1. 클래스 선언에서 확장 키워드를 사용하여 클래스의 하위 클래스를 만듭니다. 클래스는 키워드 Implements를 통해 하나 이상의 인터페이스를 사용한다고 선언합니다.
확장은 특정 클래스를 상속하는 것을 의미합니다. 상속 후 부모 클래스의 메서드를 사용하거나 부모 클래스의 메서드를 재정의할 수 있습니다. 구현은 일반적으로 여러 인터페이스 메서드가 비어 있으므로 다시 작성해야 한다는 의미입니다. 사용된.
2. 확장은 상위 클래스를 상속합니다. 클래스가 final로 선언되지 않거나 클래스가 abstract로 정의되어 있으면 상속이 가능합니다. JAVA는 다중 상속을 지원하지 않지만 이 경우 인터페이스를 사용하여 구현할 수 있습니다. 상속은 클래스만 상속할 수 있지만 구현은 여러 인터페이스를 구현할 수 있습니다. 예를 들어 쉼표로 구분하면 됩니다.
다음과 같이 코드 코드를 복사합니다 .
클래스 A는 B를 확장하고 C,D,E를 구현합니다.
오랫동안 공부한 끝에 오늘 드디어 구현을 이해하게 되었습니다. 다음 예제를 보시면 정말 간단합니다~~
인터페이스의 일부 개념
<!--[if !supportLineBreakNewLine]-->
다음과 같이 코드 코드를 복사합니다 .
공개 내면 러너
{
정수 ID = 1;
무효 실행();
}
인터페이스 Animal은 Runner를 확장합니다.
{
무효 호흡();
}
클래스 물고기 도구 동물
{
공개 무효 실행()
{
System.out.println("물고기가 헤엄치고 있습니다.");
}
공공 공허 호흡()
{
System.out.println("물고기가 부글부글 끓고 있습니다.");
}
}
추상 LandAnimal은 동물을 구현합니다.
{
공공 공허 호흡 ()
{
System.out.println("LandAnimal이 숨을 쉬고 있습니다.");
}
}
클래스 학생 확장 개인 실행자 구현
{
...
공개 무효 실행()
{
System.out.println("학생이 달리고 있습니다.");
}
...
}
인터페이스 전단지
{
무효 비행 ();
}
클래스 Bird는 Runner, Flyer를 구현합니다.
{
공개 무효 실행()
{
System.out.println("새가 뛰고 있습니다.");
}
공공 무효 비행()
{
System.out.println("새가 날고 있어요");
}
}
클래스 TestFish
{
공개 정적 무효 메인(문자열 인수[])
{
피쉬 f = new Fish();
정수 j = 0;
j = 러너.ID;
j = f.ID;
}
}
인터페이스 구현에 대한 참고 사항:
a. 인터페이스를 구현한다는 것은 인터페이스의 모든 메서드(추상 클래스 제외)를 구현하는 것입니다.
b. 인터페이스의 메소드는 추상적입니다.
c. 관련되지 않은 여러 클래스가 동일한 인터페이스를 구현할 수 있으며, 하나의 클래스가 관련되지 않은 여러 인터페이스를 구현할 수 있습니다.
================================================= =========
확장과 구현의 차이점
상속은 클래스가 final로 선언되지 않거나 클래스가 abstract로 정의되어 있으면 상속이 가능하지만, 이 경우에는 인터페이스를 이용하여 구현할 수 있다. 상속은 하나의 클래스만 상속할 수 있지만 구현은 여러 인터페이스를 구현할 수 있습니다. 예를 들어 쉼표로 구분하면 됩니다.
클래스 A는 B를 확장하고 C,D,E를 구현합니다.
클래스는 키워드 Implements를 통해 하나 이상의 인터페이스를 사용한다고 선언합니다. 클래스 선언에서 키워드 확장을 통해 클래스의 하위 클래스를 만듭니다.
다음과 같이 코드 코드를 복사합니다 .
클래스 하위 클래스 이름은 상위 클래스 이름을 확장하고 인터페이스 이름을 구현합니다.
{...
}
================================================= =========
A a = new B(); 결과적으로 a는 클래스 A의 인스턴스이며 A의 메서드에만 액세스할 수 있습니다. 그러면 A a = new A();의 차이점은 무엇입니까?
================================================= ========
클래스 B는 A를 확장합니다.
상속 후에는 일반적으로 상위 클래스에 없는 일부 멤버나 메서드가 정의됩니다.
A a = 새로운 B();
괜찮습니다. 업로드하세요.
a는 상위 클래스 객체의 인스턴스이므로 하위 클래스에서 정의한 새 멤버나 메서드에 액세스할 수 없습니다.
================================================= ========
다음과 같이 정의하면:
클래스 A{
나는 int;
무효 f(){}
}
클래스 B는 A를 확장합니다{
int j;
void f(){}//다시 작성
무효 g(){}
}
그 다음에:
Bb = 새로운 B();
b는 하위 클래스 객체의 인스턴스입니다. 자체 속성과 메서드뿐만 아니라 상위 클래스의 속성과 메서드에도 액세스할 수 있습니다. bi, bj, bf(), bg() 같은 것은 모두 합법적입니다. 이때 bf()는 B의 f()에 액세스됩니다.
A a = 새로운 B();
a는 B의 생성자를 사용하지만 업캐스트 후에는 상위 클래스 객체의 인스턴스가 되며 하위 클래스의 속성 및 메서드에 액세스할 수 없습니다. ai,af()는 합법적이지만 aj,ag()는 불법입니다. 이때 af()에 접근하는 것은 B의 f()에 접근하는 것과 같습니다.
================================================= ========
A a = new B(); 이 문에는 실제로 세 가지 프로세스가 있습니다.
(1) 가.
a를 상위 클래스 객체로 선언합니다. 이는 참조일 뿐이며 공간이 할당되지 않습니다.
(2) B 임시 = 새로운 B();
클래스 B 객체의 인스턴스는 클래스 B의 생성자를 통해 설정됩니다.
(3) a = (A)온도;
하위 클래스 개체 temp를 부모가 아닌 클래스 개체로 변환하고 이를 a에 할당합니다. 이는 안전한 업로드(업캐스트)입니다.
위의 세 가지 프로세스를 거친 후 a는 완전히 클래스 A의 인스턴스가 되었습니다.
하위 클래스에는 상위 클래스보다 더 많은 속성과 메서드가 있는 경우가 많습니다. 업로드하면 해당 항목이 삭제되므로 안전하지만, 다운캐스팅하면 일반적으로 안전하지 않습니다.
================================================= =========
af()는 클래스 B의 f() 메서드와 일치해야 합니다.
생성자를 호출하여 인스턴스를 생성한 후 해당 메서드에 대한 진입이 결정됩니다.
그 이후로 a는 클래스 A로 업로드되었지만 재정의된 메서드 f()는 여전히 B의 메서드 f()입니다. 즉, 각 객체는 어떤 메서드를 호출해야 하는지 알고 있습니다.
A a1 = 새로운 B();
A a2 = 새로운 C();
a1과 a2는 모두 클래스 A 객체이지만 각각의 f()는 다릅니다. 이것이 바로 1층에서 언급한 다형성의 구현이다.
이러한 문제는 "Java 프로그래밍 사고"에 매우 명확하게 설명되어 있습니다.
구현은 일반적으로 인터페이스를 구현합니다. 확장은 상속된 클래스입니다. 인터페이스에는 일반적으로 메소드 선언만 있고 정의가 없으므로 Java가 인터페이스 구현을 구체적으로 지적하는 것이 합리적입니다. 상속은 상위 클래스가 메소드를 구현한 반면 인터페이스는 자체 메소드를 구현하지 않고 선언만 구현한다는 의미이기 때문입니다. 메소드 헤더에는 메소드 본문이 없습니다. 따라서 인터페이스는 메서드를 상속하는 것이 아니라 메서드 선언을 구현하는 하위 클래스라는 것을 이해할 수 있습니다. 그러나 일반 클래스 메서드에는 메서드 본문이 있을 수 있으므로 상속이라고 부르는 것이 더 합리적입니다. 패키지를 가져오면 인터페이스가 아닌 구현된 모든 클래스를 사용할 수 있습니다. 그런 다음 인터페이스를 구현할지 여부를 결정합니다. 인터페이스를 구현하지 않으면 인터페이스를 호출할 수 없습니다. 인터페이스는 메서드 본문이 없는 메서드 선언의 모음이기 때문입니다. 예를 들어 보겠습니다. 인터페이스는 프로토콜과 비교할 수 있습니다. 예를 들어, 프로토콜이 "죽인다"고 말하면 마체테를 사용하여 이 인터페이스를 구현할 수 있습니다. 물론, Grab을 사용하여 킬링 인터페이스를 구현할 수도 있지만, 킬링 인터페이스는 단지 함수 설명일 뿐이고 이를 수행하는 방법은 구현 클래스에 따라 다르기 때문에 킬링 인터페이스를 사용할 수 없습니다. . 따라서 패키지에 인터페이스가 있으면 이를 구현할 필요가 없습니다. 이는 다른 클래스 사용에 영향을 주지 않습니다.
구현하다
Implements는 인터페이스를 구현하기 위해 클래스에서 사용하는 키워드입니다. 인터페이스에 정의된 추상 메서드를 구현하는 데 사용됩니다. 예를 들어 people은 인터페이스이고 say 메소드가 있습니다. public 인터페이스 people(){ public say();} 그러나 인터페이스에는 메소드 본문이 없습니다. 메소드 본문은 특정 클래스를 통해서만 구현될 수 있습니다. 예를 들어, 중국어 클래스는 people 인터페이스를 구현합니다. 공개 클래스 중국어는 people{ public say() {System.out.println("Hello!");}}를 구현합니다.
Java에서 구현은 하위 클래스가 상위 클래스를 상속한다는 의미입니다. 예를 들어, 클래스 A는 클래스 B를 상속하고 클래스 A가 B를 구현하는 것으로 작성됩니다.
확장과의 차이점
확장된 경우 상위 클래스를 구현하거나 상위 클래스를 호출하여 this.parent()를 초기화할 수 있습니다. 그리고 상위 클래스에서 정의한 변수나 함수를 덮어씁니다. 이것의 장점은 아키텍트가 인터페이스를 정의하고 엔지니어가 이를 구현하도록 할 수 있다는 것입니다. 전체 프로젝트 개발 효율성과 개발 비용이 크게 절감됩니다.
상위 클래스를 구현하고 구현하며 하위 클래스는 상위 클래스의 메서드나 변수를 재정의할 수 없습니다. 하위 클래스가 상위 클래스와 동일한 변수나 함수를 정의하더라도 상위 클래스로 대체됩니다.
이 두 가지 구현의 구체적인 사용은 프로젝트의 실제 상황에 따라 다르며 구현은 수정될 수 없습니다. 정의된 인터페이스만 구체적으로 구현되어야 하며 확장을 사용하여 수정할 수 있습니다.
<!--[endif]-->