개발자
[JAVA 18일차] final/인터페이스(interface)/ArrayIndexOutOfBoundsException/e.getMessage()/e.printStackTrace()/finally/새우깡잔고 본문
개발자/JAVA
[JAVA 18일차] final/인터페이스(interface)/ArrayIndexOutOfBoundsException/e.getMessage()/e.printStackTrace()/finally/새우깡잔고
GoGo개발 2022. 8. 28. 16:23final
더이상 값을 할당 할수 없고, 클래스면 상속받을 수 없다.
1.<final 클래스가 아닌 부모 클래스>
:rule 메소드가 final 메소드일 때 && PI 필드가 final 필드일때
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package my.day18.a.Final;
public class Final_test_1 {
public String id;
public String name;
// 필드에 final 이 붙으면 더 이상 새로운 값으로 할당 할 수 없다.
public final double PI =3.141592; // 한번 적은건 변경 불가, final은 구분지으려고 관습상 대문자로 쓴다.\
public void greeting() {
System.out.println("== 안녕하세요 ==");
}
// 메소드에 final 을 붙이면 자식 클래스에서 메소드의 overriding(재정의)을 할 수 없게 된다.
public final void rule() {
System.out.println("== 정직하게 삽시다 ==");
}
}
|
cs |
<자식 클래스>
:부모 클래스의 final 메소드인 rule()메소드는 재정의 할 수 없다.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package my.day18.a.Final;
public class Child_final_tes_1 extends Final_test_1 {
int age;
public void test() {
System.out.println(">> 연습입니다. <<");
}
@Override
public void greeting() {
System.out.println("\n~~~~~~~~~hi!!! hello~~~~\n");
}
/*
=== final 메소드는 overriding(재정의)을 할 수 없다. ===
@Override
public void rule() {
System.out.println("== 정직하게 삽시다 ==");
}
*/
}
|
cs |
<main 클래스>
:PI 필드가 final 이므로 새로운 값을 할당 할 수 없다.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package my.day18.a.Final;
public class Main_final_test_1 {
public static void main(String[] args) {
Final_test_1 ft1 = new Final_test_1();
ft1.id = "leess";
ft1.name = "이순신";
// ft1.PI = 2.3424; // final이므로 새로운 값을 할당 할 수 없기에 오류임.
///////////////////////////////////////////////////
Child_final_tes_1 child = new Child_final_tes_1();
child.greeting();
child.rule();
}
}
|
cs |
2.<final 클래스인 부모 클래스>
:클래스가 fianl로 되어져있는 부모클래스일때
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
// final 로 되어진 클래스는 다른 클래스로 상속해줄 수 없다는 말이다.
//즉, Final로 되어진 클래스는 다른 클래스에서 부모 클래스로 사용할 수 없다는 말이다.
public final class Final_test_2 {
String id;
String name;
public void example() {
System.out.println("== 연습입니다. ==");
}
}
|
cs |
<자식 클래스>
:final 클래스인 부모클래스를 상속받을 수 없다
|
1
2
3
4
5
6
7
8
|
package my.day18.a.Final;
public class Child_final_test_2 extends Final_test_2{
// final_test_2 클래스가 final 클래스 이므로 상속받을 수 없다.
}
|
cs |
인터페이스(interface)
자바에서는 인터페이스라는 것을 통해 다중 상속을 지원하고 있습니다.
인터페이스(interface)란 다른 클래스를 작성할 때 기본이 되는 틀을 제공하면서, 다른 클래스 사이의 중간 매개 역할까지 담당하는 일종의 추상 클래스를 의미합니다.
자바에서 추상 클래스는 추상 메소드뿐만 아니라 생성자, 필드, 일반 메소드도 포함할 수 있습니다.
하지만 인터페이스(interface)는 오로지 추상 메소드와 상수만을 포함할 수 있습니다.
자바의 다형성을 극대화하여 개발코드 수정을 줄이고 프로그램 유지보수성을 높이기 위해 인터페이스를 사용한다.
즉, 극단적으로 동일한 목적 하에 동일한 기능을 수행하게끔 강제하는 것이 바로 인터페이스의 역할이자 개념이다.
1.<인터페이스의 선언 : interface 클래스>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
public interface Figure {
// == 인터페이스(interface)란? ==
/*
오로지 미완성메소드(추상메소드)와 field 는 final 변수로만 이루어진것을 말한다.
그리고 미완성메소드(추상메소드)와 field 의 전급제한자는 public 으로만 되어진다.
field 생성시 public final 이 생략되어져 있다.
미완성메소드(추상메소드) 생성시 public abstract 가 생략되어져 있다.
*/
// field ==> public final 이 생략되어져 있다. 변경불가 라는 뜻.
double PI = 3.141592;
// 즉, public final double PI = 3.141592; 이다.
// 삼각형, 사각형의 면적을 구하는 미완성 메소드
//method ==> public abstract 가 생략되어져 있다. 본문 중괄호{} 넣으면 안된다. 오류남.
double area(double x, double y);
//즉, public abstract double area(double x, double y); 이다.
//추상클래스가 더큰가?
//메소드의 오버로딩
//원의 면적을 구하는 메소드 미완성 메소드
double area(double r); // 파라미터 개수 달라서 가능
}// end of class-------------------------
|
cs |
자바에서는 다음과 같이 상속과 구현을 동시에 할 수 있습니다.
문법 : class 클래스이름 extend 상위클래스이름 implements 인터페이스이름 { ... }
인터페이스는 인터페이스로부터만 상속을 받을 수 있으며, 여러 인터페이스를 상속받을 수 있습니다.
<상속받은 클래스 1>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class Rectangle implements Figure {
@Override
public double area(double x, double y) {
return x*y;
}
@Override
public double area(double r) {
return 0;
}
}
|
cs |
<상속받은 클래스 2>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class Triangle implements Figure {
// Triangle 이라는 클래스는 Figure 라는 인터페이스를 implements(구현)한다는 말이다. 안쓰더라도 Figure 클래스의 미완성 메소드 재정의 필수
@Override
public double area(double x, double y) {
return x*y*0.5;
}
@Override
public double area(double r) {
return 0;
}
}
|
cs |
<상속받은 클래스3>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class circle implements Figure {
@Override
public double area(double x, double y) {
return 0;
}
@Override
public double area(double r) {
return PI*r*r;
}
}
|
cs |
<Main 클래스>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
public static void main(String[] args) {
Triangle tri = new Triangle();
Rectangle rect = new Rectangle();
circle cir = new circle();
System.out.println("밑변 4, 높이 5 인 삼각형의 넓이 = > " + tri.area(4, 5));
System.out.println("밑변 4, 높이 5 인 사각형의 넓이 = > " + rect.area(4, 5));
System.out.println("반지름이 5인 원의 넓이 ==> " + cir.area(5));
System.out.println("\n------------------------------------------\n");
// >> 다형성(Polymorphism) <<<<
// ==> 상속을 이용하여 여러 클래스 타입을 하나의 클래스 타입으로 다루는 기술.
// 자식클래스로 생성되어진 객체를 부모 클래스 타입으로 받을 수 았다는 것이 다형성(Polymorphism)이다.
// 인터페이스로 구현된 클래스의 객체는 그 인터페이스의 타입으로 받을수 있다는 것이 다형성(Polymorphism)이다.
Figure fg1 = new Triangle(); //Triangle 자식클래스 Figure 부모클래스
Figure fg2 = new Rectangle();
Figure fg3 = new circle();
System.out.println("밑변 4, 높이 5 인 삼각형의 넓이 = > " + fg1.area(4, 5));
System.out.println("밑변 4, 높이 5 인 사각형의 넓이 = > " + fg2.area(4, 5));
System.out.println("반지름이 5인 원의 넓이 ==> " + fg3.area(5));
System.out.println("\n------------------------------------------\n");
Figure[] fig_arr = new Figure[3];
fig_arr[0] = new Triangle();
fig_arr[1] = new Rectangle();
fig_arr[2] = new circle();
for(Figure fg : fig_arr) {
if(fg instanceof Triangle) {
System.out.println("밑변 4, 높이 5 인 삼각형의 넓이 = > " + fg1.area(4, 5));
}
else if(fg instanceof Rectangle) {
System.out.println("밑변 4, 높이 5 인 사각형의 넓이 = > " + fg2.area(4, 5));
}
else if(fg instanceof circle) { // else 도괜찮다)
System.out.println("반지름이 5인 원의 넓이 ==> " + fg3.area(5));
}
}// end of for--------------------------
}// end of main()-----------------------
}
|
cs |
출력값 :
모두 동일하게
밑변 4, 높이 5 인 삼각형의 넓이 = > 10.0
밑변 4, 높이 5 인 사각형의 넓이 = > 20.0
반지름이 5인 원의 넓이 ==> 78.5398
<다중상속>
interface Inter_fater(work()메소드), Inter_mother(cook()메소드) 클래스 있다는 가정하에
<fater,mother 상속받은 inter_me 인터페이스 클래스>
|
1
2
3
4
5
6
7
8
9
10
|
package my.day18.c.multi_interface;
public interface Inter_Me extends Inter_Father, Inter_Mother {
//자바는 인터페이스가 여러 인터페이스를 상속받는 다중상속이 가능하다.!! 클래스는 불가능
void play();
//public abstract void play(); 이다.
}// end of interface------------------
|
cs |
<inter_me 인터페이스 클래스를 상속받은 자식 클래스>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package my.day18.c.multi_interface;
public class Me implements Inter_Me {
@Override
public void work() {
System.out.println("보람차게 일합니다.!!");
}
@Override
public void cook() {
System.out.println("맛있는 음식을 요리합니다.~~");
}
@Override
public void play() {
System.out.println("재미있게 놀아요^^");
}
}
|
cs |
<father , mother 인터페이스 클래스를 상속받은 자식 클래스>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package my.day18.c.multi_interface;
public class Me2 implements Inter_Father, Inter_Mother {
// 자바에서는 클래스 생성시 다중 인터페이스 구현이 가능하다.
@Override
public void cook() {
System.out.println("맛좋은 음식을 요리합니다.~~ 냠냠~~~");
}
@Override
public void work() {
System.out.println("열심히 땀흘려 일합니다.!!");
}
}
|
cs |
<main 클래스>
<18 Gujikja 코딩해보기>
ArrayIndexOutOfBoundsException
배열의 크기가 오버가 되어지면 발생하는 익셉션
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
System.out.println("\n 1.~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \n");
// 1. ArrayIndexOutOfBoundsException
// ==> 배열의 크기가 오버가 되어지면 발생하는 익셉션
// String[] subject_arr = new String[]{"자바","오라클","JSP"};
// 또는
String[] subject_arr = {"자바","오라클","JSP"};
try {
for(int i=0; i<=subject_arr.length; i++) {
System.out.println(subject_arr[i]);
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println(">> 배열의 인덱스 범위가 초과되었습니다. <<");
// System.out.println(e.getMessage());
// e.getMessage() 는 오류메시지를 알려주는 것이다.
// e.printStackTrace(); // 어디가 오류인지를 추적해서 알려준다.
}
|
cs |
ArithmeticException
분모에 0 이 들어가는 경우에 발생하는 익셉션
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
try {
int num = 10;
for(int i=2; i>=0; i--) {
System.out.println(num/i);
}
} catch(ArithmeticException e) {
System.out.println(">> 분모에는 0 이 올 수 없습니다. \n");
// System.out.println(e.getMessage());
// e.getMessage() 은 오류메시지를 알려주는 것이다.
// e.printStackTrace(); // 어디가 오류인지를 추적해서 알려준다.
}
|
cs |
<try catch 여러개>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
System.out.println("\n 5.~~~~~~~~~~~~~~~~~~~~~~~~ \n");
String[] str_arr = {"10","스물","30"};
for(int i=3; i>=0; i--) {
try {
int val = Integer.parseInt(str_arr[i])/i;
System.out.println(val);
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println(">> 배열의 인덱스 범위가 초과되었습니다. <<");
} catch(ArithmeticException e) {
System.out.println(">> 분모에는 0 이 올 수 없습니다. \n");
} catch(Exception e) {
System.out.println("오류 메시지 : " + e.getMessage());
}
}// end of for------------------------------------
또는
int[] num2_arr = {10,20,30};
for(int i=3; i>=0; i--) {
try {
int val = num2_arr[i]/i;
System.out.println(val);
} catch(ArrayIndexOutOfBoundsException | ArithmeticException e) {
e.printStackTrace();
}
}// end of for------------------------------------
|
cs |
=== [!!! 중요 !!!] === 익셉션 처리시 부모클래스의 익셉션이 맨 아래에 나와야 한다. 왜냐하면 익셉션 처리는 위에서 처리되면서 위의것이 처리가 안되면 아래로 내려가라는 말인데 부모 클래스의 익셉션이 먼저 나오고 자식 클래스의 익셉션이 아래에 나오면 부모클래스 익셉션이 처리를 못한것을 자식클래스 익셉션이 처리를 해라는 것은 모순이기 때문이다.
finally
finally 은 위에서 오류가 발생하든지 또는 위에서 오류가 발생하지 않든지 관계없이
무조건 실행해야 하는 것들은 finally 속에 기술해주면 된다
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
System.out.println("\n 7.~~~~~~~~~~~~~~~~~~~~~~~~ \n");
String[] str_num2_arr = {"10","20","삼십","40"};
int count2 = 0;
for(String str : str_num2_arr) {
try {
System.out.println(Integer.parseInt(str));
} catch(Exception e) {
System.out.println(str+"은 숫자로 변경이 불가합니다.");
} finally {
// finally 은 위에서 오류가 발생하든지 또는 위에서 오류가 발생하지 않든지 관계없이
// 무조건 실행해야 하는 것들은 finally 속에 기술해주면 된다.
System.out.println(++count2 + "번 반복 >> 여기는 오류가 발생하든 발생하지 않든 무조건 실행되어야 합니다. <<\n");
}
}// end of for--------------------
|
cs |
'개발자 > JAVA' 카테고리의 다른 글
| [JAVA] 함수형 프로그래밍/익명 클래스/람다/함수형 인터페이스 (0) | 2023.03.21 |
|---|---|
| [JAVA 19일차] 익명(무명) 클래스/람다식/collection/ArrayList/Generic/linkedlist/HashMap/iterator (0) | 2022.08.29 |
| [JAVA 17일차]다중상속/다형성/상속성/instanceof/추상메소드(미완성메소드)/오버로딩,오버라이딩/block/ (0) | 2022.08.28 |
| [JAVA 16일차] (0) | 2022.08.27 |
| [java 15일차] get,set/캡슐화/ctrl,Main,Gujikja 클래스의 관계 (0) | 2022.08.27 |