$$config title: Java2 keywords: - 12월 3일 ~ 31일 - 주말반 $$ # Java - [자바 1](https://slog.gg/p/11042) # 수업자료실 - [JDK 다운로드](https://download.oracle.com/java/19/latest/jdk-19_windows-x64_bin.exe) - [이클립스 다운로드](https://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/2022-06/R/eclipse-java-2022-06-R-win32-x86_64.zip&mirror_id=1287) - [코딩 그라운드](https://www.tutorialspoint.com/codingground.htm) - [만족도 조사](http://st.koreaedugroup.com/2019/login.asp) # 설치 - [프로그램 설치 방법](https://slog.gg/p/11043) # 12월 3일 - 1일차 ## 클래스 복습 ### 클래스 기본 > 클래스는 객체를 만들기 위한 설계도 객체는 실제 기능과 속성이 있는 사물 인스턴스는 특정 클래스로부터 생성된 객체 인스턴스화는 클래스를 가지고 객체를 생성하는것 > 클래스 이름과 소스파일과 일치 public class K1{} 소스파일과 클래스 이름 일치 class K1{} class K2{} public이 없으면 K1, K2 둘중 하나 소스파일 가능 잘못작성예시 1 public class가 두개 2 소스파일과 public class 이름이 불일치 3 대소문자를 구분하여 잘못 작성될 경우 > 클래스 이름변경 run configuation에서 main class 변경 Search에서는 만들어져있는 클래스 검색해줌 > 객체 생성 클래스명 변수명; 변수명 = new 클래스명(); K1 c; c라는 클래스의 객체를 참조하기 위한 참조변수선언 c = new K1(); 클래스의 객체를 생성 후, 객체의 주소를 참조변수에 저장 K1 c = new K1(); 선언 및 생성을 한번에 실시 int a 처럼 K1 c는 K1이라는 클레스 데이터형에 변수를 생성하는 개념 다르면 에러 발생 > 객체 생성 순서 1 클래스(설계도) 작성 2 객체를 생성 3 객체를 사용(변수, 메서드) > Car c = new Car(); Car 클래스 타입의 참조변수 c를 선언한 후 새로운 Car 인스턴스를 생성해 생성한 인스턴스의 주소를 c라는 참조변수에 저장 c라는 참조변수는 새로운 인스턴스의 컨트롤러역활을 함 >맴버 = 맴버 변수개수 + 맴버 메소드 개수 > 참조변수의 통제 Car c1 = new Car(); Car c2 = new Car(); c2 = c1; c2 = c1 c2의 주소값 즉 컨트롤러를 c1에게 넘겨줌 즉 c1과, c2가 c1에서 만들어놓은 객체를 통제함 c2에서 만들어진 객체를 통제할 수 있는 참조변수가 없음 메모리만 차지하고 있지만 정리해주는 프로그램도 있음 garbage collector 가비지 컬렉터 사용하지 않은 메모리를 스스로 찾아서 지워줌 Java에서만 지원해주고 있음 ``` java public class K1 { public static void main(String[] args) { Car c1 = new Car(); Car c2 = new Car(); c1.fuel = 10; System.out.println("c1 = "+c1.fuel+" c2 = "+c2.fuel); } } class Car{ int fuel; boolean power; String color; void fuelu() { fuel++; } } // 출력 // c1 = 10 c2 = 0 ```
> 객체의 사용 예제 두가지의 참조변수가 하나의 객체를 가리키는 경우는 가능 하나의 참조변수가 두개의 객체를 가리킬 수는 없다 불가능함 ---

### 객체 배열 객체 배열 == 참조변수 배열 Car c1, c2, c3 Car\[] carr = new Car\[3] 3개를 만들경우 일일히 만들어야 하는데 배열형태로 전체를 통제할 수 있도록 만듬 int\[] arr = new int\[3] Car\[] carr = new Car\[3] 일반적인 인트 배열의 개수 생성과 동일하다 Car\[] carr = new Car\[3] 길이가 3인 Car타입의 참조변수 배열 생성 carr\[0] = new Car() carr\[1] = new Car() carr\[2] = new Car() 객체를 생성해서 배열의 각 요소에 저장 Car\[] carr = {new Car(), new Car(), new Car()} int\[] arr = {1,2,3,4,5} 일반적인 인트 배열과 생성, 초기화 방식은 동일하다 Car\[] carr carr이라는 참조변수에 배열주소가 저장 배열 주소에 carr\[0]의주소 carr\[1]의주소, carr\[2]의주소가저장되며 그것은 new Car()로 객체의 주소가 저장
Car 타입의 배열 생성 ``` java public class K1 { public static void main(String[] args) { Car[] carr = new Car[3]; carr[0] = new Car(); carr[1] = new Car(); carr[2] = new Car(); carr[0].fuel = 1; carr[1].fuel = 5; carr[2].fuel = 15; System.out.printf("car[0] = %d, car[1] = %d, car[2] = %d" ,carr[0].fuel,carr[1].fuel,carr[2].fuel ); } } class Car{ int fuel; boolean power; String color; void fuelu() { fuel++; } } // 출력 // car[0] = 1, car[1] = 5, car[2] = 15 ```
Car타입의 for문 형식 1 ``` java public class K1 { public static void main(String[] args) { Car[] carr = new Car[3]; for(int i=0; i 객체 fuel에 int입력, print에 대한 for문형식 Car타입의 for문 형식 2 ``` java public class K1 { public static void main(String[] args) { Car[] carr = new Car[3]; for(int i=0; i
### 클래스의 정의 > 클래스 : 1. 설계도, 2. 데이터 + 함수, 3. 사용자 정의타입 > 클레스 == 데이터 + 함수 클래스 = 변수(데이터)를 함수화 함께 묶으며 서로 관련있는 변수 및 함수를 묶는다. 함수가 하는 작업 및 계산을 클래스에 있는 변수(데이터)를 가지고 한다. > 클래스 == 사용자 정의 타입 사용자(프로그래머)가 원하는 타입을 직접 만든다 시간에 대한 예로 int hour int minute int second 이렇게 선언을 하고 또다른 시간들을 저장할 개념을 만들기 위해서는 int hour1, hour2, hour3; int minute1, minute2, minute3; int second1, second2 second3; 배열을 사용한다고 하면 int\[] hour = new int\[3] int\[] minute = new int\[3] int\[] second = new int\[3] 클래스를 사용하면 Time\[] t = new Time\[3] 선언해놓고 사용하기 편리하다. ---

### 변수의 종류 선언 위치에 따른 변수의 종류 ``` java class Var{ int iv; //인스턴스 변수 (instance variable) static int cv; //클래스 변수 (class variable) void method() { int lv; //지역변수, 로컬변수 (local variable) } } ``` 클래스 영역 = 클래스의 시작과 끝 class Var{ } 메서드 영역 = 메서드의 시작과 끝 void method(){ } 클래스 영역 : 인스턴스 변수, 클래스 변수 메서드 영역 : 지역변수 CPU 에서 저장장치(SSD,HDD)를 바로 읽어들일 수 없다. CPU의 처리 속도가 너무 빠르기 때문에 RAM(메모리)이 중간에서 저장장치를 읽어 CPU에 보내준다. 클래스 변수는 RAM 즉 메모리에 올라가면 바로 사용할 수 있다. ``` java public class K1 { public static void main(String[] args) { System.out.println(Var.cv); //에러 System.out.println(Var.iv); //에러 System.out.println(Var.lv); } } class Var{ int iv; static int cv; void method() { int lv; } } // 출력 // 0 ``` > 스택(Stack) 밑이 막힌 상자를 위에서부터 쌓고 위에서부터 빼낸다 > 호출스택(Call Stack) 메서드 수행에 필요한 메모리가 제공되는 공간 메서드가 호출 되면 호출 스택에 메모리 할당 종료되면 해제 ``` java public static void main(String[] args) { System.out.println("hello"); } ``` ---
순서도 1 메인 함수 실행 2 프린트 메서드 실행, 메인함수는 대기 3 프린트 메서드 실행 후 종료 4 메인 함수 실행 5 메인 함수 종료 ---

### 변수 종류에 따른 연습 > 클래스 변수 = 하늘색 필기체 인스턴스 변수 = 밝은 하늘색 일반체 지역 변수 = 노란색 클래스 이름 = 파란색 함수 이름 = 녹색
#### 클래스 변수 연습 > 기본 ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); System.out.printf("v1 cv = %d, v2 cv = %d%n",v1.cv,v2.cv); } } class Var{ int iv = 1; static int cv = 10; void method() { int lv = 100; } } // 출력 // v1 cv = 10, v2 cv = 10 ```
>클래스.클래스 변경 모두 변경된다 ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); System.out.printf("v1 cv = %d, v2 cv = %d%n",v1.cv,v2.cv); Var.cv = 20; System.out.printf("v1 cv = %d, v2 cv = %d%n",v1.cv,v2.cv); } } // 출력 // v1 cv = 10, v2 cv = 10 v1 cv = 20, v2 cv = 20 ``` > 객체.클래스 변수 변경 모두 변경된다 ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); System.out.printf("v1 cv = %d, v2 cv = %d%n",v1.cv,v2.cv); Var.cv = 20; System.out.printf("v1 cv = %d, v2 cv = %d%n",v1.cv,v2.cv); v1.cv = 30; System.out.printf("v1 cv = %d, v2 cv = %d%n",v1.cv,v2.cv); } } // 출력 // v1 cv = 10, v2 cv = 10 v1 cv = 20, v2 cv = 20 v1 cv = 30, v2 cv = 30 ``` ---
#### 인스턴스변수 연습 > 기본 ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); } } class Var{ int iv = 1; static int cv = 10; void method() { int lv = 100; } } // 출력 // v1 iv = 1, v2 iv = 1 ```
> 클래스.인스턴스 변수 컨트롤 인스턴스 변수는 클래스로 통제 불가능 클래스는 설계도이고 객체가 생성되어야만 생성되는 변수의 컨트롤 자체가 불가능하다. ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); // 에러 Var.iv = 1; } } ```
> 객체.인스턴스 변수 = 3 변경시 인스턴스변수의 v1.iv값이 3으로 변경 v2.iv는 이전과 동일 ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v1.iv = 3; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); } } // 출력 // v1 iv = 1, v2 iv = 1 v1 iv = 3, v2 iv = 1 ```
> v2.iv = v1.iv; 개념은 v1.iv의 값을 v2.iv값에 넣어라 동일하게 3으로 출력 ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v1.iv = 3; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v2.iv = v1.iv; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); } } // 출력 // v1 iv = 1, v2 iv = 1 v1 iv = 3, v2 iv = 1 v1 iv = 3, v2 iv = 3 ```
> v1.iv를 5로 변경하면 v1.iv만 변경되고 v2.iv는 변경되지 않음 ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v1.iv = 3; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v2.iv = v1.iv; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v1.iv = 5; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); } } // 출력 // v1 iv = 1, v2 iv = 1 v1 iv = 3, v2 iv = 1 v1 iv = 3, v2 iv = 3 v1 iv = 5, v2 iv = 3 ```
> 기본으로 잡고 v2 = v1후 변환 v2 에 v1의 주소값이 들어가고 v2가 컨트롤 할 수 있게 된다. 즉 v2는 없어짐 ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); v1.iv = 3; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v2.iv = 5; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v2 = v1; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); } } // 출력 // v1 iv = 3, v2 iv = 1 v1 iv = 3, v2 iv = 5 v1 iv = 3, v2 iv = 3 ``` > v2의 인스턴스 변화 v2에서 변수의 값을 변화시키면 v1도 v2와 동일한 주소값을 가지고 있다. ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); v1.iv = 3; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v2.iv = 5; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v2 = v1; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); v2.iv = 1; System.out.printf("v1 iv = %d, v2 iv = %d%n",v1.iv,v2.iv); } } // 출력 // v1 iv = 3, v2 iv = 1 v1 iv = 3, v2 iv = 5 v1 iv = 3, v2 iv = 3 v1 iv = 1, v2 iv = 1 ``` ---
#### 지역변수 연습 > 기본 f메서드가 int형 매개변수를 받아서 실행하는 형태 ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); System.out.println(v1.f(10)); System.out.println(v2.f(5)); } } class Var{ int iv = 1; static int cv = 10; int f(int a) { int lv = 100; return a+lv; } } // 출력 // 110 105 ```
> 인스턴스 변수와 지역변수의 혼합 f메서드가 클래스 내부의 인스턴스 변수와 연동되도록 선정 ``` java public class K1 { public static void main(String[] args) { Var v1 = new Var(); Var v2 = new Var(); System.out.print(v1.f()); System.out.print(" "+v2.f()+"%n\n"); //%n은 printf에서만 사용가능 v1.iv = 50; System.out.print(v1.f()); System.out.print(" "+v2.f()); } } class Var{ int iv = 1; static int cv = 10; int f() { int lv = 100; return iv+lv; } } // 출력 // 101 101%n 150 101 ```
> 함수의 매개변수와 지역변수의 혼합 메서드 안에서 매개변수와 동일한 이름의 지역변수를 만들수 없다 if문에서 만든 지역변수를 else if에서 쓸수 없다 초기화 되지 않은 지역변수를 프린터 할수 없다 클래스의 변수는 (클래스변수, 인스턴스변수) 생성되어 지면서 초기화 된다 배열과 동일하게보면됨 ``` java public class K1 { public static void main(String[] args) { Var v = new Var(); v.iv1 =2; v.f(1); // 2+1 *10 v.f(2); // 2-1 *20 v.f(5); // 0 } } class Var{ int iv1 = 1; int iv2 = 1; static int cv = 10; void f(int a) { int p; if (a==1) { // int a; //에러 매개변수와 동일한 이름임 int a1 = 10; p = (iv1 + iv2)*a1; //f함수의 지역변수 p를 통제 } else if (a==2) { int a1 = 20; // if문 에서의 지역변수임 else if는에서는 사용가능 p = (iv1 - iv2)*a1; } // System.out.println(p); //에러 초기화 안됨 // 인스턴스변수는 자동적으로 초기화 됨 기본값으로 else { //if문 중간에 다른 식이 있고 else하면 오류 p=0; } System.out.println(p); } } // 출력 // 30 20 0 ``` ---

### 변수종류관련 연습문제 #### 연습문제 1-1 > 다음과 같이 메인함수를 사용했을때 출력될 수 있도록 클래스 변수와 인스턴스 변수를 선언하시오 ``` java public static void main(String[] args) { C c1 = new C(); C c2 = new C(); c1.a = 1; c1.b = 2; System.out.println("c1 a = "+c1.a+" b = "+c1.b); System.out.println("c2 a = "+c2.a+" b = "+c2.b); } // 출력 // c1 a = 1 b = 2 c2 a = 0 b = 2 ``` 연습문제 1-1 정답 ``` java public class K1 { public static void main(String[] args) { C c1 = new C(); C c2 = new C(); c1.a = 1; c1.b = 2; System.out.println("c1 a = "+c1.a+" b = "+c1.b); System.out.println("c2 a = "+c2.a+" b = "+c2.b); } } class C{ int a; static int b; } // 출력 // c1 a = 1 b = 2 c2 a = 0 b = 2 ``` ---
#### 연습문제 1-2 > 출력을 할 수 있는 pr() 함수를 만들어보기 반환은 없고 스트링으로 받아서 클래스내 함수 출력 ``` java public static void main(String[] args) { C c1 = new C(); C c2 = new C(); c1.a = 1; c1.b = 2; c1.pr("c1"); c2.pr("c2"); } // 출력 // c1 a = 1, b = 2 c2 a = 0, b = 2 ``` 연습문제 1-2 정답 ``` java public class K1 { public static void main(String[] args) { C c1 = new C(); C c2 = new C(); c1.a = 1; c1.b = 2; c1.pr("c1"); c2.pr("c2"); } } class C{ int a; static int b; void pr(String x) { System.out.printf("%s a = %d, b = %d%n",x,a,b); } } // 출력 // c1 a = 1, b = 2 c2 a = 0, b = 2 ``` ---
#### 연습문제 1-3 > 클래스 배열을 만들고 배열의 매개변수는 c로하고 객체를 5개 생성하시오 for문으로 ``` java public static void main(String[] args) { C[] c = new C[5]; for (int i = 0; i #### 연습문제 1-4 > a라는 인스턴스 변수에 1~5 저장하는 for문만들기 ``` java public static void main(String[] args) { C[] c = new C[5]; for (int i = 0; i #### 연습문제 1-5 > 동일한 for문을 하나로 만들고 pr()을 for문과 연동시켜서 c\[0] a = 1, b = 0 반복해서 출력되도록 하기 System.out.println("a"+"b"+1) 여기서 "a"+"b"+1 = ab1로 하나의 스트링임 ``` java public static void main(String[] args) { C[] c = new C[5]; for (int i = 0; i #### 연습문제 1-6 > 클래스는 건들지 않은상태로 c\[0] a = 1, b =0 에서 b = a\*2형태로 출력 예시 a = 1 b = 2 a = 2 b = 4 ``` java public static void main(String[] args) { C[] c = new C[5]; for (int i = 0; i

# 12월 4일 - 2일차
#### 연습문제 2-1 > 클래스 C생성 클래스 변수로 int 타입 인스턴스 변수로 int\[] 선언 배열의 개수는 클래스 변수 int의 값을 받음 ``` java public class K1 { public static void main(String[] args) { C c = new C(); System.out.println(Arrays.toString(c.arr)); } } class C{ static int a; int[] arr = new int[a]; } // 출력 // [] ``` ---
#### 연습문제 2-2 > 3개 짜리 배열을 생성하게 끔 메인 함수에 추가하시오 ``` java public static void main(String[] args) { C.a = 3; C c = new C(); System.out.println(Arrays.toString(c.arr)); } // 출력 // [0, 0, 0] ``` ---
#### 연습문제 2-3 > prarr()하면 arr이 출력되게 함수를 작성하시오 ``` java public class K1 { public static void main(String[] args) { C.a = 3; C c = new C(); c.prarr(); } } class C{ static int a; int[] arr = new int[a]; void prarr() { System.out.println(Arrays.toString(arr)); } } // 출력 // [0, 0, 0] ``` ---
#### 연습문제 2-4 > 두번째 객체는 5개짜리 배열이 생성되도록 하시고 새로운 객체를 만드시오 클래스 변수를 변경하고 새로운 객체를 생성하면 자연스럽게 클래스 변수의 변화에 따라 연동 ``` java public static void main(String[] args) { C.a = 3; C c1 = new C(); // c1.a = 5; 동일 C.a = 5; C c2 = new C(); c1.prarr(); c2.prarr(); } // 출력 // [0, 0, 0] [0, 0, 0, 0, 0] ``` ---
#### 연습문제 2-5 > 클래스 배열을 3개 만들고 클래스 배열안의 각 객체 배열은 3,6,9사이즈로 만드시오 배열 출력도 가능하게 for문을 구성 ``` java public static void main(String[] args) { C[] c = new C[3]; int size = 3; for(int i = 0; i #### 연습문제 2-6 >0~9까지의 랜덤한 값이 각각의 배열에 저장되도록하고 프린터해주는 for문은 따로 만드시오 > Math.random() 은 0.xxx ~ 1까지의 랜덤 (int)Math.random()은 인트로 변경해줌 (int)Math.random()\*9 ?? ``` java public class K1 { public static void main(String[] args) { C[] c = new C[3]; int size = 3; for(int i = 0; i #### 연습문제 2-7 >1 ~ 10까지로 랜덤을 변경해 보기 ``` java for(int j=0; j #### 연습문제 2-8 > 평균 출력 새로 for문에 작성 또는 출력 되는 for 문에 작성해도 됨 ``` java for(int i = 0; i #### 연습문제 2 전체 ``` java public class K1 { public static void main(String[] args) { C[] c = new C[3]; int size = 3; for(int i = 0; i
#### 연습문제 3-1 > 클래스를 3개의 인트형 변수로 제작하였고 다음과 같이 메인을 작성해보니 아래와 같은 결과가 나왔다. a,b,c는 각각 어떤 형태의 변수 인지 생각해보고 클래스를 작성해 보세요 ``` java public static void main(String[] args) { C.a = 10; C c1 = new C(); c1.a = 5; C c2 = new C(); c1.b = 5; System.out.printf("c1 a = %d, b = %d, c = %d%n",c1.a,c1.b,c1.c); System.out.printf("c2 a = %d, b = %d, c = %d%n",c2.a,c2.b,c2.c); } // 출력 // c1 a = 5, b = 5, c = 10 c2 a = 5, b = 1, c = 5 ``` 연습문제 3-1 정답 ``` java class C{ static int a; int b=1; int c = a; } ``` ---
#### 연습문제 3-2 > ``` java public static void main(String[] args) { C.a = 10; C c1 = new C(); c1.a = 5; C c2 = new C(); c1.b = 5; System.out.printf("c1 a = %d, b = %d, c = %d%n",c1.a,c1.b,c1.c); System.out.printf("c2 a = %d, b = %d, c = %d%n",c2.a,c2.b,c2.c); } // 출력 // c1 a = 5, b = 5, c = 12 c2 a = 5, b = 2, c = 7 ``` 연습문제 3-2 정답 ``` java class C{ static int a; int b=2; int c = a; } ``` ### 매개변수 및 반환타입
#### 기본형 매개변수 > 기본형 매개변수 : 변수의 값을 읽기만 할 수 있다. ``` java class Data{int x;} public class K1 { public static void main(String[] args) { Data d = new Data(); System.out.println("Data클래스 실행 : "+d.x); d.x = 10; System.out.println("x값 변경 : "+d.x); // ch함수를 static으로 하지 않았을때 설정해줘야함 // K1 k = new K1(); // k.ch(d.x); ch(d.x); System.out.println("ch이후 x값 확인 : "+d.x); } static void ch(int x) { x = 1000; System.out.println("ch함수 실행 x : "+x); } } // 출력 // Data클래스 실행 : 0 x값 변경 : 10 ch함수 실행 x : 1000 ch이후 x값 확인 : 10 ``` Data d = new Data(); Data타입으로 d라는 매개변수를 만들고 매개변수 d에 Data() 객체를 만들어서 저장 d.x=10; d에 저장된 Data의 객체의 변수 x값을 변경 ch(d.x); ch의 함수를 실행 시키는데 인수를 d.x로 지정 static void ch(int x) ch함수가 실행될데 int x라는 매개변수를 받는데 그 int x가 d.x의 값을 받음 x = 1000; 받은 x라는 변수에 1000을 대입 이때 프린트 되는 것은 매개변수에서 받은 값이 1000으로 바뀌어서 실행되는 것이고 함수 이후에서는 본래 10이 저장된 d.x를 출력 ch(int x) - ch(d.x) 주소를 받는 것이 아니라 d.x의 값을 받는 모습으로 x = 1000; 으로 값을 변경한다고해서 d.x는 변경되는 것이 아님 ---
#### 참조형 매개변수 > 변수의 값을 읽고 변경할 수 있다. ``` java class Data{int x;} public class K1 { public static void main(String[] args) { Data d = new Data(); System.out.println("Data클래스 실행 : "+d.x); d.x = 10; System.out.println("x값 변경 : "+d.x); ch(d); System.out.println("ch이후 x값 확인 : "+d.x); } static void ch(Data x) { x.x = 1000; System.out.println("ch함수 실행 x : "+x.x); } } // 출력 // Data클래스 실행 : 0 x값 변경 : 10 ch함수 실행 x : 1000 ch이후 x값 확인 : 1000 ``` Data d = new Data(); Data타입으로 d라는 매개변수를 만들고 매개변수 d에 Data() 객체를 만들어서 저장 d.x=10; d에 저장된 Data의 객체의 변수 x값을 변경 ch(d); ch의 함수를 실행 시키는데 인수를 d로 지정 static void ch(Data x) Data 타입의 x라는 매개변수를 받음 int a는 int타입의 a라는 매개변수를 받음 ch함수가 실행될데 Data x라는 매개변수를 받는데 그 Data x가 d의 값을 받음 즉 주소값을 받음 x.x = 1000; 받은 x에서 자신이 가르키는 x 변수에 1000을 대입 이때 프린트 되는 것은 x라는 주소가 가르키는 x의 값을 1000으로 변경해서 그것을 프린트 이후 프린트는 d라는 참조변수가 가르키는 x를 프린트
#### 연습문제 1-1 >int a, String b로 클래스 C 만들고 메인에 C클래스 타입으로 5개짜리 배열 만들기 K1클래스에 함수 ist_m만들기 인스턴스 만드는 함수 제작 ``` java package javapj; import java.util.*; class C{ int a; String b; } public class K1{ public static void main(String[] args) { C[] c = new C[5]; } static void ist_m(C[] x) { for (int i = 0; i #### 연습문제 1-2 > a,b를 출력하는 함수 제작 ist_pr 1번째 데이터 a, 과일이름 ``` java static void ist_pr(C[] x) { for (int i = 0; i #### 연습문제 1-3 > 데이터를 입력하는 함수 제작 a에 4의 배수이면서 6의 배수의 수를 입력 ``` java static void ist_d(C[] x) { int c=0; for (int i=0; i #### 연습문제 1-4 > 과일이름을 입력받아서 저장 5글자 이상은 범위를 벗어났습니다. 출력 1번째 과일이름 작성 : 사과딸기기타 범위를 벗어났습니다. 1번째 과일이름 작성 : 사과가좋아죽게다 범위를 벗어났습니다. 1번째 과일이름 작성 : 사과 2번째 과일이름 작성 : 바나나 3번째 과일이름 작성 : 파인에플 4번째 과일이름 작성 : 배 5번째 과일이름 작성 : 수박 1번째 데이터 12, 과일이름 : 사과 2번째 데이터 24, 과일이름 : 바나나 3번째 데이터 36, 과일이름 : 파인에플 4번째 데이터 48, 과일이름 : 배 5번째 데이터 60, 과일이름 : 수박 총계 ``` java package javapj; import java.util.*; class C{ int a; String b; } public class K1{ public static void main(String[] args) { C[] c = new C[5]; ist_m(c); ist_d(c); ist_f(c); ist_pr(c); } static void ist_m(C[] x) { for (int i = 0; i

# 12월 10일 - 3일차 ### 참조형 반환타입 >반환타입 자체가 참조형이고 매개변수도 참조형임 ``` java package javapj; class Data{ int x; } public class K1 { public static void main(String[] args) { Data d = new Data(); d.x = 10; Data d2 = cp(d); System.out.println("d.x = "+d.x); System.out.println("d2.x = "+d2.x); } static Data cp(Data a){ Data tmp = new Data(); tmp.x = a.x; // 이번식이 없었으면 d2.x는 0 return tmp; } } // 출력 // d.x = 10 d2.x = 10 ``` Data d = new Data(); Data 타입의 d라는 매개변수를 생성하여 매개변수 d에 Data() 객체를 만들어서 저장 d.x = 10; d라는 객체에 x라는 인스턴스 변수의 값을 10으로 저장 static Data cp(Data a); cp라는 함수를 만드는데 그것은 Data 타입으로 반환하는 함수임 또한 Data 타입의 a를 매개변수(인자)로사용 Data tmp = new Data(); Data 타입으로 tmp라는 매개변수(지역 매개변수)를 만들고 객체를 Data()클래스로 만들어서 주소값을 tmp에 저장 cp(Data a) tmp.x = a.x; cp(d); tmp라는 지역 매개변수(주소)에서 x라는 변수의 값에 a, 즉 cp함수를 실행시키는 Data타입의 a라는 매개변수(주소)에서 x라는 변수를 저장한다. return tmp; cp함수는 tmp라는 Data타입의 주소값을 반환한다. Data d2 = cp(d); cp에서 반환 값이 d2에 저장된다 d.x와 d2.x를 출력 하면 동일한값이 나온다. cp 함수에 tmp.x = a.x 가 없었더라면 d2.x = 0임
>d.x의 값을 바꾸면?? d2는 변경되지 않는다. 주소값으로 연결되어 있지 않기 때문에 ``` java class Data{int x;} public class K1 { public static void main(String[] args) { Data d = new Data(); d.x = 10; Data d2 = cp(d); System.out.println("d.x = "+d.x); System.out.println("d2.x = "+d2.x); System.out.println(); d.x = 20; System.out.println("d.x = "+d.x); System.out.println("d2.x = "+d2.x); } static Data cp(Data a){ Data tmp = new Data(); tmp.x = a.x; // 이번식이 없었으면 d2.x는 0 return tmp; } } // 출력 // d.x = 10 d2.x = 10 d.x = 20 d2.x = 10 ```
>Data에 y라는 변수를 추가해 준다면? y는 기본값으로 나온다. cp함수가 x의 값만 변경해 주었기 때문에 ``` java class Data{int x; int y;} public class K1 { public static void main(String[] args) { Data d = new Data(); d.x = 10; d.y = 5; Data d2 = cp(d); System.out.printf("d.x = %d d.y = %d%n",d.x,d.y); System.out.printf("d2.x = %d d2.y = %d",d2.x,d2.y); System.out.println(); } static Data cp(Data a){ Data tmp = new Data(); tmp.x = a.x; return tmp; } } // 출력 // d.x = 10 d.y = 5 d2.x = 10 d2.y = 0 ```
> Data cp(Data a) 함수에 tmp = a;로 넣으면? 주소값이 그대로 복사됨 ``` java class Data{int x; int y;} public class K1 { public static void main(String[] args) { Data d = new Data(); d.x = 10; d.y = 5; Data d2 = cp(d); System.out.printf("d.x = %d d.y = %d%n",d.x,d.y); System.out.printf("d2.x = %d d2.y = %d",d2.x,d2.y); System.out.println(); } static Data cp(Data a){ Data tmp = new Data(); tmp = a; return tmp; } } // 출력 // d.x = 10 d.y = 5 d2.x = 10 d2.y = 5 ```
> d2.x = 1; d2.y = 1;로 변경시킨다면 주소값이 연동되어있는 즉 d의 컨트롤을 d2가 받음 ``` java public static void main(String[] args) { Data d = new Data(); d.x = 10; d.y = 5; Data d2 = cp(d); d2.x = 1; d2.y = 1; System.out.printf("d.x = %d d.y = %d%n",d.x,d.y); System.out.printf("d2.x = %d d2.y = %d",d2.x,d2.y); System.out.println(); } // 출력 // d.x = 1 d.y = 1 d2.x = 1 d2.y = 1 ``` ---

> static 메서드 : 같은 클래스에 main, cp는 static메서드로 참조변수가 없으며, 동일 클래스에 있어서 참조변수를 생략할 수 있다. 객체 생성없이 호출이 가능하다. ``` java K1 a = new K1(); a.cp(d); ``` ### static 메서드와 인스턴스 메서드 > 간단히 static이 붙은것을 static 메서드라고 함. > 인스턴스 메서드 인스턴스(객체) 생성 후 객체의 주소를 저장하는 참조변수.메서드이름() 으로 인스턴스 맴버 (인스턴스 변수, 인스턴스 메서드)와 관련된 작업을 하는 메서드, 메서드 내에서 인스턴스 변수 사용가능 예) Scanner sc = new Scanner(System.in) sc.nextInt() >static 메서드(클래스 메서드) 객체 생성 없이 클래스 이름.메서드 이름()으로 호출 예) Math.random() 인스턴스 맴버 (인스턴스 변수, 인스턴스 메서드)와 관련없음 메서드 내에서 인스턴스 변수 사용불가 ``` java class C{ int a, b; int add() { // 인스턴스 메서드 return a+b; //인스턴스 변수 } int add2(int a, int b) { // 인스턴스 메서드, 지역변수를 매개변수로 갖음 return a+b; // 지역변수 } static int add3(int a, int b) { //클래스 메서드 return a+b; //지역변수 } /* static int add4() { //클래스 메서드 return a+b; //지역변수를 사용해야 되지만 클래스 메서드임 // 오류발생 } */ static int add4() { return c+d; } // 클래스 변수는 사용가능 } ``` 인스턴스 메서드는 기본적으로 인스턴스 변수를 쓴다 매개변수가 있을 경우 인스턴스 변수와 매개변수의 변수이름이 동일시 가까운 매개변수(지역변수)를 사용 클래스 메서드는 기본적으로 지역변수, 클래스 변수를 사용 인스턴스 메서드를 사용할 경우 에러 ``` java public static void main(String[] args) { System.out.println("class add3 = "+C.add3(5, 7)); C c = new C(); c.a = 1; c.b = 2; System.out.println("add1 = "+c.add()); System.out.println("add2 = "+c.add2(10, 20)); System.out.println("add3 = "+c.add3(10, 30)); C.c = 100; C.d = 200; System.out.println("add4 = "+C.add4()); } } class C{ static int c,d; int a, b; int add() { // 인스턴스 메서드 return a+b; //인스턴스 변수 } int add2(int a, int b) { // 인스턴스 메서드, 지역변수를 매개변수로 갖음 return a+b; // 지역변수 } static int add3(int a, int b) { //클래스 메서드 return a+b; //지역변수 } /* static int add4() { //클래스 메서드 return a+b; //지역변수를 사용해야 되지만 클래스 메서드임 // 오류발생 } */ static int add4() { return c+d; } // 클래스 변수는 사용가능 } // 출력 // class add3 = 12 add1 = 3 add2 = 30 add3 = 40 add4 = 300 ``` 인스턴스 변수를 클래스 메서드로 사용하지 못하는 이유 인스턴스 변수는 객체 생성시 만들어 지므로 오류 보통 객체는 인스턴스 변수와 인스턴스 메서드를 통제하는게 기본 클래스 변수, 클래스 메서드는 쉽게 보면 객체와는 크게 상관없이 사용하려고 만듬 인스턴스 메서드는 객체별 통제하기 위해 보통 작성한다.
> static을 붙이는 것은 속성 중에 공통 속성에 static을 붙인다 인스턴스 멤버를 사용하지 않는 메서드에 붙인다. 클래스 변수만을 사용하는 메서드에 static을 사용하지 않게 될 경우 불필요하게 객체를 만들어줘야 사용할 수 있음 static 메서드에서 인스턴스 메서드를 호출할 수 없다. 객체가 필요한 메서드 이기 때문이다. 인스턴스 메서드는 static 메서드를 호출할 수 있다. ---

## 오버로딩(overloading) > 한 클래스 안에 같은 이름의 메서드 여러개 정의 overloading 과적하다 본래 메서드 : 메서드 이름은 1:1 이름은 같고 매개변수가 다양한것 println의 인수를 보고 거기에 맞게 변경 컴파일이 어떤 인수를 판단해서 매칭시켜줌 ``` java void println() void println(boolean x) void println(char x) void println(char[] x) void println(double x) void println(float x) void println(int x) void println(long x) void println(String x) ``` 오버로딩이 없었더라면 메서드의 이름이 바뀌었을 것이다. ``` java void println() void println_bool(boolean x) void println_ch(char x) void println_charr(char[] x) void println_fl(float x) void println_in(int x) void println_lg(long x) void println_st(String x) ```
### 오버로딩의 성립 조건 >1 메서드의 이름이 같아야한다. 2 매개변수의 개수 또는 타입이 달라야한다. 3 반환타입은 영향 없다. 이름은 같고 매개변수 개수도 같다. 타입도 같다 변수이름만 다름 이런경우 오버로딩 아님 / 메서드 중복 정의 컴파일 에러 (이미 정의되어 있다) ``` java int add(int a, int b){return a+b;} int add(int x, int y){return x+y;} ``` 이름은 같고 반환타입이 다름 / 메서드 중복 정의 ``` java int add(int a, int b){return a+b;} long add(int a, int b){return (long)(a+b);} ``` 이름 같고 매개변수 타입이 다름 성립 / 오버로딩 ``` java int add(int a, int b){return a+b;} int add(long a, int b){return (int)(a+b);} //int없으면 에러 반환타입 // long 반환타입설정하고 int로 반환해도 상관없음 ``` 만약 add(2,3)을 불러들이면 어떤건지 컴파일이 판단할 수 없다 add(2,3L)하면 첫번째거 불러들임 ``` java long add(int a, long b){return a+b;} long add(long a, int b){return a+b;} ``` ambigus(모호한) ``` java public class K1{ public static void main(String[] args) { K1 k = new K1(); long a = k.add(2,3); //에러 모호한 } long add(int a, long b){return a+b;} long add(long a, int b){return a+b;} } ```
#### 연습문제 1 > add int 타입 반환 add long 타입 반환 add int\[] 타입 반환 ``` java public class K1{ public static void main(String[] args) { K1 k = new K1(); int[] a = {10,20,12,41,52}; System.out.println(k.add(a)); System.out.println(k.add(10,12)); System.out.println(k.add(1.2f, 2.0f)); } int add(int a, int b){ System.out.print("int add "); return a+b; } float add(float a, float b){ System.out.print("float add "); return a+b; } int add(int[] a) { System.out.print("int[] add "); int result = 0; for(int i = 0; i ---

# 12월 11일 - 4일차 #### 연습문제 1 > add int 타입 반환 add long 타입 반환 add int\[] 타입 반환 ``` java public class K1{ public static void main(String[] args) { K1 k = new K1(); int[] a = {10,20,12,41,52}; System.out.println(k.add(a)); System.out.println(k.add(10,12)); System.out.println(k.add(1.2f, 2.0f)); } int add(int a, int b){ System.out.print("int add "); return a+b; } float add(float a, float b){ System.out.print("float add "); return a+b; } int add(int[] a) { System.out.print("int[] add "); int result = 0; for(int i = 0; i 프린트 함수가 실행되기 위해서는 k.add(a) 가 실행되어야 하고 먼저 k.add(a)가 실행되고 프린트 함수가 실행됨 ``` java int[] a = {10,20,12,41,52}; System.out.println("프린트 함수 "+k.add(a)); // 출력 // int[] add 프린트 함수 135 ```
#### 연습문제 2-1 > 배열의 평균을 구하는 함수구현 반환 값은 float 배열 = int 반환 값은 float 배열 = float ``` java public class K1 { public static void main(String[] args) { int[] iarr = {12,14,13,15}; float[] farr = {12.3f,10.2f,11.3f,10}; System.out.printf("평균 = %.2f\n",avg(iarr)); System.out.printf("평균 = %.2f",avg(farr)); } static float avg(int[] a) { float avg; int s = 0; for(int i = 0; i #### 연습문제 2-2 > float로 받았을 때는 합계을 반환으로 변경 ``` java public static void main(String[] args) { int[] iarr = {12,14,13,15}; float[] farr = {12.3f,10.2f,11.3f,10}; System.out.printf("평균 = %.2f\n",avg(iarr)); System.out.printf("합계 = %.2f",avg(farr)); } static float avg(int[] a) { float avg; int s = 0; for(int i = 0; i #### 연습문제 3-1 > 반환업는 함수 int 1개를 a 매개변수로 하면 구구단이 출력 (2~a단) int 2개를 매개변수로 하면 구구단이 출력 (a~ b단) ``` java public class K1 { public static void main(String[] args) { gugu(3); System.out.println(); gugu(2,4); } static void gugu(int a) { for(int i = 2; i<=a; i++) { for(int j = 1; j<10; j++) { System.out.printf("%dx%d=%d ",i,j,i*j); } System.out.println(); } } static void gugu(int a, int b) { for(int i = a; i<=b; i++) { for(int j = 1; j<10; j++) { System.out.printf("%dx%d=%d ",i,j,i*j); } System.out.println(); } } } // 출력 // 2x1=2 2x2=4 2x3=6 2x4=8 2x5=10 2x6=12 2x7=14 2x8=16 2x9=18 3x1=3 3x2=6 3x3=9 3x4=12 3x5=15 3x6=18 3x7=21 3x8=24 3x9=27 2x1=2 2x2=4 2x3=6 2x4=8 2x5=10 2x6=12 2x7=14 2x8=16 2x9=18 3x1=3 3x2=6 3x3=9 3x4=12 3x5=15 3x6=18 3x7=21 3x8=24 3x9=27 4x1=4 4x2=8 4x3=12 4x4=16 4x5=20 4x6=24 4x7=28 4x8=32 4x9=36 ```
#### 연습문제 3-2 > 만약 a가 b보다 크다면 잘못 입력 출력 ``` java public static void main(String[] args) { gugu(3); System.out.println(); gugu(5,4); } static void gugu(int a) { for(int i = 2; i<=a; i++) { for(int j = 1; j<10; j++) { System.out.printf("%dx%d=%d ",i,j,i*j); } System.out.println(); } } static void gugu(int a, int b) { if (a>b) { System.out.println("잘못된 입력입니다."); return; } for(int i = a; i<=b; i++) { for(int j = 1; j<10; j++) { System.out.printf("%dx%d=%d ",i,j,i*j); } System.out.println(); } } } // 출력 // 2x1=2 2x2=4 2x3=6 2x4=8 2x5=10 2x6=12 2x7=14 2x8=16 2x9=18 3x1=3 3x2=6 3x3=9 3x4=12 3x5=15 3x6=18 3x7=21 3x8=24 3x9=27 잘못된 입력입니다. ``` ---

## 생성자, 기본생성자 생성자(constructor) : 건설자 > 인스턴스가 생성될 때마다 호출 되는 인스턴스 초기화 메서드 객체는 인스턴스 변수 묶음 객체 생성 하고 인스턴스변수 초기화 해주었는데 한번에 즉 생성과 동시에 초기화 혹은 값을 넣어서 객체를 생성하는데 생성자가 쓰인다. >Time t = new Time(); t.h = 12; t.m = 20; t.s = 52; Time t = new Time(12, 20, 52); > 생성자 호출 Time();, Time(12, 20, 52); > 생성자 : 인스턴스 생성시 수행할 작업에 사용 꼭 초기화만 할 필요는 없다. 일반적으로 생성자가 하는 일은 인스턴스 초기화 지만 원하는 작업들을 넣어서 사용할 수 도 있다. (메서드 니까) 생성자를 만들어주지 않으면 기본적으로 컴파일러가 생성자를 자동으로 세팅 해줘서 인스턴스를 생성함. > 생성자는 인스턴스 초기화를 편리하게 하거나 추가적으로 생성될 때 필요한 작업을 하기 위해
### 생성자 작성간 주의사항 1 이름이 클래스 이름과 같아야 한다. 2 리턴값이 없다(void 안붙임) : 대입문이기 때문에 리턴이 없음 3 모든 클래스는 반드시 생성자를 가져야 한다. > 클래스 이름(타입 변수명, 타입변수명){ 인스턴스 생성시 수행될 코드 } 매개변수가 있는 생성자든, 매개변수가 없는 생성자 차이 오버로딩으로 둘다 생성자를 만들어 줘도 됨 > 리턴값이 없는 것은 반환값이 없어서 void를 안붙인것 확인 일반적인 규칙임 >Time t = new Time(); Time() <- 자체가 생성자를 호출하는 것이다. 컴파일러가 기본생성자를 자동으로 만들어 준것임
### 기본 생성자 > 매개변수가 없는 생성자 생성자가 하나도 없을 때만 컴파일러가 자동추가 다른 생성자를 만들어 주면 기본생성자를 추가 시키지 않음 생성자가 하나도 없으면 컴파일러가 자동추가 ``` java class Cl1{ int a; } class Cl2{ int a; Cl2(int x){ a = x; } } public class K1{ public static void main(String[] args) { Cl1 c1 = new Cl1(); // Cl2 c2 = new Cl2(); // compile error // 생성자를 찾을 수 없다. } } ```
문제 해결 ``` java class Cl1{ int a; } class Cl2{ int a; Cl2(){ a = 0; } Cl2(int x){ a = x; } } public class K1{ public static void main(String[] args) { Cl1 c1 = new Cl1(); Cl2 c2 = new Cl2(); } } ``` ---

### 매개변수가 있는 생성자 ``` java class Time{ int h; int m; int s; Time(){} Time(int a, int b, int c){ h=a; m=b; s=c; } } public class K1{ public static void main(String[] args) { Time t1 = new Time(); Time t2 = new Time(3,20,10); System.out.printf("t1 = %d:%d:%d\n",t1.h,t1.m,t1.s); System.out.printf("t2 = %d:%d:%d",t2.h,t2.m,t2.s); } } // 출력 // t1 = 0:0:0 t2 = 3:20:10 ``` ---

### 생성자 this() > 생성자에서 다른 생성자 호출 시 사용 코드의 중복을 제거하기 위해서 생성자끼리 서로를 호출함 String = 색, float = 크기, int = 문 Car 클래스 생성 생성자는 기본생성자, 3개의 매개변수가 있는 생성자 ``` java class Car{ String color; float size; int door; Car(){ } Car(String a, float b, int c){ color = a; size = b; door = c; } } ```
> Car(){ color = "파랑"; size = 1.2f; door = 2; } 생성자 this() 사용시 this("파랑", 1.2f, 2); 생성자 this 사용법 ``` java class Car{ String color; float size; int door; Car(){ this("검정",15.3f,4); // float에 정수넣어도 됨 } Car(int a){ this("파랑",12.2f,a); } Car(String a, float b, int c){ color = a; size = b; door = c; } } ``` >this(); 의 의미 내가 가지고 있는 생성자를 호출 > this() 는 첫번째 줄에만 생성해야 함 클래스 내부 메서드를 사용하기 위해서는 void a(int a){} Car(){a(a)} 클래스 내부 생성자 메서드를 가져오기 위해서는 this()로 작성해야함 Car(int a)를 불러오기 위해서는 Car(){this(4);} 작성하면 됨 ---

### 참조변수 this > 인스턴스 자신을 가리키는 참조 변수 인스턴스 메서드(생성자 포함)에서 사용가능 지역변수와 인스턴스 변수를 구별할 때 사용 >this() 는 생성자 this는 참조변수 개념 자체가 다름 연관이 없음 ``` java class Car{ String a; float b; int c; Car(String a, float b, int c){ a = a; //인스턴스 변수를 가져와야 하는데, 지역변수만 들어감 b = b; c = c; } } ``` 가까운 변수이름인 지역변수만 선택하게됨 이때 this.a로 사용하면 인스턴스의 메서드를 가르킴 본래 대로면 참조변수.변수명으로 불러들여야함 this는 생략가능 (같은 클래스) ``` java class Car{ String a; float b; int c; Car(String a, float b, int c){ this.a = a; this.b = b; this.c = c; } } ```
객체가 생성되지 않았기 때문에 참조변수를 사용할 수 없음 물론 인스턴스 변수는 참조할 수 없음 그것을 this로 사용한다고 판단하면 됨 > 다른 클래스에서도 인스턴스 변수를 참조할 수 없음 ``` java class Car{ String a; float b; int c; Car(String a, float b, int c){ Car.a = a; // 에러 인스턴스는 생성되지 않았음 this.b = b; this.c = c; } } ``` 클래스 변수는 참조가능 ``` java class Car{ static String a1; String a; float b; int c; Car(String a, float b, int c){ Car.a1 = a; // 문제 없음 // this.a1 = a; 가능 그러나 Car.a1으로 사용하는게 맞는개념 this.b = b; this.c = c; } } ```
> this 인스턴스(객체) 자신을 가리키는 참조변수, 인스턴스의 주소가 저장 모든 인스턴스 메서드에 숨겨진 채로 존재한다. 따로 선언을 하지 않았는데 사용가능 > int a, int b; // this.a, this.b 인스턴스 변수의 진짜이름 > this() 생성자, 같은 클래스의 다른 생성자를 호출 시 사용 클래스 이름 대신 ``` java class C{ int a; // this.a 가 진짜 이름 int b; void a(int a, int b) { int c = a+b; // 지역변수 this.a = a; //인스턴스 a에 지역 a 대입 b=c; // 지역변수 } void b() { a = 10; // 인스턴스 변수 this 생략됨 b = 11; // 생략가능 } static void c(int a, int b) { //this.a = a; //에러 //클래스 메서드는 객체 생성 이전에 사용할 수 있기에 //인스턴스 변수 사용 불가 } } ``` ---

## 변수의 초기화 > 지역변수는 수동 초기화 해야됨 ``` java class C{ int a; int b=a; // 인스턴스 변수는 초기화 됨 void af() { int i; int j = i; //에러 지역변수 초기화 안됨 i = a; } } ``` 호출스택은 재사용이 빈번하다 일일히 자동으로 초기화 해주게 되면 메모리 성능이 떨어짐 인스턴스변수는 그래도 유지기간이 길기 때문에 초기화됨 배열은 자동초기화됨 > 타입에 따른 기본값 초기화 boolean false 참조형 null > 참조형 변수 - null 또는 객체 주소 ---

# 12월 17일 - 5일차 ### 멤버변수의 초기화 > 멤버 변수 = 인스턴스 변수, 클래스 변수 > 명시적 초기화 int a = 4; Car c = new Car(); 객체를 만들어서 주소를 참조형변수 c에 넣어줌 > 초기화 블럭 복잡한 초기화 할때 사용함 인스턴스 초기화 블럭 {} 클래스 초기화 블럭 static{} > 생성자 iv초기화할때 사용함
멤버변수의 초기화 1 자동 초기화 2 간단 초기화 = 3 복잡 초기화 {}, 생성자 ``` java class C{ int a=b*3+1; // 에러 b가 생성되지 않음 int b=a*3+1; int c = a-1; } ``` ``` java class C{ int a+=1; // 에러 선언과 초기화 같이하면 자신을 불러들일 수없다 int b=(b+10)*2; int c; } ``` ``` java class C{ int a; int b; int c; a+=10; // 에러 } ``` > 해결방안 생성자로 작성하면됨 또는 {} 인스턴스 변수 초기화 블록 사용하면됨 인스턴스 변수 초기화 블록은 잘 사용하지 않는다. ``` java class C{ int a; int b; int c; { a = b+c; // a = 0 a+=10; // a = 10 b+=1; // b = 1 c+=3; // c = 3 } } public class K1{ public static void main(String[] args) { C c1 = new C(); System.out.printf("a = %d, b = %d, c = %d",c1.a,c1.b,c1.c); } } // 출력 // a = 10, b = 1, c = 3 ```
클래스 변수를 배열로 만들어서 랜덤넣기 ``` java class C{ static int[] a = new int[10]; static{ for (int i = 0; i
### 멤버변수의 초기화 시점 > 클래스 변수 : 클래스가 처음 로딩 될 때 한번 (메모리에 올라갈때) 인스턴스 변수 : 인스턴스가 생성될 때 마다 초기화 순서 1 클래스 -> 인스턴스 2 자동 -> 간단 -> 복잡 ``` java class C{ static int cv = 1; // 1. 자동초기화 0, 2. 간단초기화 1 int iv = 1; // 객체생성시 4. 자동초기화 0, 5. 자동초기화 1 static {cv =2;} // 3. 복잡초기화 2 {iv =2;} // 6. 복잡초기화 2 C(){ // 7. 생성자 초기화 3 iv = 3; } // 또 객체 생성시 인스턴스 초기화 반복 // 순서를 바꿔도 동일 } public class K1{ public static void main(String[] args) { C c1 = new C(); System.out.println(c1.cv + " " + c1.iv); } } // 출력 // 2 3 ``` ---

## 상속 > 상속(Inheritance) : 계승 기존 클래스로 새로운 클래스를 작성하는 것(코드의 재사용) 두 클래스를 부모와 자식으로 관계를 맺어준다. > class 자식클래스 extends 부모클래스 > 자손은 조상의 모든 멤버를 상속 받는다. (생성자, 초기화 블럭은 제외) 인스턴스 변수, 클래스 변수, 인스턴스 메서드, 클래스 메서드 > 자손의 멤버 개수는 조상보다 적을 수 없다. (같거나 많다)
``` java class Cp{ int a = 1; int b = 5; } class Cc extends Cp{ int c = 10; } public class K1{ public static void main(String[] args) { Cc c1 = new Cc(); Cp c2 = new Cp(); c2.a = 100; // c1에 영향 주지 않음 System.out.printf("a = %d, b= %d, c= %d\n", c1.a,c1.b,c1.c); } } // 출력 // a = 1, b= 5, c= 10 ```
클래스 변수는 당연히 영향을 받는다 ``` java class Cp{ static int a = 1; static int b = 5; } class Cc extends Cp{ static int c = 10; } public class K1{ public static void main(String[] args) { Cc c1 = new Cc(); Cp c2 = new Cp(); System.out.printf("a = %d, b= %d, c= %d\n", c1.a,c1.b,c1.c); c2.a = 100; System.out.printf("a = %d, b= %d, c= %d", c1.a,c1.b,c1.c); } } // 출력 // a = 1, b= 5, c= 10 a = 100, b= 5, c= 10 ```
> 상속을 받던 받지 않던 동일한 주소형태를 갖는다. 자식 클래스 Cc에 int 3개를 넣은것이나 Cc에 부모(int 2개)를 상속 받는 자식(int 1개)은 객체가 멤버변수 3개짜리로 만들어짐 ---

## 포함 > 클래스 관계 1. 상속, 2. 포함 > 포함(composite) : 합성 클래스의 멤버로 참조변수를 선언하는 것 ``` java class C1{ int a = 1; int b = 5; } class C2{ C1 c1 = new C1(); int c = 10; } ``` > c2를 멤버 3개로 만든것과 c2 멤버1과 c1(멤버2)을 포함시켜서 작성하면 c2는 int와 c1이라는 객체로 멤버가 2개 c1변수는 주소를 참조받아 int a,b의 멤버를 갖음 즉 구조적인 차이가 있다. 불러올때는 a.c1.a ``` java class C1{ int a = 1; int b = 5; } class C2{ C1 c1 = new C1(); int c = 10; } class C3{ int a = 1; int b = 5; int c = 10; } public class K1{ public static void main(String[] args) { C2 a = new C2(); C3 b = new C3(); System.out.printf("C2 a = %d",a.c1.a); // 불러 들이는게 다름 System.out.printf("C3 a = %d",b.a); } } // 출력 // C2 a = 1 C3 a = 1 ```
> 상속에서 불러들일때 자식클래스.부모클래스.클래스 변수 안됨
> 클래스 간의 관계 결정 간단한 개념임 상속관계 : a는 b이다 포함관계 : a는 b를 가지고 있다.
> 프로그래밍 = 설계(90%) + 코딩(10%) 설계 : 내가 하고자 하는 것을 구성 ---

## 단일상속 > 자바는 단일 상속만을 허용 (C++,Python은 다중상속 허용) 다중상속은 장점이 많다 그러나 단점이 있다. 하나의 자식 클래스가 두개의 부모클래스를 받을 경우 1번 부모, 2번부모 둘다 동일한 명의 다른 처리를 하는 함수가 있으면 충돌이 생겨서 문제가 발생될 수 있다. 인터페이스를 이용하면 충돌 문제를 해결하면서 다중상속을 받을 수 있도록 도와준다. > 비중이 높은 클래스 하나만 상속관계, 나머지는 포함 ``` java class Tv{ boolean pw; int ch; void pw() {pw = !pw;} void chu() {++ch;} void chd() {--ch;} } class dvd{ boolean pw; void pl() {} void st() {} } class Tvdvd extends Tv{ dvd d = new dvd(); void pl() { d.pl(); } void chuu(int a) { for(int i=0;i

## object 클래스 > 조상이 없는 클래스는 자동적으로 object 를 상속받는다 모든 클래스는 object의 11개의 매서드를 상속받음 > class C { } 이렇게 작성하면 자동적으로 컴파일된다 class C extends Object{ } ``` java public class K1{ public static void main(String[] args) { Tvdvd t = new Tvdvd(); System.out.println(t); System.out.println(t.toString()); } } // 출력 // javapj.Tvdvd@24d46ca6 javapj.Tvdvd@24d46ca6 ``` ---

## 오버라이딩 > 오버라이딩(overriding) 덮다 상속 받은 조상의 메서드를 자신에 맞게 변경하는 것 ``` java class P{ int a; int b; void pr() { System.out.printf("a = %d, b = %d\n",a,b); } } class Ch extends P{ int c; void pr() { //오버라이딩 되었음 System.out.printf("a = %d, b = %d, C = %d\n",a,b,c); } } public class K1{ public static void main(String[] args) { P a = new P(); a.pr(); Ch b = new Ch(); b.pr(); } } // 출력 // a = 0, b = 0 a = 0, b = 0, C = 0 ```
> 선언부는 변경 불가 내용만 변경가능 그러나 오버로딩 형태로 사용하면 즉 매개변수가 다르게 작성하면 불러들이는게 다름 오버로딩 ``` java class P{ int a; int b; void pr() { System.out.printf("a = %d, b = %d\n",a,b); } } class Ch extends P{ int c; void pr(int x) { System.out.printf("a = %d, b = %d, C = %d\n",a,b,c); } } public class K1{ public static void main(String[] args) { Ch b = new Ch(); b.pr(1); b.pr(); } } // 출력 // a = 0, b = 0, C = 0 a = 0, b = 0 ``` ---

# 12월 18일 - 6일차 ### 오버라이딩 조건 > 선언부가 조상 클래스의 메서드와 일치 선언부 (반환타입, 메서드 이름, 매개변수 목록) >접근 제어자를 조상클래스의 메서드보다 좁은 범위로 변경할 수 없다. public protected private defalt >예외는 조상 클래스의 메서드보다 많이 선언할 수 없다. 조상이 2개, 자식은 같거나 적어야함 예외는 어떠한 에러가 발생할 지에 예상해서 예외를 처리하는 것을 말함 ---

### 오버로딩, 오버라이딩 차이 > 근본적으로 다른것이 없다 오버로딩 : 기존에 없는 새로운 메서드를 정의 이름이 같은 것 오버라이딩 : 상속받은 메서드의 내용을 변경 ``` java class P{ void a() {} } class Ch extends P{ void a() {} // 오버라이딩 void a(int i) {} // 오버라이딩을 한것을 오버로딩 void b() {} // 새로운 메소드 생성 void b(int i) {} // 메소드 오버로딩 // void b() {} // 에러 // 중복 } ``` ---

## 참조변수 super > 객체 자신을 가리키는 참조변수 인스턴스 메서드 및 생성자 내에서만 존재 조상의 멤버와 자신의 멤버를 구별할 때 사용 > this는 지역변수와 인스턴스 변수를 구별 super는 조상 멤버와 자신의 멤버 구별 ``` java class P{ int a = 1; //super } class Ch extends P{ int a = 10; // this void pr() { System.out.println("a= "+a); //가까운쪽 System.out.println("this.a= "+this.a); System.out.println("super.a= "+super.a); } } public class K1{ public static void main(String[] args) { Ch b = new Ch(); b.pr(); } } // 출력 // a= 10 this.a= 10 super.a= 1 ```
자신의 변수가 없으면 동일하게 나옴 ``` java class P{ int a = 1; //super } class Ch extends P{ int a = 10; // this void pr() { System.out.println("a= "+a); //가까운쪽 System.out.println("this.a= "+this.a); System.out.println("super.a= "+super.a); } } public class K1{ public static void main(String[] args) { Ch b = new Ch(); b.pr(); } } // 출력 // a= 1 this.a= 1 super.a= 1 ```
값을 변경해서 변동되는 것 확인 ``` java class P{ int a = 1; //super } class Ch extends P{ int a = 10; // this void a1() { a = 100; } void a2() { super.a = 5; } void pr() { System.out.println("a= "+a); //가까운쪽 System.out.println("this.a= "+this.a); System.out.println("super.a= "+super.a); } } public class K1{ public static void main(String[] args) { Ch b = new Ch(); b.pr(); b.a1(); b.pr(); b.a2(); b.pr(); } } // 출력 // a= 10 this.a= 10 super.a= 1 a= 100 this.a= 100 super.a= 1 a= 100 this.a= 100 super.a= 5 ``` ---

## super() - 조상의 생성자 >조상의 생성자를 호출 할 때 사용 조상의 멤버는 조상의 생성자를 호출해서 초기화 ``` java class P{ int x,y; P(int x, int y){ this.x = x; this.y = y; } } class Ch extends P{ //에러 int z; } ```
class Ch에 에러발생 Ch를 생성하면 기본으로 P를 받는데 P를 생성하기 위해서는 (int x, int y)로만생성 해결1 ``` java class P{ int x,y; P(int x, int y){ this.x = x; this.y = y; } P(){ } } class Ch extends P{ int z; } ``` 해결2 ``` java class P{ int x,y; P(int x, int y){ this.x = x; this.y = y; } } class Ch extends P{ int z; Ch() { super(0,0); } } ```
부모는 2개 자식은 3개 생성자 에러 ``` java class P{ int x,y; P(int x, int y){ this.x = x; this.y = y; } } class Ch extends P{ int z; Ch(int x, int y, int z){ this.x = x; this.y = y; this.z = z; } } ``` 해결 ``` java class P{ int x,y; P(int x, int y){ this.x = x; this.y = y; } P(){} } class Ch extends P{ int z; Ch(int x, int y, int z){ this.x = x; this.y = y; this.z = z; } } ``` 위와 같이 작성해도 상관없지만 바람직한 것은 ``` java class P{ int x,y; P(int x, int y){ this.x = x; this.y = y; } } class Ch extends P{ int z; Ch(int x, int y, int z){ super(x, y); // Ch의 매개변수 x y가 슈퍼 부모의 생성자 인수로 생성 this.z = z; } } ``` > 즉 변수를 초기화할때 조상클래스의 생성자를 호출해서 조상의 변수를 초기화하고 자신의 변수는 자신에서 초기화하는게 개념적으로 맞음 > this() 생성자 호출은 첫줄에 반드시 생성자를 호출해야함 그렇지 않으면 컴파일러가 생성자의 첫 줄에 super(); 삽입 ``` java class P{ int x,y; P() { this(0,0) } P(int x, int y){ this.x = x; this.y = y; } } // 자동 컴파일 후 변화 class P extends objcet { //object 상속받음 int x,y; P() { this(0,0) // 첫줄에 this 생성자 호출됨 } P(int x, int y){ super(); // object 클래스 생성자 호출됨 this.x = x; this.y = y; } } ```
상속시 생성자 확인 ``` java class P{ int x,y; P(int x, int y){ this.x = x; this.y = y; } } class Ch extends P{ int z; Ch(int x, int y, int z){ this.x = x; this.y = y; this.z = z; } } //자동 컴파일 후 변화 class P extends Object{ //추가 int x,y; P(int x, int y){ super(); // Object 생성자 호출 this.x = x; this.y = y; } } class Ch extends P{ int z; Ch(int x, int y, int z){ super(); // P 생성자 호출 그러나 기본생성자가 P에는 없음 this.x = x; this.y = y; this.z = z; } } ``` ---

## 패키지 (package) >패키지 - 서로관련된 클래스의 묶음 자바 약 4000개의 클래스보유 클래스는 클래스 파일, 패키지는 폴더 하위 패키지는 하위 폴더
패키지는 소스파일의 첫 번째 문장으로 단 한번선언 같은 소스 파일의 클래스는 같은 패키지에 속함 패키지가 없으면 이름없는 패키지에 속함 ---

## import문 > 클래스를 사용할 때 패키지 이름을 생략할 수 있다. > 자동 import Ctrl + Shift + O ``` java import java.util.Scanner; public class K1{ public static void main(String[] args) { java.util.Scanner sc1 = new java.util.Scanner(System.in); Scanner sc2 = new Scanner(System.in); } } ```
java.lang 패키지의 클래스는 import하지 않고 사용 즉 생략 가능 대표적인 클래스는 String, Object, System, Thread 등 > import문선언 import 패키지명.클래스명; import 패키지명.\*; 모든클래스
import문은 컴파일 시 처리되어 프로그램 성능에 영향 없음 그러나 컴파일시 오래 걸림 명시해놓으면 어떤것을 프로그램에서 사용하는지 직접적으로 알 수 있음
>java.\*; 한다고하면 java패키지의 클래스만 포함 각각의 하위 패키지의 클래스는 사용 못함 ``` java import java.util.*; import java.text.*; import java.*; ```
> 클래스 이름은 같고 패키지 명이 다른 것도 있음 사용할때 패키지명을 작성해줘야함 ``` java package javapj; import java.sql.*; // java.sql.Date import java.util.*; // java.util.Date public class K1{ public static void main(String[] args) { // Date d1 = new Date(); // 에러 java.util.Date d2 = new java.util.Date(); } } ``` ---

### static import문 static 멤버를 사용할때 클래스 이름을 생략 할 수 있게 해준다. static 멤버 = static 변수, static 메서드 ``` java package javapj; import static java.lang.System.out; import static java.lang.Math.random; import static java.lang.Math.*; public class K1{ public static void main(String[] args) { System.out.println(Math.random()); out.println(random()); out.println(PI); } } // 출력 // 0.5920576021881406 0.2837887502364551 3.141592653589793 ``` System 클래스 안에는 static 변수이면서, PrintSteam의 객체 out변수가 존재 static 변수이기 때문에 인스턴스 생성없이 바로접근 정리하면 out은 PrintStream클래스의 객체이고 println()은 PrintStream클래스의 메소드임 ---

## 제어자(modifier) > 클래스와 클래스의 멤버(변수, 메서드)에 부가적인 의미부여 접근제어자 public, protected, (default), private 4개중 1개만 붙임 그외 static, final, abstract 등 하나의 대상에 여러 제어자를 같이 사용가능(접근 제어자는 하나만) ``` java public class K1{ public static final int a = 1; public static void main(String[] args) { } } ``` 순서도 크게 제한 없다. 그러나 대부분 접근제어자를 앞에 사용(관례적으로) final 보다 static을 먼저사용(관례적) ``` java public class K1{ public static final int a = 1; static public final int b = 10; final static public int c = 20; public static void main(String[] args) { } } ``` 접근제어자는 하나만 붙일 수 있다. ``` java public class K1{ public static final int a = 1; static public final int b = 10; final static public int c = 20; private public int d = 1; //에러 public static void main(String[] args) { } } ```
#### static - 클래스의, 공통적인 |제어자|대상|의미| |---|---|---| |@rows=2: static |멤버변수|모든인스턴스에 공통적으로 사용되는 클래스 변수
클래스 변수는 인스턴스를 생성하지 않고도 사용가능
클래스가 메모리에 로드될 때 생성 |메서드|인스턴스를 생성하지 않고도 호출이 가능한 static 메서드
static 메서드 내에서는 인스턴스 멤버들을 직접 사용할 수 없다. ``` java public class K1{ static int a =1; int iv = 1; static void a() { a = 10; iv = 11; //오류 인스턴스 변수 사용불가 } void b() { a = 10; iv = 11; } } ```

# 12월 24일 - 7일차 #### final - 마지막의, 변경될 수 없는 |제어자|대상|의미| |---|---|---| |@rows=4:final|클래스|변경될 수 없는 클래스, 확장될 수 없는 클래스
final로 지정된 클래스는 다른 클래스의 조상이 될 수 없다. |메서드|변경될 수 없는 메서드
final로 지정된 메서드는 오버라이딩을 통해 재정의 될 수 없다. |멤버변수|@rows=2:변수 앞에 final이붙으면 값을 변경할 수 없는 상수가 된다. |지역변수| final 클래스의 예시 : String, Math String은 보안으로 인해서 final로 선정함 (문자열로 비밀번호) Math는 static 메서드 집합으로 굳이 일반 클래스로 만들 필요가 없음 상속불가, 포함가능, 오버로딩은 가능, ``` java final class K2{ int a = 1; final int b = 1; // 값을 변경할 수 없는 멤버변수(상수) void a1(int a) { } void a1(int a, int b) { } final void a2() { } void a2(int a) {//오버로딩 가능 } } class K2_1 extends K2{ // K2 상속불가 } class K2_2{ K2 k2 = new K2(); // 포함가능 } public class K1{ public static void main(String[] args) { K2_2 k = new K2_2(); k.k2.a = 10; k.k2.b = 1; //변경불가 final 변수 k.k2.a2(); k.k2.a2(1);//오버로딩 } } ``` 오버라이딩 사용불가 오버라이딩 : 조상 메서드를 덮어쓸수 없음 ``` java class K2{ int a = 1; final int b = 1; final void a2() { } } class K2_1 extends K2{ void a2() { //오버라이딩 안됨 } final void a2() { } } ```
#### abstract - 추상의, 미완성의 컴퓨터 과학에서의 추상화는 복잡한 자료, 모듈, 시스템 등으로부터 핵심적인 개념 또는 기능을 간추려 내는 것 객체지향 관점에서의 추상화는 클래스를 정의 할 때 불필요한 부분들을 생략하고 객체의 속성(변수) 중 중요한 것에만 중점을 두어 개략화 하는 것 즉 클래스들의 중요하고 공통된 성질들을 추출하여 슈퍼 클래스를 선정하는 개념 추상화의 이유 중복코드가 현저히 줄어든다. 코드가 간결해져서 생산성 증가, 가독성 증가, 에러감소, 유지보수시 시간 단축 잘 만들어진 슈퍼 클래스 덕분에 코드의 재사용성이 증가 추상화가 잘 되어 있으면 코드는 내부 코드를 전부 이해하지 않아도 가져다가 사용할 수 있는 장점이 있지만 반대로 그렇기 때문에 내부를 파악하거나 수정이 어렵다. |제어자|대상|의미 |---|---|--- |@rows=2:abstract|클래스|클래스 내에 추상 메서드가 선언되어 있음을 의미 |메서드|선언부만 작성하고 구현부는 작성하지 않은 추상 메서드임을 알림 객체 생성 불가 ``` java abstract class K2{ abstract void a(); } abstract void b() { //에러 추상메서드로 선언했으므로 작성불가 } class K3{ //에러 클래스 내에 미완성 추상 메서드가 있음 abstract void a(); //에러 클래스 자체가 미완성이 아님 } public class K1{ public static void main(String[] args) { K2 k = new K2(); //에러 미완성 클래스 } } ``` 추상클래스를 상속받아 추상메서드를 구현하여(오버라이딩)으로 완성시켜 상속받은 클래스(구상 클래스) 추상클래스의 반대말 인스턴스생성 후 사용 ``` java abstract class K2{ int a = 1; abstract void a1(); } class K3 extends K2{ //에러 추상메서드를 구현하지 않음 } ``` ``` java abstract class K2{ int a = 1; abstract void a1(); } class K3 extends K2{ void a1() { System.out.printf("%d",this.a); } } public class K1{ public static void main(String[] args) { K3 k = new K3(); k.a1(); } } ```

### 접근제어자 (access modifier) |접근제어자|설명 |---|--- |private|같은 클래스 내에서만 접근이 가능 |(default)|같은 패키지 내에서만 접근이 가능 |protected|같은 패키지 내, 다른 패키지의 자손클래스에서 접근 가능 |public| 접근제한이 전혀 없다 |제어자|같은 클래스|같은 패키지|자손클래스|전체 |---|---|---|---|--- |public|O|O|O|O |protected|O|O|O| |(default)|O|O|| |private|O
접근제한 없음, 같은패키지+자손, 같은 패키지, 같은 클래스 public > protected > (default) > private
클래스에 붙일 수 있는 것 public (default) 멤버에 붙일 수 있는것 public protected (default) private
참고 패키지 내에서 동일한 이름의 클래스 사용못함 K1.java ``` java package javapj; class K3{ } public class K1{ public static void main(String[] args) { } } ``` K2.java ``` java package javapj; public class K2 { } class K3{ //에러 } ```
설명 ``` java class K2{ public int pub = 3; // 전체 int def = 1; // 패키지 protected int pro = 4; // 패키지 + 자식 private int pri = 5; // 클래스 void a() { pri = 10; } } public class K1{ public static void main(String[] args) { K2 k = new K2(); k.def = 10; k.pub = 5; k.pro = 2; k.pri = 5; //에러 다른 클래스에서 사용 } } ```
protected 는 다른 패키지에서 protected 클래스를 상속받아서 사용이 가능하다. javapj - K1.java ``` java package javapj; class K2{ protected int a = 1; protected static int b = 1; } public class K1{ protected int a =1; protected static int b = 1; public static void main(String[] args) { K2.b = 10; // static 변수여서 인스턴스 생성전 사용 K2 k = new K2(); k.a = 10; //같은 패키지여서 사용가능 } } ``` javapj2 - J1.java ``` java package javapj2; import javapj.K1; class J2 extends K1{ //javapj.K1라고 쓰고 import 안해도 됨 void a() { this.a = 10; //protected 다른 패키지에서 자식이어서 가능 this.c = 1; //default 변수로 다른 패키지 사용불가 this.d = 10; //public 변수 사용가능 } static void b() { this.a = 2; //에러 a는 인스턴스 변수 K1.b = 10; //사용가능 b는 static 변수 b = 5; // 사용가능 b는 static 변수 } } class J3 extends K2{ // K2는 default 다른 패키지 사용불가 } public class J1{ J2 j = new J2(); j.a = 1; //protected 사용불가 다른패키지에서 자식이 아님 public static void main(String[] args) { K1 k = new K1(); k.a = 1; // protected 사용불가 J2 j = new J2(); j.a = 1; //protected 사용불가 } } ```

## 캡슐화 접근 제어자를 사용하는 이유 \- 외부로부터 데이터를 보호하기 위해서 \- 잘못된 데이터러 변경되는 것을 막기 위해 \- 외부에는 불필요한, 내부적으로 사용되는, 부분을 감추기 위해 public으로 하면 어디에서나 접근하여 데이터를 변화시킬 수 있다. private으로 넣으면 외부로부터의 접근을 막고 메서드를 통해서만 접근할 수 있도록 접근을 제어한다. ``` java package javapj; class C{ private int h; private int m; private int s; public void seth(int h) { if (h<0 || h>23) { return; } this.h = h; } public int geth() { return this.h; } } public class K1{ public static void main(String[] args) { C c = new C(); c.seth(25); System.out.println(c.geth()); c.seth(23); System.out.println(c.geth()); } } // 출력 // 0 23 ``` 함수추가 Extract Method Alt + Shift + M refactor - Exreact ``` java public void seth(int h) { if (hvalc(h)) { return; } this.h = h; } private boolean hvalc(int h) { // 안에서만 사용 return h<0 || h>23; } ```

## 다형성(polymorphism) 여러 가지 형태를 가질 수 있는 능력 (사전적인 느낌) \- 조상 타입 참조 변수로 자손타입 객체를 다루는 것 \- 자손타입의 참조변수로 조상타입의 객체를 가르킬수 없다. >C c3 = new C2(); 조상의 타입 / 참조변수 = 새로운 자손타입 객체 가능함 기본적으로 타입이 불일치 하면 작성이 불가능 ``` java class C{ int a; } class C2 extends C { int b; } class D{ int a; } public class K1{ public static void main(String[] args) { // C c = new D(); //에러 // C2 c2 = new C(); // 에러 C c3 = new C2(); } } ``` 객체와 참조변수의 타입이 일치 할때와 일치하지 않을 때의 차이 \- 조상 타입의 참조변수로 자손타입의 객체를 만들면 사용할 수 있는 멤버는 조상의 멤버밖에 안된다. 즉 조상 타입의 참조변수로는 리모컨 버튼을 생각하면됨 버튼이 3개인 리모컨으로 멤버 5개를 다 관리할 수 없다.
자손타입의 참조변수로 조상타입의 객체를 가르킬수 없는이유 관리할 수 있는 개수가 많은데 멤버가 적으면 사용할 수 없다. 없는 것을 호출하면 에러가 발생
정리 참조변수의 타입은 인스턴스의 타입과 반드시 일치? 일치하는 것이 보통이지만 일치 하지 않을 수도 있다. 참조변수가 조상타입일 때와 자손타입일 때의 차이 참조변수로 사용할 수 있는 멤버의 갯수가 달라짐 자손 타입의 참조변수로 조상타입 객체를 가리킬 수 없다. 없는 것을 호출하면 에러 발생
장점 \1 유지보수가 쉽다 개발자가 여러 객체를 하나의 타입으로 관리가 가능하기 때문에 코드 관리가 편리해 유지보수가 용이합니다. \2 재사용성 증가 다형성을 활용하면 객체를 재사용하기 쉬워지기 때문에 개발자의 코드 재사용성이 높집니다. \3 느슨한 결합 다형성을 활용하면 클래스간 의존성이 줄어들며 확장성이 높고 결합도가 낮아져 안전성이 높아집니다. ``` java class C{ void pr() { System.out.println("부모"); } } class C2 extends C { void pr() { System.out.println("자식2"); } } class C3 extends C{ void pr() { System.out.println("자식3"); } } public class K1{ public static void main(String[] args) { C c1 = new C(); C c2 = new C2(); C c3 = new C3(); c1.pr(); c2.pr(); c3.pr(); } } // 출력 // 부모 자식2 자식3 ``` 배열은 동일한 타입을 관리할 수 있음 ``` java C[] c = {new C(),new C2(),new C3()}; c[0].pr(); c[1].pr(); c[2].pr(); ``` 배열은 for문으로 관리하기 편함 ``` java for(int i = 0; i

## 참조변수의 형변환 >사용할 수 있는 멤버의 갯수를 조절 하는 것 (주소값, 객체 바뀌지 않는다.) 조상 자손관계의 참조변수는 서로 형변환 가능 (형제들끼리는 형변환 불가) >자식을 부모로 형변환하는 것 up casting 부모를 자식으로 형변환하는 것 down casting
기본형 형변환 3.6을 int형으로 형변환하면 3으로 값이 바뀐다.
#### 부모 타입의 참조 변수에 자식의 타입을 대입 부모 타입의 참조변수에 자식의 타입을 넣으면 자동형변환이 된다. 즉 생략가능 조상 타입의 참조 변수에 자손의 타입을 넣을 수 있다. 부모 타입의 참조 변수는 자식이 가지고 있는 멤버를 통제할 수 없다. ``` java package javapj; class Parents{ int a = 1; int b = 2; int c = 3; } class Child extends Parents { int d = 5; } class Child2 extends Parents{ int d2 = 15; } class Childc extends Child{ int e = 1; } public class K1{ public static void main(String[] args) { Child c = new Child(); Parents p = (Parents) c; Parents p2 = c; //생략해도됨 Object o = (Object) c; // p.d = 1; //에러 부모의 타입에는 d라는 변수가 없음 c.d = 2; //문제없음 // o.a = 1; //에러 Childc cc = new Childc(); Parents p3 = cc; } } ```
#### 자동형변환 일반적인 자동형변환은 타입의 크기가 큰 것에 작은것을 넣으면 자동형 변환이지만 객체는 조상에 자손을 넣으면 자동형 변환 ``` java public class K1{ public static void main(String[] args) { int a = 1; float b = 1.5f; a = b; //에러 타입의 범위가 작은것에 큰것을 넣을때 에러 a = (int)b; // 명시적형변환 b = a; //자동형변환 } } ```
#### 자식 타입의 참조형 변수에 부모 사용 다형성에서 배운것 자손타입의 참조변수로 부모타입의 객체를 컨트롤 할 수 없다. 컴파일에서는 문제가 없지만 문제가 발생 ``` java public class K1{ public static void main(String[] args) { Parents p = new Parents(); // Childc c = p; //에러 Childc c2 = (Childc) p; } } // 출력 // Exception in thread "main" java.lang.ClassCastException: ```
자손으로 만든 객체를 이용하여 부모타입의 참조 변수에서 컨트롤 가능 그리고 그 부모타입의 참조변수의 값을 자손타입의 참조형변수에 넣는것은 문제 없음 멤버의 개수가 줄어드는 행동은 안전성을 높여줌 멤버의 개수가 늘어나는 행동은 불안정성을 높여줘서 형변환 필수 ``` java public class K1{ public static void main(String[] args) { Childc c = new Childc(); Parents p = c; Childc c2 = (Childc) p; System.out.println(p.a); } } // 출력 // 1 ```
물론 손자객체를 가지고 자식에서 받아 쓸수 있음 ``` java public class K1{ public static void main(String[] args) { Childc c = new Childc(); //손자 객체 생성 Parents p = c; // 부모타입의 참조변수에 손자 변수값 대입 Child c2 = (Child) p; // 자식타입의 참조 변수에 손자객체로 만든 변수값 대입가능 } } ```
부모 타입의 참조변수에 손자 객체를 넣어도 문제는 없음 ``` java public class K1{ public static void main(String[] args) { Parents p = new Childc(); Child c = (Child)p; c.d = 10; System.out.println(c.d); } } // 출력 // 10 ```
#### 형제끼리의 형변환 불가함 ``` java public class K1{ public static void main(String[] args) { Child2 c = new Child2(); Child ch = (Child) c; // 당연히 에러 Parents p = c; //문제없음 } } ```
#### 멤버의 연동 ``` java public class K1{ public static void main(String[] args) { Childc c = new Childc(); Parents p = c; p.a = 10; p.b = 200; System.out.println("a= "+c.a+", b="+c.b); } } // 출력 // a= 10, b=200 ```
#### 참조형매개변수 함수의 운용 일반적인 운용 ``` java public class K1{ public static void main(String[] args) { Childc c = new Childc(); Parents p = c; a(c); System.out.println("a= "+c.a+", b="+c.b); } static void a(Child a) { a.a = 10; a.b = 200; } } // 출력 // a= 10, b=200 ``` 부모 타입의 참조변수는 자식 타입의 변수의 값을 받을때 명시적 형변환해줘야 함. ``` java public class K1{ public static void main(String[] args) { Childc c = new Childc(); Parents p = c; // a(p); //에러 자동형변환이 안됨 a((Childc)p); // 문제없음 System.out.println("a= "+c.a+", b="+c.b); } static void a(Childc a) { a.a = 10; a.b = 200; } } // 출력 // a= 10, b=200 ```

## 12월 31일 - 8일차 #### 참조형 반환타입에서의 활동 받는 타입 변환 Childc로 또한 주는 타입도 변환 Childc로 그러나 부모타입으로 받아서 줄때는 앞에만 하면 됨 ``` java public class K1{ public static void main(String[] args) { Childc c = new Childc(); Parents p = a(c); //Childc c2 = a(p); 에러 //Childc c2 = a((Childc) p); 에러 Childc c2 = (Childc)a((Childc)p); Childc c3 = (Childc)b(p); System.out.println("a= "+c.a+", b="+c.b); } static Parents a(Childc a) { return a; } static Parents b(Parents b) { return b; } } ```
#### 참조형 반환타입복습 ``` java public class K1{ public static void main(String[] args) { Childc c = new Childc(); Parents p = a(); p.a = 100; p.b = 1000; System.out.println("c.a= "+c.a+", c.b="+c.b); System.out.println("p.a= "+p.a+", p.b="+p.b); } static Parents a() { Childc b = new Childc(); return b; } } // 출력 // c.a= 1, c.b=2 p.a= 100, p.b=1000 ```
#### Null 포인트시 에러 컴파일은 문제 안됨 ``` java public class K1{ public static void main(String[] args) { Childc c = null; Parents p = c; Childc c2 = (Childc) p; c2.e = 10; //경고 } } // 출력 // Exception in thread "main" java.lang.NullPointerException ```

## instanceof 연산자 > 참조변수의 형변환 가능여부 확인에 사용. 가능하면 true반환 조상과 자손은 형변환가능 > 1확인, 형변환 해도 되는지 (안전한지) 2형변환 형변환 전에 반드시 instanceof로 확인 필요 손자로 만든 객체 점검 ``` java public class K1{ public static void main(String[] args) { Childc c = new Childc(); System.out.println(c instanceof Child); System.out.println(c instanceof Childc); System.out.println(c instanceof Parents); } } // 출력 // true true true ``` 부모로 만든 객체 점검 ``` java public class K1{ public static void main(String[] args) { Parents c = new Parents(); System.out.println(c instanceof Child); System.out.println(c instanceof Childc); System.out.println(c instanceof Parents); } } // 출력 // false false true ``` 부모타입의 참조변수에 자식의 객체 ``` java public class K1{ public static void main(String[] args) { Parents c = new Child(); System.out.println(c instanceof Child); System.out.println(c instanceof Childc); System.out.println(c instanceof Parents); } } // 출력 // true false true ```
정리 참조변수의 형변환을 하는이유 참조변수를 변경함으로써 사용할 수 있는 멤버의 갯수를 조절 instanceof연산자는 참조변수를 형변환하기 전에 형변환 가능여부를 확인할 때 확인한다.

## 매개변수의 다형성 > 장점 1 다형적 매개변수 2 하나의 배열로 여러종류 객체 다루기 > 다형성 1 조상타입의 참조변수로 자손객체 다루기 2 참조변수의 형변환 - 사용할 수 있는 멤버 갯수 조절 3 instanceof 연산자 - 형변환 가능여부 체크 > 매개변수의 다형성 참조형 매개변수는 메서드 호출시, 자신과 같은 타입 또는 자손타입의 인스턴스를 넘겨줄수 있다. 에러 ``` java class Parents{ int a = 0; int b = 0; int c = 0; } class Child extends Parents { int d = 0; } class Child2 extends Parents{ int d = 0; } class Child3 extends Parents{ int d = 0; } // 출력 // public class K1{ public static void main(String[] args) { Child c1 = new Child(); Child2 c2 = new Child2(); Child3 c3 = new Child3(); d(c1,10); d(c2,22); } static void d(Child a,int b) { a.b = b; } } ``` 오버로딩 ``` java public class K1{ public static void main(String[] args) { Child c1 = new Child(); Child2 c2 = new Child2(); Child3 c3 = new Child3(); b(c1,10); b(c2,22); b(c3,35); } static void b(Child a,int b) { a.b = b; } static void b(Child2 a,int b) { a.b = b; } static void b(Child3 a,int b) { a.b = b; } } ``` 매개변수의 다형성 당연히 부모의 맴버만 변경가능 각자의 것을 바꾸려면 오버로딩하는게 맞음 ``` java public class K1{ public static void main(String[] args) { Child c1 = new Child(); Child2 c2 = new Child2(); Child3 c3 = new Child3(); b(c1,10); b(c2,22); b(c3,35); System.out.printf("c1 = %d, c2 = %d, c3 = %d",c1.b,c2.b,c3.b); } static void b(Parents a,int b) { a.b = b; //에러 a.d = 1;//에러 } } // 출력 // c1 = 10, c2 = 22, c3 = 35 ``` 참고 toString()이 자동으로 실행되어 나옴 오버라이딩 ``` java class Child extends Parents { int d = 0; public String toString() { return "Child"; } } public class K1{ public static void main(String[] args) { Child c1 = new Child(); Child2 c2 = new Child2(); Child3 c3 = new Child3(); b(c1,10); b(c2,22); b(c3,35); System.out.println(c1+" = "+c1.b); System.out.println(c2+" = "+c2.b); } } // 출력 // Child = 10 javapj.Child2@4517d9a3 = 22 ```

다형성을 배열로 다룰수 있다. ``` java public class K1{ public static void main(String[] args) { Parents[] p = {new Child(),new Child2(),new Child3()}; } } ``` ``` java public class K1{ static Parents[] p = new Parents[10]; static int count = 1; public static void main(String[] args) { add(new Child()); add(new Child2()); add(new Child3()); Child c1 = (Child) p[0]; c1.d = 10; Child2 c2 = (Child2) p[1]; c2.d = 20; Child3 c3 = (Child3) p[1]; c3.d = 30; } static void add(Parents a) { p[count++] = a; } } ```

## 추상 클래스 (abstract class) > 미완성 설계도, 미완성 메서드를 갖고 있는 클래스 ``` java abstract class abc{ int iv = 1; abstract void af(int a); // 미완성 메서드(추상 메서드) } ``` > 미완성 설계도 => 제품생산 불가 다른 클래스 작성에 도움을 주기 위한 것으로 인스턴스 생성 불가 ``` java abc c = new abc(); // 에러 ``` > 상속을 통해 추상 메서드를 완성해야 인스턴스 생성가능 ``` java class Child extends abc{ //완성됨 클래스 void af(int a) { } } ```
> 추상클래스 타입으로 자손클래스의 객체를 만들어 사용할 수 있음. ``` java abstract class abc{ int iv = 1; abstract void af(int a); } class Child extends abc{ void af(int a) { System.out.println(a); } } public class K1{ public static void main(String[] args) { abc c = new Child(); c.af(10); } } // 출력 // 10 ```
#### 추상 메서드 > 미완성 메서드, 구현부 가 없는메서드 abstract 리턴타입 메서드 이름(); // 세미클론을 넣어 주어야 한다 추상메서드 작성 이유 꼭 필요하지만 자손마다 다르게 구현될 것으로 예상되는 경우 사용 ``` java abstract class abc{ //2개의 추상메서드 int iv = 1; abstract void af(int a); abstract void af2(); } class Child extends abc{ void af(int a) { System.out.println(a); } void af2() { System.out.println("af2"); } } abstract class AChild extends abc{ //1개의 추상메서드만 구현 abstract 미작성시 에러 void af(int a) { System.out.println("af"+a); } } public class K1{ public static void main(String[] args) { // abc c = new AChild(); //추상 클래스 생성 에러 } } ``` ---
추상메서드 호출가능 메서드는 선언부만 알면 호출이가능하므로 추상메서드도 호출 가능 현재는 구현부는 없지만 상속을 통해 자손이 완성시키기 때문에 당연히 호출 가능 인스턴스 메서드는 객체 생성후 사용할 수 있는데, 추상클래스는 객체생성이 안됨 그렇기 때문에 인스턴스 안됨 ``` java abstract class abc{ int iv = 1; abstract void af(int a); abstract void af2(); void af() { af(iv); //iv값에 다른 숫자를 넣으면 } } class Child extends abc{ void af(int a) { System.out.println(a); } void af2() { System.out.println("af2"); } } public class K1{ public static void main(String[] args) { abc c = new Child(); //추상 클래스 생성 에러 c.iv = 22; c.af(); } } // 출력 // 22 ``` > static void af() { af(15); //에러 인스턴스 메서드 가르키고 있어서 } 설명 굳이 추상메서드로 만들 필요없고 일반메서드로 만들어서 빈공간을 줘도 된다. 그러나 추상메서드로 만들어 주면 필수적으로 상속받는 클래스에서는 무조건 작성해야 되기 때문에 추상메서드를 만든다. ---

#### 추상클래스의 작성 추상클래스 : 미완성 설계도(미완성 메서드 포함) 여러 클래스에 공통적으로 사용될 수 있는 추상클래스를 바로 작성하거나 기존 클래스의 공통부분을 뽑아서 추상클래스를 만든다. 선언부는 일치하지만 구현부가 불일치 할 경우 추상메서드로 만들어 준다. > 예시 유닛의 좌표, 이동, 공격, 등등 공통된 부분을 추상으로 각각의 마린, 메딕, 파이어벳, 레이스에서 구현 유닛 배열 만들고 각각의 유닛(마린, 메딕 등등)객체을 따로 넣어줌 각각의 유닛에서 동일한 부분에 대해서는 시행가능 유닛 타입은 공통된 것을 넣어 놓았기 때문에 ``` java int a = 3; // 유닛 종류 int c = 10; // 유닛의 총 개수 int[] arr = new int[3]; // 유닛 int[] u = new int[c]; //선택한 유닛 u[0] = arr[0%a]; // 0, 1, 2 가 for문 반복하면 나옴 // 0을 i로 넣어서 ```

#### 추상클래스의 장점 추상 클래스 관련 Tv50a, Tv50b, Tv50c 공통된 부분 3개, 다른게 1개라면 공통된 부분은 추상클래스로 (미완성시키기) 바탕으로 자손을 만들면 중복이 제거되고 1개만 만들면 됨 추가적인 설계도를 만들기 쉽다 공통된 부분이 달라지면 추상 클래스만 바꿔도 모든게 변화된다 즉 관리가 용이해진다. (변경) 추상클래스를 조상은 공통 1개, 자손은 2개, 그 밑 자손은 3개로 공통된 부분에 대해서도 단계별로 작성가능 (구체화) 그러면 새로운 클래스에서 공통된 부분자체를 하나의부분만 변경해야 되면 자손 2개짜리 추상클래스에서 바로 상속받아서 사용할 수 있다.
#### 사전적 의미 추상(뺄 추, 형상 상) 추상 : 여러 가지 사물이나 개념에서 공통되는 특성이나 속성 따위를 추출하여 파악하는 작용 추상적 : 구체성이 없이 사실이나 현실에서 멀어져 막연하고 일반적인. 구체 : 사물이 직접 경험하거나 지각할 수 있도록 일정한 형태와 성질을 갖춤 구체화 : 구체적으로 만드는것 추상화 : 불명확한것 추상화 <-> 구체화(반대) 추상화된 코드는 구체화된 코드보다 유연하다 변경에 유리

## 인터페이스(interface) > 인터페이스는 Static 메서드, default 메서드도 가지고 있지만 부수적인것임 핵심은 추상 메서드의 집합 > 인터페이스(상호작용) 인터페이스 = 추상 메서드의 집합 : 프로그래밍 관점 구현된 것이 전혀 없는 설계도, 껍데기(모든 멤버가 public) >인터페이스의 모든 멤버는 public 인터페이스, 추상클래스의 차이 추상클래스 : 일반클래스 인데 추상 메서드를 가지고 있음 인터페이스 : 추상메서드를 가지고 있음 추상클래스는 멤버변수가 있지만 인터페이스는 멤버변수를 가지고 있지 않음 캡슐화에서 (내부 변수를 보호, 메서드를 이용해야만 접근가능) 구현된것의 겉부분이 인터페이스이다. ``` java interface ifa{ static final int a = 1; //값이 없어도 에러임 final이기 때문 // public static final int a final int a2 = 2; // public static final int a2 static int a3 =3; // public static final int a3 int b = 2; //static final 이 기본 public도 기본 //public static final int b //상수는 항상 public static final임 예외없음 //그래서 생략가능 // private int c=1; //안됨 // protected int d= 3; //안됨 // void m() {} 기본값이 추상메서드 에러 구현을 했기 때문에 void m2(); // public abstract void m2() == public abstract 생략가능 // 생략가능한 이유는 인터페이스는 항상 public에 abstract이기 때문에 abstract void m3(); public abstract void m4(); } class cl{ static final int a = 1; int b = 2; final int c = 3; static int d = 4; } ```
#### 인터페이스의 상속 인터페이스의 조상은 인터페이스만 가능 (object 최고 조상 아님) 다중상속 가능(추상메서드는 충돌해도 문제 없음) ``` java interface ifa{ int a=1; int b=2; void m1(); } interface ifb{ void m1(); //선언부가 같은데 구현부가 달라서 문제인것임 //내용불일치로 충돌을 일으킴 //구현부가 둘다 없기때문에 아무런 문제가 되지 않는다. } interface ifc extends ifa,ifb{ } ```
#### 인터페이스의 구현 인터페이스는 추상메서드로만 되어 있어서 인터페이스를 구현한다는 것은 인터페이스에 정의된 추상 메서드를 완성하는 것 > class 클래스 이름 implements 인터페이스 이름{ } ``` java interface ifa{ int a=1; int b=2; void m1(); } interface ifb{ void m1(); } interface ifc extends ifa,ifb{ } class cifa implements ifc{ //두개 구현할 수 있음 ifa,ifb public void m1() { //public 안쓰면 에러 // 상속하는 것도 오버라이딩하려면 조상의 범위공간보다 작으면 안됨 } } ```
인터페이스를 구현한 클래스의 인스턴스 생성 ``` java class cifa implements ifa,ifb{ public void m1() { System.out.println("생성"); } } public class K1{ public static void main(String[] args) { cifa c = new cifa(); System.out.println(c.a); System.out.println(c.b); } } // 출력 // 1 2 생성 ``` 동일 이름의 변수 선언 ``` java class cifa implements ifa,ifb{ public void m1() { System.out.println("생성"); } int a = 100; } // 출력 // 100 2 생성 ``` 인터페이스의 변수 불러오기 ``` java public static void main(String[] args) { cifa c = new cifa(); System.out.println(c.a); System.out.println(c.b*10); System.out.println(ifa.a); c.m1(); } // 출력 // 100 20 1 생성 ```
상속과 인터페이스 구현 둘다 한 클래스에서 사용가능 ``` java class cifa extends cl implements ifa,ifb{ } ```

인터페이스가 두개의 추상 메서드를 갖고 있는데 클래스에서 implements 로 인터페이스를 가져오는데 1개만 구현했다면 클래스앞에 abstract넣어야 함

게시글 상세