자바 입문 에서 진급 의 길 (13)

이전 글 에서 우 리 는 자바 류 의 private, static, final 을 소개 했다. 이 장 에서 자바 의 추상 류 와 추상 적 인 방법 을 살 펴 보 자.
우 리 는 먼저 다음 코드 를 살 펴 보 자.

 1 //        
 2 class Square { //    
 3     double c;
 4 
 5     double area() { //     
 6         return 0.0625 * c * c;
 7     }
 8 }
 9 
10 class Circle { //    
11     double c;
12 
13     double area() { //     
14         return 0.0796 * c * c;
15     }
16 }

위의 코드 에서 우 리 는 각각 사각형 류 와 원형 류 를 정의 한 다음 에 둘레 에 따라 각자 의 면적 을 계산한다.어떻게 위의 코드 에서 이 두 단락 의 코드 가 모두 같은 부분 을 가지 고 있 는 지 알 수 있 습 니 다. 우 리 는 첫 번 째 느낌 은 같은 부분 을 하나의 부류 로 포장 한 다음 에 집적 방식 으로 완성 하 는 것 입 니 다. 다음 과 같 습 니 다.

 1 class Shape { //   
 2     double c;
 3 
 4     double area() { //     return        
 5         return    * c * c; //         
 6     }
 7 
 8     void area() { //         ，               
 9 
10     }
11 }
12 
13 //        
14 class Square extends Shape { //    
15 
16 }
17 
18 class Circle extends Shape { //    
19 
20 }

위의 코드 에서 우 리 는 단독으로 Shape 류 를 봉 인 했 지만 한 가지 문제 가 있 습 니 다. 둘레 c 는 공공 적 인 문제 가 없 지만 면적 area () 방법 은 서로 다른 도형 의 면적 계수 가 다 르 기 때문에 해결 할 수 없습니다. 이때 추상 적 인 방법 으로 해결 해 야 합 니 다. 즉, 방법 체 앞 에 abstract 키 워드 를 추가 하면 다음 과 같 습 니 다.

1 class Shape { //   
2     double c;
3 
4     abstract double area(); //      --   
5 
6 }

추상 적 인 방법의 정의:
 1. abstract 로 수식 한다.
 2. 방법의 정의 만 있 고 방법의 실현 이 없다 (대괄호 도 없다).
그러나 추상 적 인 방법 은 완전 하지 않 기 때문에 우 리 는 유형 도 추상 적 인 유형 으로 바 꿔 야 한다. 다음 과 같다.

1 abstract class Shape { //    --   
2     double c;
3 
4     abstract double area(); //      --   
5 
6 }

추상 클래스 의 정의:
 1. abstract 로 수식 한다.
 2. 추상 적 인 방법 을 포함 하 는 유형 은 반드시 추상 적 인 유형 이 어야 한다.
 3. 추상 류 는 예화 되 어 서 는 안 된다.
 4. 추상 류 는 계승 되 어야 하기 때문에 자 류 는 다음 과 같이 필요 하 다.
1) 모든 추상 적 인 방법 을 다시 쓴다 --- 상용
2) 추상 적 이지 않 은 클래스 --- 자주 사용 하지 않 음
 
4 시 에 추상 류 는 계승 되 어야 합 니 다. 다음 과 같은 코드 입 니 다.

 1 abstract class Shape { //    --   
 2     double c;
 3 
 4     abstract double area(); //      --   
 5 
 6 }
 7 
 8 
 9 class Square extends Shape { //     ，      Shape  ，Shape          
10 
11 }
12 
13 //   
14 abstract class Square extends Shape { //     ，   Square         
15 
16 }
17 
18 //   
19 class Square extends Shape { //     ，  Square              
20     double area() {
21         return 0.0625 * c * c;
22     }
23 }

위의 코드 에서 우 리 는 추상 류 와 추상 적 인 방법 을 실 현 했 지만 쓸데없는 짓 을 한 것 처럼 보인다. 다음 과 같다.

1 class Shape { //            c
2     double c;
3 }
4 
5 abstract class Shape { //    --   
6     double c;
7 
8     abstract double area(); //      --   
9 }

위의 코드 에서 우 리 는 공공 변수 둘레 c 만 추출 하면 됩 니 다. area () 방법 은 어차피 다시 써 야 하 는 것 이 니 쓸데없는 짓 을 할 필요 가 있 습 니까?
다음은 다음 의 수 요 를 살 펴 보 자. 각각 둘레 c = 1, 2, 3 으로 세 개의 Square 와 Circle 류 를 만 든 다음 에 이 6 개의 도형 중에서 면적 이 가장 큰 하 나 를 찾 는 것 이다.우리 가 먼저 생각 한 방법 은 다음 과 같다.

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         Square[] squares = new Square[3];
 4         squares[0] = new Square(1);
 5         squares[1] = new Square(2);
 6         squares[2] = new Square(3);
 7 
 8         Circle[] circles = new Circle[3];
 9         circles[0] = new Circle(1);
10         circles[1] = new Circle(2);
11         circles[2] = new Circle(3);
12 
13         /**
14          * 1、   squares       sMax
15          * 2、   circles       cMax
16          * 3、   sMax   cMax     
17          */
18 
19     }
20 }
21 
22 class Shape {
23     double c;
24 }
25 
26 class Square extends Shape {
27     Square(double c) {
28         this.c = c;
29     }
30 
31     double area() {
32         return 0.0625 * c * c;
33     }
34 }
35 
36 
37 class Circle extends Shape {
38     Circle(double c) {
39         this.c = c;
40     }
41 
42     double area() {
43         return 0.0796 * c * c;
44     }
45 }

위의 코드 에서 우 리 는 먼저 하나의 배열 을 정의 합 니 다. 그 안에 세 개의 둘레 c = 1, 2, 3 의 Square 를 저장 한 다음 에 하나의 배열 을 정의 합 니 다. 그 안에 세 개의 둘레 c = 1, 2, 3 의 Circle 을 저장 한 다음 에 우 리 는 두 배열 중 면적 의 최대 치 를 계산 한 다음 에 면적 이 가장 큰 하 나 를 비교 합 니 다. 이것 은 우리 의 문 제 를 해결 할 수 있 습 니 다. 그러나 가격 이 육각형 이 라면...하나의 배열 을 더 정의 해 야 합 니 다. 그러면 우리 가 위 에 쓴 코드 는 코드 가 중복 되 고 확장 성 이 떨 어 지 며 유지 성 이 떨 어 지 는 문제 가 발생 합 니 다.
다음은 추상 적 인 방법 으로 쓰 겠 습 니 다.

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         Shape[] shapes = new Shape[6]; //     
 4         shapes[0] = new Square(1);
 5         shapes[1] = new Square(2);
 6         shapes[2] = new Square(3);
 7         shapes[3] = new Circle(1);
 8         shapes[4] = new Circle(2);
 9         shapes[5] = new Circle(3);
10 
11         double max = shapes[0].area(); //           
12         for(int i=1;i){
13             double area = shapes[i].area();
14             if(area > max){
15                 max = area;
16             }
17         }
18         System.out.println(max);
19     }
20 }
21 
22 abstract class Shape {
23     double c;
24     abstract double area();
25 }
26 
27 class Square extends Shape {
28     Square(double c) {
29         this.c = c;
30     }
31 
32     double area() {
33         return 0.0625 * c * c;
34     }
35 }
36 
37 
38 class Circle extends Shape {
39     Circle(double c) {
40         this.c = c;
41     }
42 
43     double area() {
44         return 0.0796 * c * c;
45     }
46 }

위의 코드 에서 우 리 는 먼저 Shape [] 배열 을 정의 한 다음 에 위로 스타일 링 하 는 방식 으로 배열 에 Square 와 Circle 을 각각 추가 하면 한 배열 에서 최대 치 를 비교 하면 됩 니 다. 오각형 을 추가 하면 육각형 은 Shape [] 배열 만 확장 하면 됩 니 다.
 추상 류 의 의미:
 1. 하위 클래스 에 공공 유형 인 위로 스타일 링 을 제공 합 니 다.
 2. 패키지 하위 클래스 의 중복 내용 (구성원 변수 와 방법);
 3. 정 의 는 추상 적 인 방법 이 있 고 자 류 는 서로 다른 실현 이 있 지만 이 방법의 정 의 는 일치 하 다.