Question

我对这个话题感到困惑，请帮忙。谢谢。 //一个类（比如说B）分别扩展或实现另一个类或接口

interface myInterfaceA{

int interfaceDataMember1;
int interfaceDataMember2;

void interfaceMethod1();
void interfaceMethod2();

}

class myClassA{

int parentClassDataMember1;
int parentClassDataMember2;

myclassA(){}

void parentClassMethod1(){}
void parentClassMethod2(){}

}

// case1

class B implements myInterfaceA{

int dataMember1;
int dataMember2;

B(){}

void method1(){}
void method2(){}
}

// OR case2

class B extends myClassA{

int dataMember1;
int dataMember2;

B(){}

void method1(){}
void method2(){}
}

//所以在任何一种情况下，以下列方式创建B类对象的目的是什么

myInterfaceA objectB = new B();
// or 
myClassA objectB = new B();

1）这个程序有没有名字？ 2）什么（数据memeber，方法，构造函数）将被加载到objectB中？ 3）如果B类的所有代码都将被加载到objectB中那么为什么我们给出了接口或父类的refrece？ 4）这表明多态性？如果是的话，为什么呢？ 5）在case2中，类B也会继承myClassA的构造函数 6）为什么在创建子类对象

时也会调用父类的构造函数

Answer 1

1）这个程序有没有名字？

这是多态性。

2）将加载什么（数据memeber，方法，构造函数）对象B？

每个数据成员和方法都将由objectB继承。

如果是接口，则数据成员为private，static，final常量。它们必须在构造函数中初始化。这些方法必须由B类实施。

对于超类，简单地继承数据成员和方法。您可以覆盖这些方法。变量不是多态的。

3）如果B类的所有代码都将加载到objectB中，那么为什么呢我们是否给出了接口或父类的refrece？

我们提供接口或父类的引用，以便在多个子类型的情况下，我们可以有一个接受超类型而不是创建多个方法的方法。这减少了代码行并使代码可读。

4）这是显示多态吗？如果是的话，为什么呢？

这显示了多态行为，因此您无需将每个子类型绑定到不同的方法。可以编写单个方法来动态绑定单个超类型的所有子类型。

5）在case2中，B类也继承了myClassA的构造函数

构造函数不是继承的。如果需要，您必须显式调用super（）。

6）为什么我们创建时也会调用父类的构造函数子类对象

每次都不必调用父类的构造函数。如果不需要，您可以跳过它。但作为标准实践，super()是子类构造函数的第一行，因此超类对象创建中的任何更改都不会影响子类。

Answer 2

接口（并实现它们）仅指示继承类必须具有哪种签名方法。唯一被复制的东西，即可用作方法，是自Java 8以来的默认方法

从类（或抽象类）扩展是一个完全不同的故事，尽管它也可以规定继承类要实现哪些方法签名。但是在这里，所有数据都不会被复制，而是可用于调用接口。

接口用于标准化行为（将狗和鸟视为宠物），抽象类来标准化行为并提供实施（让鹦鹉和鹦鹉飞翔）

package zoo;

import java.util.ArrayList;



interface Pet {
    void printName();
}



abstract class Bird implements Pet {
    public void fly() {
        System.out.println("I (" + getClass().getSimpleName() + ") am flying");
    }
}



class Dog implements Pet {
    @Override public void printName() {
        System.out.println("Hans");
    }
}



class Budgie extends Bird {
    @Override public void printName() {
        System.out.println("Jockl");
    }
}



class Cockatoo extends Bird {
    @Override public void printName() {
        System.out.println("Zenzi");
    }
}



public class AnimalSchool {
    public static void main(final String[] args) {
        final Dog d = new Dog();
        d.printName();

        final Budgie b = new Budgie();
        b.printName();
        b.fly();

        final Cockatoo c = new Cockatoo();
        c.printName();
        c.fly();

        final ArrayList<Pet> pets = new ArrayList<>();
        pets.add(d);
        pets.add(b);
        pets.add(c);
        for (final Pet pet : pets) {
            System.out.print("\nPet is a " + pet.getClass().getSimpleName() + " and is called ");
            pet.printName();
        }

        final ArrayList<Bird> byrdies = new ArrayList<>();
        //      byrdies.add(d); this will not compile, as it is not a bird
        byrdies.add(b);
        byrdies.add(c);
        for (final Pet pet : byrdies) {
            System.out.print("\nBird is a " + pet.getClass().getSimpleName() + " and is called ");
            pet.printName();
        }

    }
}

Answer 3

回答你的问题。

它被称为多态性
在使用案例1的对象B中，B将被强制实现myInterfaceA方法，你的B类也不能有未实现的方法，除非你将类声明为abstract：
```
class B implements myInterfaceA{

  int dataMember1;
  int dataMember2;

  B(){}

  public void method1(){
  }
  public void method2(){
  }

  //interface methods
  public void interfaceMethod1(){
  }
  public void interfaceMethod2(){
  }
 }
```
因此，类b将具有接口的属性及其自身的属性以及它已实现的方法。然而，使用情况2B将如此实现。（假设a不是抽象类，因此它的实现方法不会像接口方法或抽象类方法那样声明）
```
class B extends myClassA{

  int dataMember1;
  int dataMember2;

  B(){
    super();
  }

  public void method1(){
  }
  public void method2(){
  }
 }
```
注意可以对超类构造函数进行显式调用
我们提供了对接口/父类的引用，因为我们想要一个实现超级类型的实现，并且实现用于有许多子类型的情况
是的，它是多态的，因此我们可以拥有超类型的不同行为和实现。
正如我前面所说，将对超类构造函数进行显式调用
标准做法是调用超类构造函数，以便对其进行更改不会影响子类

使用diffrenet refrence创建对象

3 个答案: