package Week01;
import java.util.Scanner;
//실습1]
class Father{ // 겟,셋메소드 -> 속성을 private으로 하기때문.
String name;
int age;
String job;
public Father(String name, int age, String job){ //생성자에서 초기화를 해야함.(정답은 없음)
this.name = name;
this.age = age;
this.job = job;
}
void goToWork(int time) {
System.out.println("직업이 " + job + "인 " + age + "세 " + name + "님이 " + time + "시에 출근하다.");
}
void goOffWork(int time) {
System.out.println("직업이 " + job + "인 " + age + "세 " + name + "님이 " + time + "시에 퇴근하다.");
}
}
//실습2]
class Member{
String name; //최상위 클래스에 변수선언해야 자식클래스에서 상속받고 , 재사용 및, 다시 선언안하게됨.
Member(String name) { //속성이 있으므로 무조건 생성자를 만든다.
this.name = name;
}
String getName() { //name은 부모에 있으므로 안써도 됨.
return name;
}
void setName(String name) {
this.name = name;
}
}
class SpecialMember extends Member{
public SpecialMember(String name) {
super(name);
}
}
//실습3]
class Parent {
String name;
int age;
Hobby h;
public void setAge(int age) {
this.age = age;
}
public void setHobby(Hobby h) {
this.h = h;
}
public String toString() {
return h.setHobby();
}
public boolean equals(Object obj) {
if (obj != null && obj instanceof Child) {
return name == ((Child) obj).name;
} else
return false;
}
}
public class Child extends Parent {
Child(String name) {
this.name = name;
}
}
public class 실습3일차 {
public static void main(String[] args) {
/*•실습1: Father에 대한 클래스
- 속성:(String)name, (int)age, (String)job
- 메소드:
void goToWork(int time): ‘출근하다’ 출력
void goOffWork(int time): ‘퇴근하다’ 출력
위 클래스를 사용하여 출근하다, 퇴근하다를 출력해 보기
*/
Father ft = new Father("홍길동", 35, "개발자");
ft.goToWork(9);
ft.goOffWork(18);
/*
•실습2: 다음 클래스 설계
SpecialMember, Member
SpecialMember m = new SpecialMember(“홍길동”);
Member s = m;
s.getName(); // 홍길동
*/
SpecialMember sm = new SpecialMember("홍길동"); //"홍길동"을 인자로 받는다.
Member s = sm; //SpecialMember는 Member를 상속받는다.
System.out.println(s.getName()); // 홍길동
/*
•실습3: 다음을 만족하는 클래스를 작성
Parent, Child, Hobby, Tennis, Piano
Child c = new Child(“홍길동”);
Parent p = c; //상속관계
c.setAge(30); //child로 놓을지, parent로 놓을지는 선택의 문제.
Tennis t = new Tennis();
Hobby b = t; //hobby가 tennis의 부모. 잘알면 실체화시킬수있는 클래스로 만든다. 잘모르면 추상클래스로 만든다.
c.setHobby(t); //parent는 테니스 hobby를 t로 받고있음.
Piano p = new Piano();
Hobby b2 = p;
c.setHobby(p);
Child c2 = new Child(“홍길동”);
System.out.println(c); // 피아노
System.out.println(c.equals(c2));// true
*/
Child c = new Child("홍길동");
Parent p = c;
c.setAge(30);
Tennis t = new Tennis();
Hobby b = t;
c.setHobby(t);
System.out.println(c);
Piano p2 = new Piano();
Hobby b2 = p2;
c.setHobby(p2);
Child c2 = new Child("홍길동");
System.out.println(c); // 피아노
System.out.println(c.equals(c2));// true
}
}
-----------------------------------------------------------------------------
package Week01;
import java.util.*;
public class Switch예제 {
public static void main(String[] args) {
char gender;
String regNo = "";
System.out.println("당신의 주민번호를 입력하세요.ex)011231-1111222");
Scanner sc = new Scanner(System.in);
regNo = sc.nextLine();
gender = regNo.charAt(7); //입력받은 번호의 8번째 문자를 gender에 저장. 인덱스처리는 0번째부터 시작함.
switch(gender) {
case '1':
case '3':
switch(gender) {
case'1':
System.out.println("당신은 2000년 이전에 출생한 남자입니다.");
break; //break는 {}속해있는 블록을 탈출하는 거임.
case'3':
System.out.println("당신은 2000년 이후에 출생한 남자입니다.");
}
break; //이 break문을 빼먹지 않도록 주의
case '2':
case '4':
switch(gender) {
case'2':
System.out.println("당신은 2000년 이전에 출생한 여자입니다.");
break;
case'4':
System.out.println("당신은 2000년 이후에 출생한 여자입니다.");
break;
}
break; //이 break문을 빼먹지 않도록 주의
default: //만족하는 case가 없는경우 default 출력.
System.out.println("유효하지 않는 주민등록번호입니다.");
}
} // main의 끝
}
--------------------------------------------------------------------------
package Week01;
public class 다중For문 {
public static void main(String[] args) {
for(int i = 1; i<=5; i++) { //이 안에서 int 선언해주는 것이 좋음. 밖에서 선언할경우 에러날수도 있다. {}블록범위를 잘 파악해라.
for(int j = 1; j<=10; j++) {
System.out.print("*");
}
System.out.println();
}
}//main의 끝
}
--------------------------------------------------------------------------
package Week01;
public class Break문예제 {
public static void main(String[] args) {
int sum = 0;
int i = 0;
while(true) {
if(sum>100) //실무시 break if 조건 바로 오른쪽에. 블록반드시 쓸것.
break;
++i;
sum+=i;
}// end of while
System.out.println("i=" + i); //14
System.out.println("sum=" + sum); //105
}
}
--------------------------------------------------------------------------
package Week01;
import java.util.Scanner;
public class 반복문복합예제 {
public static void main(String[] args) {
int menu = 0;
int num = 0;
Scanner sc = new Scanner(System.in);
outer: //반복문에 이름부여. 잘안쓰임. 많이쓰면 추적하기 어려워짐.
while(true) {
System.out.println("(1)sqaure");
System.out.println("(2)sqaure root");
System.out.println("(3)log");
System.out.print("원하는 메뉴(1~3)를 선택하세요.(종료:0)");
String tmp = sc.nextLine(); //화면에서 입력받은 내용을 tmp에 저장
menu = Integer.parseInt(tmp);
if(menu==0) {
System.out.println("프로그램을 종료합니다.");
break;
} else if (!(1<=menu && menu <=3)){ //! : boolean 반대로
System.out.println("메뉴를 잘못 선택하셨습니다. (종료는 0)");
continue;
}
for(;;) {
System.out.println("계산할 값을 입력하세요(계산종료0, 전체종료99)");
tmp = sc.nextLine(); //화면에서 입력받은 내용을 tmp에 저장
num = Integer.parseInt(tmp); //입력받은 문자열(tmp)을 숫자로 변환
if(num==0)
break; //계산종료, for문을 벗어난다
if(num==99)
break outer; //전체종료, for문과 while문을 모두 벗어난다. break할 대상을 지정함.
switch(menu) {
case 1:
System.out.println("result =" + num*num);
break;
case 2:
System.out.println("result =" + Math.sqrt(num));
break;
case 3:
System.out.println("result =" + Math.log(num));
break;
}
} //for(;;)
} //while의 끝
} // main의 끝
}
--------------------------------------------------------------------------
package Week01;
public class Singleton { //싱글톤 -> 많이 쓰임. 힙에 자신의 인스턴스는 1개만 존재하도록 해놓은 규칙.
private Singleton() {}
private static Singleton instance = null;
public static synchronized Singleton getInstance() { //
if(instance == null) {
instance = new Singleton(); //단 하나의 스레드만 들어와서 실행할 수 있음.
}
return instance;
}
}
--------------------------------------------------------------------------
package Week01;
import java.util.ArrayList;
import java.util.List;
//인스턴스에 대한 카피본을 만드는 소스
public class Prototype패턴 implements Cloneable {
private List<String> userList; //userList :자바에서 제공하는 라이브러리
public Prototype패턴() {
userList = new ArrayList();
}
public Prototype패턴(List list) {
this.userList = list;
}
public void loadData() {
userList.add("1");
userList.add("2");
userList.add("3");
userList.add("4");
}
public void print() {
System.out.println(userList);
}
public List<String> getUserList(){
return userList;
}
public Object clone() throws CloneNotSupportedException{
List<String> temp = new ArrayList();
for(String s : this.getUserList()) {
temp.add(s);
}
return new Prototype패턴(temp);
}
public static void main(String[] args) throws Exception{
Prototype패턴 orginUsers = new Prototype패턴();
orginUsers.loadData();
Prototype패턴 cloneUsers = (Prototype패턴)orginUsers.clone();
cloneUsers.print();
}
}
--------------------------------------------------------------------------
package Week01;
interface A3{
int x = 100;
public static class B3{
private int y;
public B3() {
this.y = 200;
}
public void disp() {
System.out.println("x = " + x); //A.x
System.out.println("y = " + y); //this.y
}
}
}
public class Interface01예제 {
public static void main(String[] args) {
A3.B3 bp = new A3.B3();
bp.disp(); // x = 100, y = 200 출력
}
}
--------------------------------------------------------------------------
package Week01;
interface MyInterface {
default void method1() {
System.out.println("method1() in MyInterface");
}
default void method2() {
System.out.println("method2() in MyInterface");
}
static void staticMethod() {
System.out.println("staticMethod() in MyInterface"); // 인터페이스.메소드명으로 호출 static이므로 출력
}
}
interface MyInterface2{
default void method1() {
System.out.println("method1() in MyInterface2");
}
static void staticMethod() {
System.out.println("staticMethod() in MyInterface2"); // 인터페이스.메소드명으로 호출 static이므로 출력
}
}
public class Interface02예제 {
public static void main(String[] args) {
Child c = new Child();
c.method1(); // method1() in Child 출력
c.method2(); // method2() in Parent 출력
MyInterface.staticMethod(); // staticMethod() in MyInterface 출력
MyInterface2.staticMethod(); // staticMethod() in MyInterface2 출력
}
}
class Child extends Parent implements MyInterface, MyInterface2{
public void method1() {
System.out.println("method1() in Child"); //오버라이딩
}
}
class Parent{
public void method2() {
System.out.println("method2() in Parent");
}
}
--------------------------------------------------------------------------
package Week01;
import java.util.Arrays;
public class StringTest {
public static void main(String[] args) {
//여기있는 메소드를 잘 활용해라. 메소드 만드는데 시간허비하지 말것.
//1.String(char[] value) 메소드
char[] c = {'H', 'e', 'l', 'l', 'o'};
String s = new String(c);
System.out.println(s); //Hello 출력
//2.String(StringBuffer buf) 메소드 : 루프안에서는 스프링버퍼를 써야함.
StringBuffer sb = new StringBuffer("Hello");
String s2 = new String(sb);
System.out.println(s2); //Hello 출력
//3. char charAt(int index) 메소드
String s3 = "Hello";
char c2 = s3.charAt(1); //index가 0부터 시작.
System.out.println(c2); // e출력
//4. int compareTo(String str) : 사전순으로 비교 -1/0/1 -> 습관적으로 1,2개씩 바꿔가면서 해보는게 나중에 큰차이!!!(오류잡는 방법)★★★
int l = "aaa".compareTo("aaa");
int m = "aaa".compareTo("aaa1");
int n = "aaa".compareTo("aa");
System.out.println(l); // 0출력
System.out.println(m); // -1출력
System.out.println(n); // 1출력
//5. String concat(String str) : 문자열 덧붙임
String s4 = "Hello";
String s5 = s4.concat(" World");
System.out.println(s5); // Hello World 출력
//6. boolean contains(CharSequence s) : 지정된 문자열이 포함되었는지 검사
String s6 = "abcdefg";
boolean b = s6.contains("bc");
System.out.println(b); // true
//7. boolean endsWith(String suffix) : 지정된 문자열로 끝나는지 검사
String file = "Hello.txt";
boolean b2 = file.endsWith("txt");
System.out.println(b2); //true
//8. int indexOf(int ch) : 문자(ch)가 존재하는 위치(0부터 시작). 많이쓰임★★★
String s7 = "Hello";
int idx1 = s7.indexOf('o');
System.out.println(idx1); //4 출력
//9. int indexOf(int ch, int pos) : 문자(ch)가 존재하는 위치를 pos부터 확인하여 index를 알려줌
String s8 = "Hello";
int idx2 = s8.indexOf('e',0); //1
int idx3 = s8.indexOf('e',2); //-1 (e가 기준점 l로부터 왼쪽 첫번째에 있으므로 -1임)
System.out.println(idx2);
System.out.println(idx3);
//10. int indexOf(String str) : 문자열이 존재하는 위치
String s9 = "ABCDEFG";
int idx4 = s9.indexOf("CD");
System.out.println(idx4); //2 출력
//11. int lastIndexOf(int ch) : 문자를 오른쪽 끝에서 찾아서 위치리턴
String s10 = "java.lang.Object";
int idx5 = s10.lastIndexOf('.');
System.out.println(idx5); //9출력. index 순서는 왼쪽부터
//12. String replace(char old, char nw) : old문자를 nw로 변경. 많이쓰임★★★
String s11 = "Hello";
String s12 = s11.replace('H', 'C');
System.out.println(s11); //Hello
System.out.println(s12); //Cello
//13. String replaceAll(Sting regex, String nw) : 전체변경
String sb2 = "AABBAABB";
String r = sb2.replaceAll("BB", "bb");
System.out.println(r); //AAbbAAbb
//14. String replaceFirst(String regex, String nw) : 일치하는 것중 첫번째 것만 변경
String sb3 = "AABBAABB";
String r2 = sb3.replaceFirst("BB", "bb");
System.out.println(r2); //AAbbAABB
//15. String[] split(String regex) : 분리자로 나누어 배열을 반환. 많이쓰임★★★
String animals = "dog,cat/bear";
String[] arr = animals.split(",|/"); //cf. | 멀티지정 구분자.
System.out.println(arr[2]); // bear
//16. String[] split(String argex, int limit) : 분리하되 문자열을 limit 수만큼 자른다.
String animals2 = "dog, cat, bear";
String[] arr2 = animals.split(",", 2); //arr[0] : dog, arr[1] : cat, bear
//17. boolean startWith(String prefix) : 주어진 문자열로 시작하는지 검사
String s13 = "java.lang.Object";
boolean b3 = s13.startsWith("java");
System.out.println(b3);//true
//18. String trim() : 문자열의 왼쪽, 오른쪽 끝에 있는 공백을 없앤 결과를 반환. 많이쓰임★★★. R trim, L trim
String s14 = " Hello World ";
String s15 = s14.trim();
System.out.println(s15); //Hello World
//19. static String valueOf(boolean b);
// boolean대신 -> char/int/long/float/double/Object 값들이 올수있고 : 지정된 값을 문자열로 반환
String b4 = String.valueOf(123456);
System.out.println(b4); //true
//20. static String join(CharSequence arg(), CharSequence... arg1). 많이쓰임★★★. 한줄로 만들어서 보냄.
String[] arr3 = {"A", "B", "C"};
String s16 = String.join("-", arr3);
System.out.println(s16); //A-B-C
}
}
--------------------------------------------------------------------------
package Week01;
public class StringBufferTest {
public static void main(String[] args) {
// StringBufferTest
//1. StringBuffer(String str)
StringBuffer sb = new StringBuffer("H1");
System.out.println(sb); //H1
//2. StringBufer append(boolean b)
//기본자료형 / char[]/ Object /String 문자열 뒤에 붙이기
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb2.append("abc")); //abcabc
//3. char charAt(int index)
StringBuffer sb3 = new StringBuffer("abc");
char c = sb3.charAt(2);
System.out.println(c); //c
//4. StringBuffer delete(int start, int end)
//start ~ end 사이의 문자를 제거
StringBuffer sb4 = new StringBuffer("0123456");
StringBuffer c2 = sb4.delete(0, 5); // 56 (0번째에서 5번째까지 삭제)
System.out.println(c2);
//5. StringBuffer deleteCharAt(int index)
//지정된 위치의 문자 제거
StringBuffer sb5 = new StringBuffer("0123456");
StringBuffer c3 = sb5.deleteCharAt(3); //3번째 문자 제거
System.out.println(c3); // 012456
//6. StringBuffer insert(int pos, boolean b)
// boolean대신 -> char/char[]/int/long/float/double/Object/String 값들이 올수있고 : 지정된 값을 문자열로 변환하여 pos에 추가
StringBuffer sb6 = new StringBuffer("0123456");
System.out.println(sb6.insert(4, ',')); // 0123,456
//7. StringBuffer replace(int start, int end, String str)
//지정된 범위의 문자열을 주어진 문자열로 바꾼다.
StringBuffer sb7 = new StringBuffer("0123456");
System.out.println(sb7.replace(3, 6, "AB")); //012AB6
//8. StringBuffer reverse()
// 문자열 순서를 거꾸로
StringBuffer sb8 = new StringBuffer("0123456");
System.out.println(sb8.reverse()); //6543210
//9. String substring(int start)
// String substring(int start, int end) // 범위에 해당하는 값 출력.
StringBuffer sb9 = new StringBuffer("0123456");
String str = sb9.substring(3);
System.out.println(str); //3456
String str2 = sb9.substring(3,5);
System.out.println(str2); //34
}
}
