继承、抽象、接口、多态、封装

画了一个简易的关系图（个人总结）。

通过这个关系图，可以得到以下信息：
继承（extends/implements）：

• 类，单一继承，classs A extends class B，class B extends (abstract)
  class Z
• 接口，多重继承，interface 3 extends interface 1 interface 2
• 类（除了抽象类）必须实现接口中的方法 class B implements interface3 ……

抽象（abstract）：

• 抽象类是显式抽象，接口是隐式抽象；
• 抽象的不能被实例化（new）,方法为抽象方法

抽象类与接口：

• 抽象类包含成员变量、构造函数、抽象方法（只定义方法）、具体方法
• 接口只包含抽象方法
• 抽象类可以实现接口中的方法，转变为具体方法。
• 子类继承抽象类，必须实现抽象类中所有的抽象方法（包括抽象类继承而未实现的方法）
• 子类可以重写父类的具体方法，或者调用父类的方法。

//接口interfaceA包含两个抽象方法
public interface interfaceA {
    public String Interfacemethod1();   
    public String Interfacemethod2(); 
}

//抽象类ParentClass,继承接口interfaceA
public abstract class ParentClass implements interfaceA {
    private String name; //成员变量
    public ParentClass(){  //无参构造函数
    }
    public ParentClass(String name){  //有参构造函数
        this.setName(name);
    }
    public int Parentmethond1() {  //具体方法
        return 0;
    }
    public abstract int Parentmethod2(); //抽象方法
    public String Interfacemethod1() { //实现interfaceA中的Interfacemethod1
        return "hello world";
    }
     //封装
    public String getName() {
        return name;

    public void setName(String name) {
        this.name = name;
    }
}

public class ChildClass extends ParentClass {
    @Override //实现父类中继承interfaceA中的抽象方法
    public String Interfacemethod2() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override  //实现父类的抽象方法
    public int Parentmethod2() {
        // TODO Auto-generated method stub
        return 0;
    }

    //重写父类的方法
    public int methond1() {  
        int a=super.Parentmethond1()+1;
        return a; 
    }

    public String test() {
        return super.Interfacemethod1(); //调用父类的方法
    }
}

ChildClass A=new ChildClass();
A.getName(); //父类方法
A.Interfacemethod1(); //父类方法
A.Interfacemethod2();//子类（自己）方法
A.Parentmethod2();//子类（自己）方法
A.Parentmethond1();//父类方法
A.methond1();//子类（自己）方法
A.test();//子类（自己）方法

多态：

• 一般：class A a=new class A(); class B b=new class B();
• 多态：cllass A c=new class B();
• （c 是一个 B，c 也是一个A） c.method1调用的是B中的方法，需调用A中的方法，需super等指定

封装：
函数调用class A/B中的成员变量，需要通过方法获取

public class A{

   private String name;

   public String getName(){
      return name;
   }

   public void setName(String newName){
      name = newName;
   }
}

A a = new A();
a.setName("Jack");
a.getName();