대상 지향 인터페이스

인터페이스 (인터페이스)
정의: 인 터 페 이 스 는 특수 한 추상 류 이다.자바 의 인 터 페 이 스 는 일련의 방법의 성명 으로 일부 방법 특징의 집합 이다. 하나의 인 터 페 이 스 는 방법의 특징 만 있 고 방법 이 없 기 때문에 이런 방법 들 은 서로 다른 곳 에서 서로 다른 유형 으로 실 현 될 수 있 고 이런 실현 은 서로 다른 행위 (기능) 를 가 질 수 있다.
역할: 자바 는 단일 계승 만 지원 합 니 다. 다 중 계승 을 실현 하려 면 인 터 페 이 스 를 사용 하 십시오.

    ：1）                    ，       animal，      eat，          ，        ，               ，            ，                     eat。

2）           ，        ，       ，       ，        。             ，              ，           ，             ，              。

  ，         ：           ，     （   ），        ，     

    ：

            ，                     。                 ，            ，                  。

  ：

  A     public void print1(){}; public void print(){};

  B     public void print2(){}; public void print(){};

    C   A B

      A   C   

A a = new C();

      C    ，        

a.print();

a.print1();

B b = new C();

b.print();

b.print2(); 

          ，  3          ，           。                         ，            。                 ，        ，         。

주의:
1、         인터페이스의 위치 (등급 구조) 는 class 와 같 고 인터페이스의 모든 방법 은 추상 적 인 방법 이 며 방법 은 모두 Public 이다.Public interface MyInterface{  }，
2、         인터페이스 방법 을 설명 할 때 abstract 키 워드 를 사용 할 수도 있 고 abstract 키 워드 를 생략 할 수도 있 습 니 다.
Eg：Public （abstract） void  output（）；
3、         인 터 페 이 스 는 특수 한 추상 류 로 볼 수 있다. 이런 추상 류 에는 상수 와 추상 적 인 방법의 정의 만 포함 되 고 변수 와 방법의 실현 이 없다.
Eg：public interface  Runner{
public  static final int id=10;
public void start();
public void run();
public void stop();
}
4、         클래스 는 인 터 페 이 스 를 실현 할 수 있 고 키워드 implements 를 사용 할 수 있 으 며 특정한 클래스 가 특정한 인 터 페 이 스 를 실현 한 것 을 대표 합 니 다.
5、         만약 에 특정한 유형 이 하나의 인 터 페 이 스 를 실현 하고 이런 유형 이 추상 류 가 아니라면 이런 유형 은 반드시 이 인터페이스 에 있 는 모든 방법 (인터페이스 에 있 는 것 은 추상 적 인 방법) 을 실현 해 야 한다. 만약 에 이런 유형 이 추상 류 라면 인터페이스 에 있 는 방법 을 실현 할 필요 가 없다.
6、         자바 는 단일 계승 입 니 다. 즉, 하나의 클래스 는 하나의 부모 클래스 만 있 을 수 있 습 니 다. 그러나 하나의 클래스 는 여러 개의 인 터 페 이 스 를 실현 할 수 있 습 니 다. 여러 인터페이스 간 에 쉼표 로 구 분 됩 니 다.
Eg ：Class A implementsB1，B2{ }
7、         한 종 류 는 하나의 종 류 를 동시에 계승 하고 여러 개의 인터페이스 (다 중 실현) 를 실현 할 수 있 으 며, 여러 개의 무관 한 종 류 는 같은 인 터 페 이 스 를 실현 할 수 있다. 인터페이스 와 실현 류 사이 에는 다 형 성 이 존재 한다.
Eg：Class A extends B implements C1，C2
8、         인터페이스 에서 설명 하 는 방법 은 모두 추상 적 인 방법 이 고 인터페이스 에서 의 방법 은 모두 Public 이다.
9、         인터페이스 에서 도 성명 속성 을 정의 할 수 있 지만 초기 화 해 야 합 니 다. 인터페이스의 속성 은 모두 Public, final, static 만 있 을 수 있 습 니 다. 상수 입 니 다.
class interface {
     public final static int=3；
}
10、    new 를 통 해 인터페이스 대상 의 인 스 턴 스 를 만 들 수 없습니다.
11、    인 터 페 이 스 는 다른 인 터 페 이 스 를 계승 하고 새로운 속성 과 추상 적 인 방법 을 추가 할 수 있다.
12、    클래스 와 클래스 사이, 인터페이스 와 인터페이스 사 이 는 서로 계승 할 수 있 지만 클래스 와 인터페이스 사 이 는 실현 할 수 밖 에 없다.
13、    인 터 페 이 스 는 다 중 계승 가능: 즉
interface A{
   public void printA();
}
interface B{
   public void printB();
}
interface C extends A,B{
   public void printC();
}
예 를 들 면:
 
public interface Singer
{
   public void sing (); / / 노래 하 는 방법, 노래 할 수 있 는 것 을 정의 합 니 다. 구체 적 으로 어떻게 부 르 는 지 모 르 겠 습 니 다. 사람 은 사람의 창 법, 동물 은 동물 의 창 법 이 있 습 니 다.
   public void sleeping();
}
 
class Student implements Singer{
/ / 인 터 페 이 스 를 실현 하려 면 그 중의 모든 방법 을 실현 해 야 합 니 다.
   public void sing()
   {
   }
 
   public void sleeping()
   {
   }
  
}
 
코드 설명:
public classimplementszzj {
 
      /**
       * 인터페이스의 정의: c + + 가 얼마나 계승 되 는 지, 자바 는 단지 계승 할 수 있 기 때문에 인 터 페 이 스 를 추가 하여 다 중 계승 인 터 페 이 스 를 실현 하 는 것 은 특수 한 추상 류, 즉 final 류 이다.
       * 이러한 추상 류 에는 상수, 즉 final 이 정의 하 는 정적 static 변수 와 방법 정의 만 포함 되 어 있다.
       * 즉, 정의 함수 만 있 고 그 안에 실 현 된 내용 을 쓰 지 않 고 추상 류 에서 상수 로 정의 하 는 장점 은 이 양 이 data segment 정적 문자 상수 저장 소 에 만 저장 할 수 있 기 때 문 입 니 다.
       * 변수 스 택 메모리 와 클래스 방법의 메모리 에 두 지 않 기 때문에 c + + 에서 다 중 계승 을 피 할 때 정 의 된 변수 이름 처럼 호출 이 어렵 습 니 다. data segment 장점,
       * 즉, 몇 개의 똑 같은 정의 명 이 든 그 안에 서 는 기본적으로 하나 입 니 다. 자, 다음 4 대 저장 영역 복습: hep 정의 new 방법의 자료 저장 소 stack 부분 변수
       * 주 함수 변수 저장 소 data segment 정적 변수 문자 상수 저장 소 code segment 코드 저장
       *
       *@param args
       */
      public static void main(String[] args) {
           // TODO Auto-generated method stub
 
           s1 ss1 = new set 1 ("set 1 의 이름");
            ss1.ss1();
           ss1. ss2 (); / / 주의, 인터페이스 류 는 자신의 인터페이스 방법 만 호출 할 수 있 습 니 다.
           s2 ss2 = new set2(12);
           ss2.sss1();
           ss2.sss2();
           // //
           // set 는 set 1 과 set 2 를 포함 하기 때문에 s1 은 s1 에 만 접근 할 수 있 고 s2 는 s2 에 만 접근 할 수 있 습 니 다.
           // 모든 인터페이스 가 자신 에 게 대응 하 는 방법 을 표시 합 니 다. 그래서 어떤 인터페이스 로 set 3 에 있 는 지 이 인터페이스 방법 을 사용 합 니 다.
           // s1 ss3=new set3();
           s2 ss3 = new set3();
           ss3.sss1();
      }
 
}
 
/ / s1 인터페이스 및 방법 정의
interface s1 {
      public void ss1();
      public void ss2();
}
 
/ / 인터페이스의 실현 과정 을 정 의 했 습 니 다. 인 터 페 이 스 를 정의 하려 면 반드시 실현 과정 에 대응 해 야 합 니 다.
class set1implements s1 {
      private String name;
 
      set1(final String name) {
           this.name = name;
           System. out. println ("구조 방법 을 정의 하여 이름 을 전달 합 니 다");
      }
 
      public void sett1() {
           System. out. println ("이것 은 스스로 정의 하 는 방법 입 니 다");
      }
      public void ss1() {
           //TODO Auto-generated method stub                    
           System. out. println ("이것 은 인터페이스 ss1 의 실현 과정 입 니 다");
      }
      public void ss2() {
           // TODO Auto-generated method stub
           System. out. println ("이것 은 인터페이스 ss2 의 실현 과정 입 니 다");
      }
}
 
/ / s2 인터페이스 및 방법 정의
interface s2 {
      public void sss1();
      public void sss2();
}
 
/ / 인터페이스의 실현 과정 을 정 의 했 습 니 다. 인 터 페 이 스 를 정의 하려 면 반드시 실현 과정 에 대응 해 야 합 니 다.
class set2implements s2 {
      private int age;
      set2(final int age) {
           this.age = age;
           System. out. println ("구조 방법 을 정의 하여 나 이 를 전달 합 니 다");
      }
      public void sss1() {
           // TODO Auto-generated method stub
           System. out. println ("이것 은 인터페이스 sss 1 의 실현 과정 입 니 다");
      }
 
      public void sss2() {
           // TODO Auto-generated method stub
           System. out. println ("이것 은 인터페이스 sss 2 의 실현 과정 입 니 다");
      }
}
/ / 여러 인터페이스의 실현 과정 을 정 의 했 습 니 다. 인 터 페 이 스 를 정의 하려 면 실현 과정 에 대응 해 야 합 니 다.
class set3  implements s1, s2 {
 
      public void ss1() {
           // TODO Auto-generated method stub
           System. out. println ("이것 은 인터페이스 ss1 의 실현 과정 입 니 다");
      }
      public void ss2() {
           // TODO Auto-generated method stub
           System. out. println ("이것 은 인터페이스 ss2 의 실현 과정 입 니 다");
      }
 
      public void sss1() {
           // TODO Auto-generated method stub
           System. out. println ("이것 은 인터페이스 sss 1 의 실현 과정 입 니 다");
      }
 
      public void sss2() {
           // TODO Auto-generated method stub
           System. out. println ("이것 은 인터페이스 sss 2 의 실현 과정 입 니 다");
      }
}
/ / 클래스 를 정의 하고 방법 을 정의 하여 실현 합 니 다.
class set4 {
      void sett() {
           System. out. println ("이것 은 set 4 의 방법 입 니 다");
      }
}
/ / 클래스 를 정의 하고 set 4 클래스 와 s1 s2 인 터 페 이 스 를 계승 합 니 다.
class set5 extendsset4 implements s1, s2 {
/ / 인 터 페 이 스 를 정의 하려 면 실현 과정 에 대응 해 야 합 니 다.
      public void ss1() {
           // TODO Auto-generated method stub
 
      }
 
      public void ss2() {
           // TODO Auto-generated method stub
 
      }
 
      public void sss1() {
           // TODO Auto-generated method stub
 
      }
 
      public void sss2() {
           // TODO Auto-generated method stub
 
      }
 
}
/ / 클래스 를 정의 하고 set 2 클래스 를 계승 합 니 다. 그 안에 자신 이 정의 한 구조 방법 이 있 기 때문에
/ / 계승 하려 면 반드시 자신의 구조 방법 을 다시 쓰 고 슈퍼 방법 을 통 해 부류 set 2 에 전달 해 야 한다.
class set6 extendsset2
{
      set6(int age) {
           super(age);
           // TODO Auto-generated constructorstub
      }
 
}
class set7 extendsset1
{
 
      set7(String name) {
           super(name);
           // TODO Auto-generated constructorstub
      }
}