이해하기 쉬운 언어로 또는 기사로 연결되는 링크로 설명하십시오.
답변
extends
수업 을 연장 하기 위한 것 입니다.
implements
인터페이스 를 구현 하기 위한 것입니다
인터페이스와 일반 클래스의 차이점은 인터페이스에서 선언 된 메소드를 구현할 수 없다는 것입니다. 인터페이스를 “구현”하는 클래스 만이 메소드를 구현할 수 있습니다. 인터페이스에 해당하는 C ++는 추상 클래스 (정확히 같지는 않지만 거의)입니다.
또한 java는 클래스에 대한 다중 상속 을 지원하지 않습니다 . 이것은 여러 인터페이스를 사용하여 해결됩니다.
public interface ExampleInterface {
public void doAction();
public String doThis(int number);
}
public class sub implements ExampleInterface {
public void doAction() {
//specify what must happen
}
public String doThis(int number) {
//specfiy what must happen
}
}
이제 수업을 연장하다
public class SuperClass {
public int getNb() {
//specify what must happen
return 1;
}
public int getNb2() {
//specify what must happen
return 2;
}
}
public class SubClass extends SuperClass {
//you can override the implementation
@Override
public int getNb2() {
return 3;
}
}
이 경우
Subclass s = new SubClass();
s.getNb(); //returns 1
s.getNb2(); //returns 3
SuperClass sup = new SuperClass();
sup.getNb(); //returns 1
sup.getNb2(); //returns 2
동적 바인딩, 다형성 및 일반적으로 객체 지향 프로그래밍의 상속에 대해 좀 더 연구 할 것을 제안합니다.
답변
프로필에 C ++ 질문이 있습니다. C ++에서 다중 상속 의 개념을 이해하면 (하나 이상의 다른 클래스에서 특성을 상속하는 클래스 참조) Java는이를 허용하지 않지만 interface
C ++의 순수한 가상 클래스와 같은 키워드를 가지고 있습니다 . 많은 사람들이 언급했듯이, 당신 extend
은 클래스 (그리고 당신은 하나에서 확장 할 수 있습니다)와 implement
인터페이스를 제공하지만 클래스는 원하는만큼 인터페이스를 구현할 수 있습니다.
즉, 이러한 키워드와 사용 규칙은 Java에서 다중 상속 가능성을 설명합니다 (수퍼 클래스는 하나만있을 수 있지만 여러 인터페이스를 구현할 수 있음).
답변
일반적으로 구현은 구현에 사용되는 인터페이스 및 연장 에 사용되는 확장 기본 클래스의 행동이나의 추상 클래스입니다.
extends : 파생 클래스는 기본 클래스를 확장 할 수 있습니다. 당신은 확립 된 관계의 행동을 재정의 할 수 있습니다. 파생 클래스 ” 는 “기본 클래스 유형입니다.
구현합니다 : 계약을 구현하고 있습니다. “”인터페이스를 구현하는 클래스 에는 “기능이 있습니다.
Java 8 릴리스를 사용하면 interface 자체에 구현을 제공하는 interface에 기본 메소드 가있을 수 있습니다 .
각각의 사용시기에 대해서는이 질문을 참조하십시오.
사물을 이해하는 예.
public class ExtendsAndImplementsDemo{
public static void main(String args[]){
Dog dog = new Dog("Tiger",16);
Cat cat = new Cat("July",20);
System.out.println("Dog:"+dog);
System.out.println("Cat:"+cat);
dog.remember();
dog.protectOwner();
Learn dl = dog;
dl.learn();
cat.remember();
cat.protectOwner();
Climb c = cat;
c.climb();
Man man = new Man("Ravindra",40);
System.out.println(man);
Climb cm = man;
cm.climb();
Think t = man;
t.think();
Learn l = man;
l.learn();
Apply a = man;
a.apply();
}
}
abstract class Animal{
String name;
int lifeExpentency;
public Animal(String name,int lifeExpentency ){
this.name = name;
this.lifeExpentency=lifeExpentency;
}
public void remember(){
System.out.println("Define your own remember");
}
public void protectOwner(){
System.out.println("Define your own protectOwner");
}
public String toString(){
return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;
}
}
class Dog extends Animal implements Learn{
public Dog(String name,int age){
super(name,age);
}
public void remember(){
System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");
}
public void protectOwner(){
System.out.println(this.getClass().getSimpleName()+ " will protect owner");
}
public void learn(){
System.out.println(this.getClass().getSimpleName()+ " can learn:");
}
}
class Cat extends Animal implements Climb {
public Cat(String name,int age){
super(name,age);
}
public void remember(){
System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");
}
public void protectOwner(){
System.out.println(this.getClass().getSimpleName()+ " won't protect owner");
}
public void climb(){
System.out.println(this.getClass().getSimpleName()+ " can climb");
}
}
interface Climb{
public void climb();
}
interface Think {
public void think();
}
interface Learn {
public void learn();
}
interface Apply{
public void apply();
}
class Man implements Think,Learn,Apply,Climb{
String name;
int age;
public Man(String name,int age){
this.name = name;
this.age = age;
}
public void think(){
System.out.println("I can think:"+this.getClass().getSimpleName());
}
public void learn(){
System.out.println("I can learn:"+this.getClass().getSimpleName());
}
public void apply(){
System.out.println("I can apply:"+this.getClass().getSimpleName());
}
public void climb(){
System.out.println("I can climb:"+this.getClass().getSimpleName());
}
public String toString(){
return "Man :"+name+":Age:"+age;
}
}
산출:
Dog:Dog:Tiger:16
Cat:Cat:July:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man
이해해야 할 중요한 사항 :
- 강아지 와 고양이는 동물 그리고 그들은 확장
remember
()와protectOwner
공유 ()name,lifeExpentency
에서Animal
- 고양이는 올라갈 수 있지만 개는 할 수 없습니다. 개는 생각할 수는 있지만 고양이는 그렇지 않습니다 . 이러한 특정 기능에 추가
Cat
하고Dog
그 기능을 구현하여. - 인간은 동물이 아니지만 그는 할 수 있습니다
Think,Learn,Apply,Climb
이 예제들을 살펴보면
관련없는 클래스는 인터페이스를 통해 기능을 가질 수 있지만 관련 클래스는 기본 클래스의 확장을 통해 동작을 대체합니다.
답변
extends
기본 클래스 에서 상속하는 경우 (예 : 기능 확장)입니다.
implements
인터페이스를 구현할 때 사용 됩니다 .
시작하기에 좋은 장소는 다음과 같습니다 : Interfaces and Inheritance .
답변
A는 class
단지 “를 구현”할 수 있습니다 interface
. 클래스는 “확장”만합니다 class
. 마찬가지로을 interface
다른 확장 할 수 있습니다 interface
.
A class
는 서로 만 확장 할 수 있습니다 class
. A는 class
여러 구현할 수 interface
들.
대신 abstract class
es와 interface
s 를 사용하는시기를 알고 싶은 경우이 스레드를 참조하십시오. 인터페이스 vs 추상 클래스 (일반 OO)
답변
인터페이스는 객체가 수행 할 수있는 동작에 대한 설명입니다. 예를 들어 전등 스위치를 뒤집거나 전등이 켜질 때 어떻게되는지 신경 쓰지 않아도됩니다. 객체 지향 프로그래밍에서 인터페이스는 객체가 “X”가되기 위해 가져야하는 모든 기능에 대한 설명입니다. 다시 한 번, 예를 들어 라이트처럼 “ACTS LIKE”는 turn_on () 메소드와 turn_off () 메소드를 가져야합니다. 인터페이스의 목적은 컴퓨터가 이러한 속성을 적용하고 TYPE T (인터페이스가 무엇이든)의 개체에 X, Y, Z 등의 함수가 있어야한다는 것을 알 수 있도록하는 것입니다.
인터페이스는 컴퓨터가 객체 (클래스)에 특정 속성을 적용 할 수있는 프로그래밍 구조 / 구문입니다. 예를 들어 자동차 클래스와 스쿠터 클래스, 트럭 클래스가 있다고 가정 해 봅시다. 이 세 클래스 각각에는 start_engine () 액션이 있어야합니다. 각 차량에 대한 “엔진 시작”방법은 각 특정 클래스에 맡겨져 있지만 start_engine 조치가 있어야한다는 사실은 인터페이스 의 도메인입니다 .