ym - 추상 과 인터페이스 (공장, 어댑터, 대리 모델 응용 포함) (새)

전재 본 고 는 Cym 의 블 로그 (http://blog.csdn.net/cym492224103) 응원 해 주 셔 서 감사합니다!추상 류 와 인터페이스 추상 류

abstract class A{      //          
       publicstatic final String FLAG = "CHINA" ;  //    
       privateString name = "Cym" ;    //          
       publicvoid setName(String name){
              this.name = name ;
       }
       publicString getName(){
              return this.name ;
       }
       publicabstract void print() ;           //       
};

는 추상 적 인 방법 을 포함 하 는 유형 을 추상 류 라 고 한다. 추상 적 인 방법 은 성명 만 하고 실현 되 지 않 는 방법 이다. 모든 추상 적 인 방법 은 반드시 abstract 키워드 성명 을 사용 해 야 하고 모든 추상 류 도 abstract 키워드 성명 이 필요 하 다.

abstract class A{      //          
       publicstatic final String FLAG = "CHINA" ;  //    
       privateString name = "Cym" ;       //          
       publicvoid setName(String name){
              this.name = name ;
       }
       publicString getName(){
              return this.name ;
       }
       publicabstract void print() ;           //       
};
class B extends A{  //      ，  B    ，            
       publicvoid print(){
              System.out.println("FLAG = " +FLAG) ;
              System.out.println("   = " + super.getName()) ;
       }
};

추상 류 에 대해 직접적 으로 실례 화 된 조작 을 할 수 없 지만 추상 류 를 사용 하려 면 반드시 자 류 에 의존 해 야 한다. 추상 류 는 반드시 자 류 에 의 해 계승 되 어야 하고 계승 되 는 자 류 는 추상 중의 모든 추상 적 인 방법 을 실현 해 야 한다.문제: 추상 류 는 final 키워드 로 수식 할 수 있 습 니까?추상 류 는 반드시 이불 류 에 의 해 계승 되 어야 한다.final 에 의 해 수 식 된 클래스 는 계승 할 수 없습니다.그래서 추상 류 는 final 관건 적 인 수식 을 사용 할 수 없다 는 결론 을 내 렸 다.추상 류 는 구조 방법 이 존재 할 수 있 습 니까?

abstract classA{      //          
              public A(){
                     System.out.println("A、         。") ;
              }
};
class B extendsA{  //      ，  B    ，            
              public B(){
                     super();
                     System.out.println("B、        。") ;
              }
};
public classAbstractDemo03{
              public static void main(String args[]){
                     Bb = new B() ;
              }
};

추상 류 에서 구조 방법 이 허용 되 지만 이 구조 방법 은 직접 호출 할 수 없고 하위 클래스 에 호출 된 것 이다. 하위 클래스 대상 의 실례 화 과정 에서 부모 클래스 의 구조 방법 을 영원히 먼저 호출 한다.추상 류 는 일반 류 보다 추상 적 인 방법 이 하나 더 많 을 뿐이다.추상 류 속성 은 어떻게 초기 화 합 니까?

abstract class Person{
       privateString name ;              //   name  
       privateint age ;                     //   age  
       publicPerson(String name,int age){
              this.name = name ;
              this.age = age ;
       }
       publicvoid setName(String name){
              this.name = name ;
       }
       publicvoid setAge(int age){
              this.age = age ;
       }
       publicString getName(){
              return this.name ;
       }
       publicint getAge(){
              return this.age ;
       }
       publicabstract String getInfo() ;      //     
};

슈퍼

class Student extends Person{
       privateString school ;
       publicStudent(String name,int age,String school){
              super(name,age) ;     //                    
              this.school = school ;
       }
       publicvoid setSchool(String school){
              this.school = school ;
       }
       publicString getSchool(){
              return this.school ;
       }
       publicString getInfo(){
              return      "  ：" + super.getName()  +
                            "；  ：" + super.getAge() +
                            "；  ：" + this.getSchool() ;
       }
};
public class AbstractDemo04{
       publicstatic void main(String args[]){
              Student stu = new Student("  ",30,"    ") ;
              System.out.println(stu.getInfo()) ;
       }
};

추상 류 의 속성 을 사용 하여 초기 화 하려 면 구조 방법 에 의존 해 야 한다.인터페이스 인 터 페 이 스 는 특수 한 종류 로 자바 에서 인 터 페 이 스 는 추상 적 인 방법 과 전체 상수 로 구성 된다.자바 에서 interface 를 사용 하여 인터페이스

interface A{            //     A
       publicstatic final String AUTHOR = "CYM" ;      //    
       publicabstract void print() ;    //     
       publicabstract String getInfo() ;      //     
}

를 정의 합 니 다. 이 인터페이스 에서 두 가지 추상 적 인 방법 을 정의 합 니 다. 하나의 전체 상수, 그러면 인 터 페 이 스 는 추상 류 와 마찬가지 로 하위 클래스 가 필요 합 니 다. 그러면 하위 클래스 는 상속 류 가 아니 라 실현 류 라 고 부 르 고 implements 키 워드 를 통 해 이 루어 집 니 다.인터페이스의 방법 과 속성 은 영원히 pubic 수정자 입 니 다. 기본적으로 방법 은 abstract 속성 입 니 다. static final 은 인터페이스 가 정의 에서 추상 적 인 방법 과 전체 상수 로 구성 되 어야 한 다 는 요 구 를 명 확 히 한 이상 인터페이스 가 정 의 될 때 조작 을 간소화 할 수 있다

interface A{            //     A
       StringAUTHOR = "Cym" ;   //     
       voidprint() ;    //     
       StringgetInfo() ;      //     
}

. 하 나 는 값 이 하나의 부 류 를 계승 할 수 있 지만 한 가지 유형 은 여러 개의 인 터 페 이 스 를 동시에 실현 할 수 있다.만약 에 하나의 유형 이 인 터 페 이 스 를 실현 하고 추상 류 를 계승 하려 면 반드시 하나의 형식 으로 완성 해 야 한다.Class 하위 클래스 extends 추상 류 implements 인터페이스 A, 인터페이스 B,... {}

interface A{            //     A
       publicString AUTHOR = "CYM" ;       //    
       publicvoid print() ; //     
       publicString getInfo() ;   //     
}
abstract class B{      //      B
       publicabstract void say() ;      //       
}
class X extends B implements A{   // X    B ，   A  
       publicvoid say(){
              System.out.println("HelloWorld!!!") ;
       }
       publicString getInfo(){
              return "HELLO" ;
       }
       publicvoid print(){
              System.out.println("  ：" + AUTHOR) ;
       }
};
public class InterfaceDemo04{
       publicstatic void main(String args[]){
              X x = new X() ;      //        
              x.say() ;
              x.print() ;
       }
};

인터페이스 안의 방법 은 abstract 키 워드 를 쓰 지 않 고 간략하게 쓸 수 있 지만 추상 류 에 서 는 abstract 키 워드 를 반드시 고 쳐 야 합 니 다.

interface A{            //     A
       publicString AUTHOR = "CYM" ;       //    
       publicvoid print() ; //     
       publicString getInfo() ;   //     
}
abstract class B implements A{       //      B，    A
       publicabstract void say() ;      //       
}
class X extends B{  // X    B 
       publicvoid say(){
              System.out.println("HelloWorld!!!") ;
       }
       publicString getInfo(){
              return "HELLO" ;
       }
       publicvoid print(){
              System.out.println("  ：" + AUTHOR) ;
       }
};
public class InterfaceDemo05{
       publicstatic void main(String args[]){
              X x = new X() ;      //        
              x.say() ;
              x.print() ;
       }
};

하나의 추상 류 는 여러 개의 인 터 페 이 스 를 실현 할 수 있 지만 하나의 인 터 페 이 스 는 하나의 추상 류 를 계승 할 수 없다.

interface A{            //     A
       publicString AUTHOR = "CYM" ;       //    
       publicvoid printA() ;      //     
}
interface B{
       publicvoid printB() ;
}
interface C extends A,B{
       publicvoid printC() ;
}
class X implements C{    // X    B 
       publicvoid printA(){
              System.out.println("A、Hello World!!!") ;
       }
       publicvoid printB(){
              System.out.println("B、Hello MLDN") ;
       }
       publicvoid printC(){
              System.out.println("C、Hello LXH") ;
       }
};
public class InterfaceDemo06{
       publicstatic void main(String args[]){
              X x = new X() ;      //        
              x.printA() ;
              x.printB() ;
              x.printC() ;
       }
};

하나의 인 터 페 이 스 는 추상 적 인 종 류 를 계승 할 수 없 지만 하나의 인 터 페 이 스 는 여러 개의 인 터 페 이 스 를 동시에 계승 할 수 있다.대상 다 형 인터페이스 와 추상 류 의 기본 개념 이 완성 되 었 습 니 다. 아래 에서 가장 중요 한 것 은 대상 의 다 형 성 입 니 다. 전체 자바 에서 가장 중요 한 부분 입 니 다. 다 형 적 존재 가 있 기 때문에 프로그램 을 더욱 유연 하 게 만 들 수 있 습 니 다.다 형 성 은 대상 을 대상 으로 하 는 마지막 특징 이다. 방법의 과부하 와 방법의 복 사 는 실제 적 으로 다 형 행 의 표현 에 속한다.진정한 다 태 성 에는 대상 다 태 성 개념 도 포함 되 어 있다.대상 다 태 성 은 주로 자 류 와 부계 대상 의 상호 전환 관 계 를 가리킨다.위로 전환: 부모 클래스 부모 클래스 대상 = 하위 클래스 인 스 턴 스  --》자동 완성 아래로 전환: 하위 클래스 대상 = (하위 클래스) 부모 클래스 인 스 턴 스 - 강제 완성

class A{
       publicvoid fun1(){
              System.out.println("1、A  --> public void fun1(){}") ;
       }
       publicvoid fun2(){
              this.fun1() ;
       }
};
class B extends A{
       publicvoid fun1(){  //       
              System.out.println("2、B  --> public void fun1(){}") ;
       }
       publicvoid fun3(){  //            ，      
              System.out.println("3、B  --> public void fun3(){}") ;
       }
};
public class PolDemo01{
       publicstatic void main(String args[]){
              A a = new B() ;       //         ，     -->     
              a.fun2() ;
       }
};

부모 클래스 대상 = 하위 클래스 인 스 턴 스 (위로 전환) 는 부모 클래스 에 있 는 방법 만 사용 할 수 있 습 니 다.(하위 클래스 가 덮어 쓰 면 하위 클래스 덮어 쓰 는 방법 사용)

class A{
       publicvoid fun1(){
              System.out.println("1、A  --> public void fun1(){}") ;
       }
       publicvoid fun2(){
              this.fun1() ;
       }
};
class B extends A{
       publicvoid fun1(){  //       
              System.out.println("2、B  --> public void fun1(){}") ;
       }
       publicvoid fun3(){  //            ，      
              System.out.println("3、B  --> public void fun3(){}") ;
       }
};
public class PolDemo02{
       publicstatic void main(String args[]){
              A a = new B() ;       //         ，     -->     
              B b = (B)a ;    //         ，  
              b.fun3() ;
              b.fun2() ;
       }
};

부모 클래스 대상 = 하위 클래스 실례 클래스 대상 = (하위 클래스) 부모 클래스 대상 (아래로 전환)

class A{
       publicvoid fun1(){
              System.out.println("1、A  --> public void fun1(){}") ;
       }
       publicvoid fun2(){
              this.fun1() ;
       }
};
class B extends A{
       publicvoid fun1(){  //       
              System.out.println("2、B  --> public void fun1(){}") ;
       }
       publicvoid fun3(){  //            ，      
              System.out.println("3、B  --> public void fun3(){}") ;
       }
};
public class PolDemo03{
       publicstatic void main(String args[]){
              A a = new A() ;
              B b = (B)a ;
              b.fun2() ;
       }
};

은 ClassCastException 을 발생 시 켜 전환 이상 을 나타 내 는데 근본 적 인 원인 은 관계 가 없 는 두 클래스 가 서로 대상 조작 을 하 는 것 이다.관찰 대상 의 다 형 적 역할: 만약 에 지금 방법 을 설계 하려 면 이 방법 은 A 류 의 모든 하위 클래스 의 인 스 턴 스 를 받 아들 일 수 있 습 니 다.현재 대상 의 다 형 적 개념 을 사용 하지 않 고 완성

class A{
       public void fun1(){
              System.out.println("1、A  -->public void fun1(){}") ;
       }
       public void fun2(){
              this.fun1() ;
       }
};
class B extends A{
       public void fun1(){  //       
              System.out.println("2、B  -->public void fun1(){}") ;
       }
       public void fun3(){  //            ，      
              System.out.println("3、B  -->public void fun3(){}") ;
       }
};
class C extends A{
       public void fun1(){  //       
              System.out.println("4、C  -->public void fun1(){}") ;
       }
       public void fun4(){  //            ，      
              System.out.println("5、C  -->public void fun4(){}") ;
       }
};
public class PolDemo04{
       public static voidmain(String args[]){
              fun(new B()) ;
              fun(new C()) ;
       }
       public static void fun(Bb){
              b.fun2() ;
              b.fun3() ;
       }
       public static void fun(Cc){
              c.fun2() ;
              c.fun4() ;
       }
};

이상 의 방식 이 리 로드 를 통 해 이 루어 진다 면 이상 의 방법 으로 완성 하 는 것 은 이상 의 단점 이 있 을 수 있 으 며, 현재 A 류 의 하위 클래스 가 N 개 라면 방법 은 N 회 리 로드 해 야 하 며, 하위 클래스 를 추가 할 때마다 코드 자 체 를 수정 해 야 한다.따라서 이때 대상 의 다 형 성 을 사용 하면 이런 문 제 를 잘 해결 할 수 있다. 왜냐하면 모든 대상 이 자동 적 으로 위로 전환 하 는 작업 이 발생 하기 때문이다.

class A{
       public void fun1(){
              System.out.println("1、A  -->public void fun1(){}") ;
       }
       public void fun2(){
              this.fun1() ;
       }
};
class B extends A{
       public void fun1(){  //       
              System.out.println("2、B  -->public void fun1(){}") ;
       }
       public void fun3(){  //            ，      
              System.out.println("3、B  -->public void fun3(){}") ;
       }
};
class C extends A{
       public void fun1(){  //       
              System.out.println("4、C  -->public void fun1(){}") ;
       }
       public void fun4(){  //            ，      
              System.out.println("5、C  -->public void fun4(){}") ;
       }
};
public class PolDemo05{
       public static voidmain(String args[]){
              fun(new B()) ;
              fun(new C()) ;
       }
       public static void fun(Aa){
              a.fun2() ;
       }
};

class A{
       public void fun1(){
              System.out.println("1、A  -->public void fun1(){}") ;
       }
       public void fun2(){
              this.fun1() ;
       }
};
class B extends A{
       public void fun1(){  //       
              System.out.println("2、B  -->public void fun1(){}") ;
       }
       public void fun3(){  //            ，      
              System.out.println("3、B  -->public void fun3(){}") ;
       }
};
class C extends A{
       public void fun1(){  //       
              System.out.println("4、C  -->public void fun1(){}") ;
       }
       public void fun4(){  //            ，      
              System.out.println("5、C  -->public void fun4(){}") ;
       }
};
public class PolDemo08{
       public static voidmain(String args[]){
              fun(new B()) ;
              fun(new C()) ;
       }
       public static void fun(Aa){
              a.fun2() ;
              if(a instanceof B){
                     B b = (B)a ;
                     b.fun3() ;
              }
              if(a instanceof C){
                     C c = (C)a ;
                     c.fun4() ;
              }
       }
};

하위 클래스 자체 의 방법 을 사용 하려 면 대상 이 아래로 전환 하 는 작업 이 정확 하도록 조작 하기 전에 instanceof 키 워드 를 추가 하여 판단 하 는 것 이 좋 습 니 다.계승 관계 에서 부류 의 디자인 은 매우 중요 하 다. 부류 의 디자인 이 합 리 적 이면 코드 개발 이 매우 간편 하 다.추상 류 의 응용 은 대상 의 다 형 적 개념 을 보면 자 류 는 아버지 류 의 사례 화 는 비교적 쉬 운 조작 으로 자동 적 으로 위로 전환 하 는 관 계 를 발생 시 킬 수 있다 고 생각한다. 그러면 호출 하 는 방법 은 영원히 이불 류 가 복 사 된 방법 이다.그렇다면 이 개념 을 이용 해 대상 의 다 형 성 을 통 해 추상 적 인 사례 화 를 할 수 있다.추상 류 는 방법 을 실현 할 수 있다. 여러 가지 방법 이 똑 같 고 똑 같이 실 현 될 때 우 리 는 추상 류 를 사용 할 수 있다.물론 복사 도 가능 합 니 다.추상 류 자체 의 가장 큰 용 도 는 바로 모델 디자인 에 있다.인터페이스의 응용 인터페이스 도 추상 류 처럼 다 태 성 을 통 해 대상 의 실례 화 조작 을 할 수 있다.추상 류 는 모드 작업 을 정의 하 는 데 사용 할 수 있 지만 인 터 페 이 스 는?인 터 페 이 스 는 사실상 하나의 표준 으로 존재 한다.인 터 페 이 스 를 실현 할 수 없 는 방법 이지 만 같은 방법 으로 조작 할 때 우 리 는 인 터 페 이 스 를 기준 으로 할 수 있다.인터페이스 와 추상 적 인 어댑터 디자인 모델 이 정상 적 인 상황 에서 다음 인터페이스의 하위 클래스 는 모든 추상 적 인 방법

interface Window{
       publicvoid open() ; //     
       publicvoid close() ; //     
       publicvoid icon() ;  //    
       publicvoid unicon() ;      //    
}
Class MyWindow implements Window｛
｝

을 실현 해 야 한다. MyWindow 클래스 는 이때 반드시 모든 추상 적 인 방법 을 덮어 써 야 한다. 그러나 지금 은 자신의 수요 에 따라 덮어 쓰 기 를 선택 하고 자 한다. 그러면 어떻게 실현 해 야 합 니까?하나의 유형 으로 먼저 인 터 페 이 스 를 실현 하 였 으 나 모든 방법 은 공 실현 에 속 한 후에 이런 것 을 계승 하 였 다.추상 류 를 사용 해 야 한다. 추상 류 도 직접 사용 할 수 없 기 때문이다.

interfaceWindow{
       public void open() ; //     
       public void close() ; //     
       public void icon() ;  //    
       public void unicon() ;      //    
}
abstract classWindowAdapter implements Window{
       public void open(){}
       public void close(){}
       public void icon(){}
       public void unicon(){}
};
class MyWindowextends WindowAdapter{
       public voidopen(){
              System.out.println("    ！");
       }
};
public classAdpaterDemo{
       public static void main(String args[]){
              Windowwin = new MyWindow() ;
              win.open();
       }
}

공장 설계 모델

interface Fruit{
       publicvoid eat() ;
}
class Apple implements Fruit{
       publicvoid eat(){
              System.out.println("   。。。") ;
       }
};
class Orange implements Fruit{
       publicvoid eat(){
              System.out.println("   。。。") ;
       }
};
Public class interDemo｛
Public staticvoid main（String args[]）{
Fruit f = new Apple();
F.eat();
}
｝

이상 의 프로그램 을 개발 하면 문제 가 있 습 니까?
주 방법 은 사실상 클 라 이언 트 라 고 강조 해 왔 다.클 라 이언 트 의 코드 는 간단 할 수록 좋다.

interface Fruit{
       publicvoid eat() ;
}
class Apple implements Fruit{
       publicvoid eat(){
              System.out.println("   。。。") ;
       }
};
class Orange implements Fruit{
       publicvoid eat(){
              System.out.println("   。。。") ;
       }
};
class Factory{  //    
       publicstatic Fruit getFruit(String className){
              Fruit f = null ;
              if("apple".equals(className)){
                     f= new Apple() ;
              }
              if("orange".equals(className)){
                     f= new Orange() ;
              }
              return f ;
       }
};
public class InterDemo{
       publicstatic void main(String args[]){
              Fruit f = Factory.getFruit(args[0]) ;
              if(f!=null){
                     f.eat();
              }
       }
}

모든 인터페이스의 실례 화 대상 은 공장 류 에서 얻 은 것 이다.그러면 클 라 이언 트 가 호출 할 때 들 어 오 는 이름 에 따라 서로 다른 기능 을 완성 합 니 다.
프 록 시 디자인 모드

interface Give{
       publicvoid giveMoney() ;
}
class RealGive implements Give{
       publicvoid giveMoney(){
              System.out.println("     。。。。。") ;
       }
};
class ProxyGive implements Give{  //     
       privateGive give = null ;
       publicProxyGive(Give give){
              this.give = give ;
       }
       publicvoid before(){
              System.out.println("  ：  、  、  、  、  、  ") ;
       }
       publicvoid giveMoney(){
              this.before() ;
              this.give.giveMoney() ;   //                
              this.after() ;
       }
       publicvoid after(){
              System.out.println("      ") ;
       }
};
public class ProxyDemo{
       publicstatic void main(String args[]){
              Give give = new ProxyGive(new RealGive());
              give.giveMoney() ;
       }
};

두 가지 유형 이 하나의 인 터 페 이 스 를 동시에 실현 할 때 한 가지 유형 은 다른 대리 가 있어 야 이 기능 을 실현 할 수 있다. 이것 을 대리 모델 이 라 고 한다.
추상 류 와 인터페이스의 차이
   NO   
비교 점
추상 류
인터페이스
1
결성
추상 적 방법, 일반 방법, 상수, 변수, 구조, 방법, 전역 변수
추상 적 방법, 전역 상수
2
정의.
Abstract
interface
3
하위 클래스
하위 클래스 는 extends 를 통 해 추상 클래스 를 계승 합 니 다.
하위 클래스 는 implements 를 통 해 인 터 페 이 스 를 실현 합 니 다.
4
제한 하 다.
하나의 자 류 는 하나의 추상 류 만 계승 할 수 있다.
하나의 하위 클래스 는 여러 개의 인 터 페 이 스 를 동시에 실현 할 수 있다.
5
관계.
하나의 추상 류 는 여러 개의 인 터 페 이 스 를 실현 할 수 있다.   하나의 추상 류 에는 여러 개의 인터페이스 가 포함 되 어 있다.
하나의 인 터 페 이 스 는 추상 적 인 종 류 를 계승 할 수 없다.   하나의 인 터 페 이 스 는 여러 개의 추상 류 를 포함 할 수 있다.
6
디자인 모드
모델 디자인
공장 모드, 대리 모드
7
실례 화
모두 대상 의 다 태 성, 하위 클래스 를 통 해 대상 실례 화 조작 을 한다
8
제한 을 실현 하 다
단일 상속 한계 가 존재 하 다.
단일 상속 한계 가 존재 하지 않 습 니 다.
9
특성
하나의 표준, 하나의 능력
 
 
 
 
 
추상 류 와 인터페이스 가 동시에 사용 할 수 있다 면 우선 인 터 페 이 스 는 인터페이스 가 단일 계승 의 한 계 를 피 할 수 있다 고 생각한다.
추상 클래스 포함 인터페이스

abstract class A{
       publicabstract void fun() ;
       interfaceB{     //     
              public void print() ;
       }
};
class X extends A{
       publicvoid fun(){
              System.out.println("****************");
       }
       classY implements B{
              public void print(){
                     System.out.println("===================");
              }
       };
};
public class TestDemo01{
       publicstatic void main(String args[]){
              A a = new X() ;
              a.fun() ;
              A.B b = new X().new Y() ;
              b.print() ;
       }
};

인터페이스 포함 추상 클래스

interface A{
       publicvoid fun() ;
       abstractclass B{      //      
              public abstract void print() ;
       }
};
class X implements A{
       publicvoid fun(){
              System.out.println("****************");
       }
       classY extends B{
              public void print(){
                     System.out.println("===================");
              }
       };
};
public class TestDemo02{
       publicstatic void main(String args[]){
              A a = new X() ;
              a.fun() ;
              A.B b = new X().new Y() ;
              b.print() ;
       }
};