Java 继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为
比如现实生活中，兔子和羊属于食草动物类，狮子和豹属于食肉动物类。食草动物和食肉动物又是属于动物类。
所以继承需要符合的关系是：is-a，父类更通用，子类更具体。

格式

通过 extends 关键字申明一个类是从另外一个类继承而来的

/*格式
class 父类 {
}
class 子类 extends 父类 {
}
*/
//共性
class Person {
    String name;
    int age;
}

class Student extends Person {
    void study() {
        System.out.println("good study");
    }
}

class Worker extends Person {
    void work() {
        System.out.println("good work");
    }
}

class ExtendsDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "zhagnsan";
        s.study();
    }
}

运行结果：
good study

特性

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法（重写(覆盖)）。
• Java 的继承是单继承，但是可以多重继承。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

super 与 this

super关键字：可以通过super来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：代表的是本类对象的引用。

class Animal {
    void eat() {
        System.out.println("animal : eat");
    }
}

class Dog extends Animal {
    void eat() {
        System.out.println("dog : eat");
    }
    void eatTest() {
        this.eat();   // this 调用自己的方法
        super.eat();  // super 调用父类方法
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Dog d = new Dog();
        d.eatTest();
    }
}

运行结果：
animal : eat
dog : eat
animal : eat

重写（覆盖）

子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样。

作用

当子类继承父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，
这时，没有必要定义新功能，而是使用覆盖，保留父类的功能定义，并重写功能内容。

细节

• 子父类方法要一模一样。
• 子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

class Fu {
    void speak() {
        System.out.println("vb");
    }
}

class Zi extends Fu {
    void speak() {
        System.out.println("java");
    }
}

class ExtendsDemo3 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.speak();
    }
}

运行结果：
java

子父类中的构造函数

在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句 super( );
super( ):会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super( );

• 当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。

class Fu //extends Object
{
    int num;
    Fu() {
        //super();
        num = 60;
        System.out.println("fu run");
    }
    Fu(int x) {
        System.out.println("fu ...." + x);
    }

}

class Zi extends Fu {
    Zi() {
        //super();
        System.out.println("zi run");
    }
    Zi(int x) {
        //super();
        this();//可手动指定this语句来访问本类中的构造函数       
        //super(3);手动通过super语句形式来指定要访问父类中的构造函数
        System.out.println("zi..." + x);
    }
}

class ExtendsDemo4 {
    public static void main(String[] args) {
        Zi z = new Zi(0);
        System.out.println(z.num);
    }
}

运行结果：
fu run
zi run
zi...0
60

接口（interface）

格式特点

1. 接口中常见定义：常量，抽象方法。
2. 接口中的成员都有固定修饰符。
   常量：public static final
   方法：public abstract
3. 接口中的成员都是public的。

注意事项

• 接口是不可以创建对象的，因为有抽象方法。
• 子类实现接口时，需对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
• 接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现(implements)。

interface Inter {
    public static final int NUM = 3;

    public abstract void inter();
}

interface InterA {
    public abstract void interA();
}

class Demo {
    public void function() {
    }
}

class Test extends Demo implements Inter, InterA {
    public void inter() {
    }

    public void interA() {
    }
}