$$config title: ★★★★★★★자바 수업내용★★★★★★ keywords: - 수업준비 - ... $$ # 수업자료실 - [JDK 다운로드](https://www.oracle.com/kr/java/technologies/javase/javase8-archive-downloads.html#license-lightbox) - [이클립스 다운로드](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) # 설치 - [프로그램 설치 방법](https://slog.gg/p/11043)

## 인터페이스(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넣어야 함

#### 인터페이스를 이용한 다형성 다형성 : 조상참조변수로 자손객체를 가르키는 것 클래스를 상속하는 것과 인터페이스를 구현하는데 문제가 발생 상속받는 부모 클래스의 메서드와 인터페이스 메서드의 이름이 동일할 경우 다중상속문제가 있다. 그러나 인터페이스는 구현부가 없기 때문에 생각안해도 된다. 다중상속의 문제점을 해결하면서 사용할 수 있도록 해줌 ``` java class c extends pc implements if{ } pc a = new c(); //조상클래스에서 자손객체 if i = new c(); // 인터페이스에서 자손객체 사용가능 //인터페이스에서 사용된 맴버 2개만 사용가능 ```
매개변수로 인터페이스를 사용한다는 것은 인터페이스를 구현한 클래스의 인스턴스(객체)만 가능 참조형 매개변수 관리와 동일 ``` java interface if{ void m(int x, int y); void a(if a); } ```
인터페이스를 메서드의 리턴타입으로 지정할수 있다.(반환타입) 의미 는 인터페이스를 구현한 클래스의 인스턴스를 반환 일반적으로 기본형 타입을 반환하는 형태와 동일 ``` java if method(){ C c = new C(); return f; } ``` 반환타입은 인터페이스이고 반환하는 값은 클래스임 구현을 해 놓았기 때문에 문제가 없음 자동형변환과 유사 개념 ``` java abstract class un{ int x, y; abstract void move(int x, int y); void stop() {System.out.println("멈춤");} } interface fit{ void move(int x, int y); // public abstract가 생략 void at(fit f); } class f extends un implements fit{ public void move(int x, int y) { //public 써줘야함 // 오버라이딩 규칙 조상보다 접근제어자가 좁으면 안됨 System.out.println(x+""+y+"이동"); } public void at(fit f) { System.out.println(f + "공격"); } } public class K1{ public static void main(String[] args) { f a = new f(); a.move(10, 10); a.at(new f()); } } // 출력 // 1010이동 javapj.f@24d46ca6공격 ``` fit도 사용가능 ``` java fit a = new f(); a.move(10, 10); a.at(new f()); ``` fit에서는 stop() 구현은 불가함 ``` java fit a = new f(); a.move(10, 10); a.at(new f()); a.stop();//사용할 수 없다. 인터페이스 fit에서 구현안됨 ``` un추상클래스에서는 at() 구현 불가 ``` java un a = new f(); a.move(10, 10); a.at(new f()); //사용할 수 없다. at가 un에 없다. a.stop(); ```

f클래스나 fit 인터페이스나 상관이 없다. ``` java class f extends un implements fit{ public void move(int x, int y) { //public 써줘야함 // 오버라이딩 규칙 조상보다 접근제어자가 좁으면 안됨 System.out.println(x+""+y+"이동"); } public void at(fit f) { System.out.println(f + "공격"); } fit getf() { f cf = new f(); return cf; } } public static void main(String[] args) { f a = new f(); a.move(10, 10); a.at(a.getf()); a.stop(); } ``` > 타입만 맞춰주면된다. 반환타입이 인터페이스이라는 것은 인터페이스를 구현하는 것을 반환한다라고 이해해도됨 > 다형성이면서 추상화 때문에 쓰인다.

### 인터페이스의 장점 1. 1 두 대상(객체) 간의 '연결, 대화, 소통'을 돕는 중간역할을 한다. interface = inter(~사이) + face(얼굴, 대상) inter national airport (국제공항) 어떤 두 대상사이에서 중간 역할을 해줌 어떤 두 대상이 직접소통할 수 있지만 중간에서 소통을 도와주는 역할을 해주는 중개인 역할임
##### 1번장점 기계 예시 기계가 있다고 생각을 하면 사람이 직접 기계를 조작할 수도 있지만 기계전반적인 부분에 대해서 알고 있지 않으면 직접 조작하기 어렵다. 기계 껍데기에 버튼등을 장착해서 인터페이스를 구현해 놓으면 버튼으로 기계의 부분부분들을 통제하여 기계를 사용하는 것이 효율적이다. 기계와 사람사이에 인터페이스 즉 중간역할을 만들어 주면 기계와 사람이 소통하기 쉬워 진다. 다른예로 자판기를 보면 자판기의 버튼을 누르면(인터페이스) 기계가 작동하는 역할임
##### 1번장점 컴퓨터 예시 또다른 예는 컴퓨터로 컴퓨터의 하드웨어를 직접적으로 사용하기는 어렵다. 그것을 해결하고자 윈도우(OS), Operating System 운영체제 GUI Graphic User Interface로 일종의 인터페이스 중간역할 화면만 클릭하면 컴퓨터에 명령을 줌 안의 하드웨어가 변경된다고 하더라도 사람이 인터페이스에 익숙해지면 명령을 주는 행동에는 변화가 되지 않고 자연스럽게 사용할 수 있음. 즉 변경에 유리하고 연결, 대화, 소통을 도와준다.
2번째 장점

### 인터페이스의 장점 2 선언(설계)와 구현을 분리시킬 수 있게 한다. 일반적으로 클래스에서 메서드가 선언 및 정의를 해놓는데 메서드만 떼어내서 인터페이스에 선언만 넣어놓을 수 있다. 분리시켜놓을 수 있다. 분리하지 않으면 유연하지 않고 변경에 불리하다. 분리하면 다른클래스에서 구현을 시킬 수 있고 유연해진다. 변경이 쉽다.

### 인터페이스의 장점 3 인터페이스 덕분에 B가 변경되어도 A는 안바꿀수 있다.(느슨한 결합) A라는 클래스가 B라는 클래스를 사용하고 즉 의존되어 있을때 B라는 클래스가 더이상 사용되어지지 않고 다른형태로 변경되어야하면 A라는 클래스의 형태도 변화시켜야 하지만 인터페이스로 싸여진 B라는 클래스를 사용하고 있을때 인터페이스(즉 버튼부분만 사용하는 법만 알면)만 알면 인터페이스 내부의 변화에 따라서 바꾸지 않아도 된다. 기계로서 생각해보면 기계 부품과 사용법이 바뀌면 그것을 사용하는 사람이 조작방법이 바뀌지만 껍데기 화면 부분은 일치화 시키면 내부가 바뀌든 말든 아무런 조작방법의 변화없이 사용가능

## 내부 클래스 클래스 안에 만들어진 다른 클래스로 중첩클래스라고 함 두개의 클래스가 긴밀한 관계가 있을 때 선언한다. 내부 클래스의 장점 > 두 클래스 멤버들 간에 손쉽게 접근할 수 있다. > 불필요한 클래스를 감춰 코드의 복잡성 최소화
##### 클래스의 명칭 외부클래스 >다른 클래스 내부에 존재하지 않고 독립적으로 정의된 클래스 클래스 파일의 최상위 레벨에 위치 내부 클래스 > 클래스의 내부에서 선언 및 정의된 클래스 외부클래스와 밀접한 관계를 가지며 멤버로 간주됨 외부클래스의 멤버에 쉽게 접근할수 있음
##### 주요특징 - 외부 클래스의 멤버에 대한 쉬운 접근 > 외부 클래스의 private 멤버에도 접근이 가능함 - 외부 클래스와의 강한 연관성 > 외부 클래스의 인스턴스와 상호작용 및 데이터를 공유 가능 - 접근 제어 및 용도 제한 > 내부 클래스를 통해 정근 제어를 조정 및 코드 구조 조정가능 내부 클래스를 private으로 선언하여 외부에서의 직접 접근 제한가능
### 내부클래스 종류 |종류|설명 |---|--- |인스턴스 내부 클래스
(Instance Inner Class)|- 외부 클래스의 인스턴스 변수와 동일한 생명 주기를 가지는 내부 클래스
- 외부클래스의 멤버변수에 접근하여 사용함
- 외부클래스의 모든 멤버에 접근가능
- 외부클래스의 인스턴스를 생성한 후 해당 인스턴스를 사용하여 내부 클래스의 인스턴스를 생성 |정적 내부 클래스
(Static Inner Class)|- 정적 멤버로 선언된 클래스
-외부클래스의 인스턴스에 종속되지 않고 외부클래스의 정적멤버와 유사한 특성을 가짐
- 외부 클래스의 인스턴스를 생성하지 않고도 생성가능 |지역 클래스
(Local Inner Class)|- 메소드 내에 선언된 클래스로 해당 메소드 내에서만 유효한 클래스
- 주로 메소드 내부에서 임시적인 기능을 구현하기 위해 사용
- 외부 클래스의 멤버에 접근 가능 메소드 내에서는 제한
#### 인스턴스 클래스 ##### 인스턴스 클래스의 정의 외부 클래스 내에 멤버를 넣어줄 부분에서 선언한다. ``` java class Out{ int a = 10; class In{ int b = 1; } } ```
##### 인스턴스 클래스의 객체 생성 외부클래스의 인스턴스를 생성하고 외부클래스명 객체명 = new 클래스명(); 외부클래스명.내부클래스명 객체명 = 외부클래스의 객체명.new 내부클래스명(); ``` java Out a = new Out(); Out.in b = a.new in(); ```
##### 인스턴스 클래스의 활용 - 인스턴스변수 접근 / 접근제한 private >private로 접근이 제한되어 있는 변수도 접근이 가능하다 클래스 내부에서 사용하는 것이기 때문에 메서드를 사용하는 것과 같다고 보면됨 ``` java package pj; class Out{ private int a = 10; // 정적변수 class in{ int b = 1; void f() { System.out.println(a); //정적 변수 접근 } } } public class t1 { public static void main(String[] args) { Out a = new Out(); Out.in b = a.new in(); System.out.println(b.b); // 내부 인스턴스 변수 접근 b.f(); } } // 출력 // 1 10 ```
- 정적변수 및 메서드 접근 > 정적변수 및 메서드도 메모리에 미리 올라온 형태로 인하여 사용간 제한 없다. ``` java package pj; class Out{ private int a = 10; // 인스턴스 변수 static int as = 100;// static 변수 static void fas(int x) {// static 메서드 as = x; // a = x2; static으로 인스턴스 접근 불가능 } class in{ int b = 1; void f() { System.out.println(a); //인스턴스 변수 접근 } void fs() { fas(101); //static 메서드 호출 System.out.println(as); // static 변수 접근 } } } public class t1 { public static void main(String[] args) { Out a = new Out(); Out.in b = a.new in(); System.out.println(b.b); b.f(); b.fs(); } } // 출력 // 1 10 101 ```
- 변수접근 방법 >동일한 명의 변수를 불러들이는 방식 메서드에서 지역변수 불러들이려면 변수명 사용 내부 클래스 내 변수 자신 : this.변수명 외부클래스 내 변수 : 외부클래스명.this.변수명 ``` java class Out{ private int a = 10; class in{ int a = 1; void f(int a) { System.out.println("함수 내부 = "+a); System.out.println("내부 변수 = "+this.a); System.out.println("외부 변수 = "+Out.this.a); } } } public class t1 { public static void main(String[] args) { Out a = new Out(); Out.in b = a.new in(); b.f(100); } } // 출력 // 함수 내부 = 100 내부 변수 = 1 외부 변수 = 10 ```
- 다른 외부 클래스 상속 > 내부 클래스가 자신의 외부 클래스가 아닌 다른 외부 클래스를 상속하여 사용할수 있다. ``` java class Out{ private int a = 10; class in extends Out2{ int a = 1; void f(int a) { System.out.println("함수 내부 = "+a); System.out.println("내부 변수 = "+this.a); System.out.println("외부 변수 = "+Out.this.a); System.out.println("부모클래스 변수 = "+super.a); } } } class Out2{ protected int a = 1000; } public class t1 { public static void main(String[] args) { Out a = new Out(); Out.in b = a.new in(); b.f(100); } } // 출력 // 함수 내부 = 100 내부 변수 = 1 외부 변수 = 10 부모클래스 변수 = 1000 ```
- 외부 클래스의 부모클래스 접근 ``` java class Out extends Out2{ private int a = 10; class in{ int a = 1; void f(int a) { System.out.println("함수 내부 = "+a); System.out.println("내부 변수 = "+this.a); System.out.println("외부 변수 = "+Out.this.a); System.out.println("외부의 부모클래스 변수 = "+Out.super.a); } } } class Out2{ protected int a = 2000; } public class t1 { public static void main(String[] args) { Out a = new Out(); Out.in b = a.new in(); b.f(100); } } // 출력 // 함수 내부 = 100 내부 변수 = 1 외부 변수 = 10 외부의 부모클래스 변수 = 2000 ```

#### 정적 클래스 > 외부 클래스의 인스턴스 멤버에 접근이 불가능함 외부 클래스를 인스턴스화(객체) 하지 않고 인스턴스 가능 ##### 정적 클래스의 정의 외부 클래스 내에 멤버를 넣어줄 부분에서 static으로 선언 ``` java class Out{ static class In{ } } ```
##### 정적 클래스의 객체 생성 외부 클래스의 인스턴스를 생성하지 않아도 생성가능 외부클래스명.내부클래스명 객체명 = new 외부클래스명.내부클래스명(); ``` java Out.in a = new Out.in(); ```
##### 정적 클래스 활용 외부 클래스의 인스턴스 변수에 접근 제한 ``` java class Out{ private int x = 10; static private int sx = 30; static class in{ int a = 1; void f() { // System.out.println("외부 인스턴스 변수 = "+x); 외부 클래스의 인스턴스 접근 불가 System.out.println("내부 인스턴스 변수 = "+a); System.out.println("외부 static 변수 = "+sx); } } } public class t1 { public static void main(String[] args) { Out.in a = new Out.in(); a.f(); } } // 출력 // ```

#### 지역 클래스 > 메서드 내에서 선언되어 사용 주로 메소드 내부에서 임시적인 기능을 구현하기 위해 사용 외부 클래스의 멤버에 접근 가능 메소드 내에서는 제한 ##### 지역 클래스의 정의 메서드 내에서 선언하고 사용함 ``` java class Out{ void a() { class In{ } } } ```
##### 지역 클래스의 객체 생성 메서드 내부에서만 사용가능함. ``` java void a() { class In{ } In ic = new In(); } ```
##### 지역 클래스 활용 ``` java class Out{ private int x = 10; static private int sx = 30; void a(String f1) { class In{ int ix = 1; String isx = "안녕"; } In ic = new In(); ic.isx = f1; ic.ix = this.x; System.out.println(ic.isx+" "+ic.ix); } } public class t1 { public static void main(String[] args) { Out oc = new Out(); oc.a("사람"); } } // 출력 // 사람 10 ``` ##### 지역 클래스 상속 ``` java class Out extends Out2{ //외부클래스가 상속 private int x = 10; static private int sx = 30; void a(String f1) { class In{ int ix = 1; String isx = "안녕"; } In ic = new In(); ic.isx = f1; ic.ix = super.a; //외부클래스가 상속받은 클래스변수에 접근 System.out.println(ic.isx+" "+ic.ix); } } class Out2{ protected int a = 1000; } // 출력 // 사람 1000 ```

## 예외 처리 > 발생하는 예외에 대해서 처리가하고 넘길수 있음
#### 에러와 예외 > 에러 : 시스템에 비정상적인 상황이 생겼을때 발생함 외부요인 및 구동중에 발생하는 치명적 오류일 가능성 있음 개발자가 예측 및 처리할 수 없는 영역 > 예외 : 프로그램 구동중에 나타나는 오류 문법적으로 문제없지만 실제 운영중 생기는 문제 > 예외의 종류 체크 예외 : 컴파일 도중 확인 문법적으로 강제 비체크 예외 : 컴파일 중에 확인 하지 않는 예외

#### 대표적인 예외 ##### NullpointerException > 객체가 제대로 생성되지 않은 상태에서 사용할 경우 발생 ``` java public static void main(String[] args) { int[] a = null; System.out.println(a[0]); } // 출력 // Exception in thread "main" java.lang.NullPointerException: Cannot load from int array because "a" is null at pj.t1.main(t1.java:10) ```

##### NumberFormatException > 문자열을 숫자로 형변환시 사용되는 예외 10.1 이라는 문자를 정수로 변환시 예외
문자를 숫자를 변형하는 법 ``` java String a = "10"; int i1 = Integer.parseInt(a); //정수로 변환 String b = "11.1"; float f1 = Float.parseFloat(b); //실수로 변환 ```
잘못된 작성으로 예외 발생 ``` java int i2 = Integer.parseInt(b); //에러 // 출력 // Exception in thread "main" java.lang.NumberFormatException: For input string: "11.1" at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67) at java.base/java.lang.Integer.parseInt(Integer.java:668) at java.base/java.lang.Integer.parseInt(Integer.java:786) at pj.t1.main(t1.java:13) ```

##### ArrayIndexOutOfBoundsException >배열 인덱스 범위 초과 에러 ``` java int[] a = {1,2,3}; System.out.println(a[3]); // 출력 // Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3 at pj.t1.main(t1.java:10) ```

#### 예외 처리 ##### 단일사용 >try{ 예외 발생 가능성 코드 } catch( 예외클래스명 변수명){ 예외 발생시 처리 } ``` java try { int[] a = {10,20,30}; int b = 3; System.out.println(a[b]); } catch(ArrayIndexOutOfBoundsException c) { System.out.println("인덱스 오류"); } // 출력 // 인덱스 오류 ```
##### 다중사용 >try{ 예외 발생 가능성 코드 } catch( 예외클래스명 변수명){ 예외 발생시 처리 } catch( 예외클래스명 변수명){ 예외 발생시 처리 } > 먼저 발생한 예외에 맞게 빠져나옴 ``` java try { int[] a2 = null; System.out.println(a2[1]); int[] a = {10,20,30}; int b = 3; System.out.println(a[b]); } catch(ArrayIndexOutOfBoundsException c) { System.out.println("인덱스 오류"); } catch(NullPointerException c) { System.out.println("null값 오류"); } // 출력 // null값 오류 ```
##### finally 예외 발생유무와 상관없이 반드시 실행하는것으로 생략가능 ``` java try { int[] a2 = null; System.out.println(a2[1]); int[] a = {10,20,30}; int b = 3; System.out.println(a[b]); } catch(ArrayIndexOutOfBoundsException c) { System.out.println("인덱스 오류"); } catch(NullPointerException c) { System.out.println("null값 오류"); } finally { System.out.println("종료"); } // 출력 // null값 오류 종료 ```

## 래퍼클래스(Wrapper Class) >래퍼 클래스란? 자바의 자료형은 기본 타입(primitive type)과 참조 타입(reference type)으로 구분 기본 타입 : Int, char, float, double, boolean 등 참조 타입 : class interface 등 프로그래밍을 하다보면 기본 타입의 데이터를 객체로 표현해야 하는 경우가 종종있음

기본타입을 객체로 다루기 위해서 사용하는 클래스를 래퍼클래스(Wrapper)라고 한다. 래퍼는 포장하다는 의미를 가지고 있음
#### 래퍼클래스의 종류 |기본 타입 | 래퍼클래스 |---|---| |byte|Byte |char|Character |int|Integer |float|Float |double|Double |boolean|Boolean |long|Long |short|Short
> 대략적으로 대문자를 넣는 형태로 쓰며 대표 클래스인 Object 클래스를 상속 받아 사용하고 있다. Object 클래스 는 Boolean, Character, Number를 가지고 있고 Number 안에 정수와 실수를 저장하는 래퍼 클래스 보유
#### 박싱(Boxing)과 언박싱(UnBoxing) >박싱 : 기본 타입의 값을 포장 객체로 만드는 과정 >언박싱 : 포장객체에서 기본타입의 값을 얻어내는 과정 ``` java public static void main(String[] args) { Integer num = new Integer(17); // 박싱 int n = num.intValue(); //언박싱 System.out.println(n); } ```
> 자동 박싱과 언박싱 자동적으로 일어나는 경우도 있다. 참조 타입에 기본값이 대입될때나 기본 타입에 참조값이 대입될때 자동으로 일어남 > 힙 영역에 생성됨 ``` java public static void main(String[] args) { Integer num = 17; // 자동 박싱 int n = num; //자동 언박싱 } ```
#### 래퍼클래스의 사용예제 ##### 문자열을 기본타입 값으로 변환 ``` java public static void main(String[] args) { String str = "10"; String str2 = "10.5"; String str3 = "true"; byte b = Byte.parseByte(str); int i = Integer.parseInt(str); short s = Short.parseShort(str); long l = Long.parseLong(str); float f = Float.parseFloat(str2); double d = Double.parseDouble(str2); boolean bool = Boolean.parseBoolean(str3); System.out.println("문자열 byte값 변환 : "+b); System.out.println("문자열 int값 변환 : "+i); System.out.println("문자열 short값 변환 : "+s); System.out.println("문자열 long값 변환 : "+l); System.out.println("문자열 float값 변환 : "+f); System.out.println("문자열 double값 변환 : "+d); System.out.println("문자열 boolean값 변환 : "+bool); } ```
##### 값비교 > 참조형 과 참조형으로 비교하면 다르다고 나옴 참조형 주소값을 갖고 있기 때문에 기본값을 넣으면 자동 박싱 되어 힙영역에 올라가 비교하면 같다고 나옴 ``` java public static void main(String[] args) { Integer a = new Integer(10); Integer b = new Integer(10); System.out.println("참조형 == 참조형 "+(a==b)); Integer c = 10; Integer d = 10; System.out.println("박싱 == 박싱 "+(c==d)); } // 출력 // 참조형 == 참조형 false 박싱 == 박싱 true ```
##### Object 클래스 활용 >Object 클래스는 모든 클래스의 부모로 타입을 정하게 되면 값에 따라서 어떠한 클래스로든 볼수 있다. ``` java public class t1 { Object data; void adddata(Object a) { this.data = a; } public static void main(String[] args) { t1 a = new t1(); a.adddata(new Integer(100)); System.out.println("Integer형태 = " + a.data); a.adddata(new String("안녕")); System.out.println("String형태 = " + a.data); } } // 출력 // Integer형태 = 100 String형태 = 안녕 ```
Value 및 문자열 변형 ``` java public class t1 { Object data; Integer i; void adddata(Object a) { this.data = a; } public static void main(String[] args) { t1 a = new t1(); a.i = new Integer(10); int i = a.i.intValue(); System.out.println(i); Scanner sc = new Scanner(System.in); System.out.print("문자열 입력 >> "); a.i = a.i.parseInt(sc.next()); i = a.i.intValue(); System.out.println(i); } } // 출력 // 10 문자열 입력 >> 500 500 ```

## 제너릭 > 데이터 형식에 의존하지 않고 하나의 값이 여러 다른 데이터 타입들을 가질 수 있도록 하는 방법
#### Object 타입으로 데이터 잡을때 문제점 > 일반적으로 동일한 스타일의 클래스들은 하나의 형태로 만들어 주는것이 객체지향의 장점을 살리는데 기본임 유사한작업을 하는 클래스 ``` java public class t1 { public static void main(String[] args) { iclass ic = new iclass(10); idata id = new idata(ic); sclass sc = new sclass(5); sdata sd = new sdata(sc); System.out.println(id.a.i); System.out.println(sd.a.i); } } class iclass{ int i; iclass(int a){ this.i = a; } } class idata{ iclass a; idata(iclass a){ this.a = a; } } class sclass{ int i; sclass(int a){ this.i = a; } } class sdata{ sclass a; sdata(sclass a){ this.a = a; } } // 출력 // 10 5 ```
모두가 가지고 있는 공통 부모로 변경할 수 있음 Object 클래스형태로 변경 ``` java public class t1 { public static void main(String[] args) { iclass ic = new iclass(10); data id = new data(ic); sclass sc = new sclass(5); data sd = new data(sc); iclass ic2 = (iclass)id.a; sclass sc2 = (sclass)sd.a; System.out.println(ic2.i); System.out.println(sc2.i); } } class iclass{ int i; iclass(int a){ this.i = a; } } class sclass{ int i; sclass(int a){ this.i = a; } } class data{ Object a; data(Object a){ this.a = a; } } // 출력 // 10 5 ```
> 참조 타입을 넣어주는 이유는 그 참조타입으로만 데이터를 받으려고 하였지만 Object는 부모이기 때문에 어떠한 데이터 타입이 들어가도 문제가 없다고 나옴 물론 Object말고 프로그래머가 만든 클래스는 문제가 발생 ``` java int a = 10; data id = new data(a); iclass ic = (iclass)id.a; // 출력 // 에러 ```

#### 제너릭을 사용하는 이유 > 내가 원하는 타입의 데이터만을 넣어줄수 있도록 객체를 만들때 데이터 타입을 선정해주어 데이터중 들어갈수 있는 것만 넣어줌
예시 ``` java class data{ //c는 이름일 뿐 c a; data(c a){ this.a = a; } } ``` ``` java public class t1 { public static void main(String[] args) { iclass ic = new iclass(1); sclass sc = new sclass(10); data id = new data(ic); //에러 data id2 = new data(ic); 다른 타입 들어감 data id2 = new data(sc); System.out.println(id.a.i); System.out.println(id2.a.i); } } class iclass{ int i; iclass(int a){ this.i = a; } } class sclass{ int i; sclass(int a){ this.i = a; } } class data{ c a; data(c a){ this.a = a; } } // 출력 // 1 10 ```

#### 제너릭의 한계 및 해결 > 제너릭은 기본타입에 대해서는 넣어줄수 없다. 그래서 기본타입의 래퍼클래스인 참조타입으로 시행 ``` java public class t1 { public static void main(String[] args) { //에러 기본형은 안됨 data a = new data(10); data a = new data(10); System.out.println(a.a); System.out.println(a.a.intValue()); } } class data{ T a; data(T a){ this.a = a; } } // 출력 // 10 10 ```

## 람다식 ``` java public class t1 { public static void main(String[] args) { itf o = (a,b) -> a>b ? a:b; System.out.println(o.max(100, 20)); } } interface itf{ int max(int a, int b); } ```

``` java ``` ``` java // 출력 // ```