Java学习8：继承

继承特点

1.提高代码复用性；
2.让类与类之间产生关系，有了这个关系，才有了多态的特性；
3.java只支持单继承，不支持多继承，因为多继承容易带来安全隐患，因为当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个；
4.java保留这种机制，用另一个体现形式来表示，即多实现；
5.java支持多层继承。

子父类出现后，类成员的特点

变量

如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量用this，访问父类中的同名变量用super，this代表本类对象的引用，super代表父类对象的引用。

class Fu{    int num = 4;    void show()    {        System.out.println("Fu");    }}class Zi extends Fu{    int num = 5;    void show()    {        System.out.println("Zi");        System.out.println(num);        System.out.println(super.num);    }}public class Demo{    public static void main(String[] args){        Zi z = new Zi();        z.show();    }}

函数

覆盖（重写）：当子类中出现和父类一模一样的函数时，当子类对象调用该函数时，会运行子类函数的内容，如同父类的函数被覆盖一样。
上述程序中可说明此现象。
注意：
（1）子类覆盖父类，必须保证子类权限大于等于父类权限才可以覆盖，否则编译失败；
（2）静态只能覆盖静态；
（3）重载：只看同名函数的参数列表，重写：子父类方法要一模一样。
（4）为了避免错误，可以使用一个特殊的java语法，称为重写标注，在子类的方法前放一个@Override，该标注表示被标注的方法必须重写父类的一个方法，如果具有该标注的方法没有重写父类的方法，编译器将报错：

class Fu{    void printValue()    {        System.out.println("Fu");    }}class Zi extends Fu{    @Override    void printValue()    {        System.out.println("Zi");    }}public class Demo{    public static void main(String[] args) {        new Zi().printValue();    }}

构造函数

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

/*    Fu    Zi    Fu    Zi....4*/class Fu{    Fu()    {        System.out.println("Fu");    }}class Zi extends Fu{    Zi()    {        //super();        System.out.println("Zi");    }    Zi(int x)    {        //super();        System.out.println("Zi...." + x);    }}public class Demo{    public static void main(String[] args){        Zi z1 = new Zi();        Zi z2 = new Zi(4);    }}

eg2:如果父类中定义的是有参数的构造函数

/*    Fu....2    Zi    Fu....2    Zi....4 */class Fu{    Fu(int x)    {        System.out.println("Fu...." + x);    }}class Zi extends Fu{    Zi()    {        //super();        super(2);        System.out.println("Zi");    }    Zi(int x)    {        //super();        super(2);        System.out.println("Zi...." + x);    }}public class Demo{    public static void main(String[] args){        Zi z1 = new Zi();        Zi z2 = new Zi(4);    }}

为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式。

 /*    4    s*/public class Demo{    public static void main(String[] args)    {        new Student(4).method();    }}class Person{    private int num;    Person(int num)    {        this.num = num;    }    void show()    {        System.out.println(num);    }}class Student extends Person{    Student(int num)    {        super(num);    }    void method()    {        super.show();        System.out.println("s");    }}

注意： super语句一定定义在子类构造函数第一行。
结论：
（1）子类中的所有的构造函数，默认都会访问父类中空参数的构造函数，因为子类每一个构造函数内的第一行都有一句隐式super();
（2）当父类中没有空参数的构造函数时，子类必须手动通过super语句来指定要访问父类中的构造函数；
（3）当然，子类中的构造函数第一行也可以手动指定this语句来访问本类中的构造函数（如下例），子类中至少会有一个构造函数会访问父类中的构造函数。

/*    Person()    Student()    Student(int num)...4    show    method*/public class Demo{    public static void main(String[] args)    {        new Student(4).method();    }}class Person{    private int num;    Person()    {        System.out.println("Person()");    }    void show()    {        System.out.println("show");    }}class Student extends Person{    Student()    {        //super();        System.out.println("Student()");    }    Student(int num)    {        this();        System.out.println("Student(int num)..." + num);    }    void method()    {        super.show();        System.out.println("method");    }}

final关键字

修饰类，函数和变量：
1. 被final修饰的类不可被继承，为了避免被继承时被子类复写功能；
2. 被final修饰的函数（方法）不可以被复写；
3. 被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，此时为了增强阅读性，都给这些值起名字，方便阅读，而这个值不需要改变，所以加上final修饰：final double PI = 3.1415; 常量的书写规范：所有字母都大写，如果由多个单词组成，单词间通过 _ 连接。

抽象类

当多个类中出现相同功能，但是功能主体不同，此时可以进行向上抽取，这时只抽取功能定义，不抽取功能主体。
抽象类的特点：
1. 抽象方法一定在抽象类中；
2. 抽象方法和抽象类都必须被abstract关键字修饰；
3. 抽象类不可以用new创建对象，因为调用抽象方法没意义；
4. 抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用，如果子类只覆盖了部分抽象对象，那么该子类还是一个抽象类。

public class Demo{    public static void main(String[] args)    {        new Student().show1();        //new Worker().show1();//Error:(865, 9) java: Worker是抽象的; 无法实例化 ，上述3    }}abstract class Person//抽象类{    abstract void show1();    abstract void show2();    void sleep()    {        System.out.println("sleep");    }}class Student extends Person{    void show1()    {        System.out.println("Student show1");    }    void show2()    {        System.out.println("Student show2");    }}abstract class Worker extends Person//上述4{    void show1()    {        System.out.println("Worker show1");    }}

注意：
1. 抽象类和一般类没有太大不同，该怎么描述实物就怎样描述实物，只不过该事物出现了一些看不懂的东西，这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体，通过抽象方法来表示；
2. 抽象类比一般类多了抽象函数，抽象类不可以实例化；
3. 抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
例子：

abstract class Employee//员工类{    private String name;    private String id;    private float pay;    Employee(String name, String id, float pay)    {        this.name = name;        this.id = id;        this.pay = pay;    }    abstract void work();//抽象方法}class Manager extends Employee//经理类{    private float bonus;    Manager(String name, String id, float pay, float bonus)    {        super(name, id, pay);        this.bonus = bonus;    }    void work()    {        System.out.println("Manager work");    }}class proEmployee extends Employee//普通员工类{    proEmployee(String name, String id, float pay)    {        super(name, id, pay);    }    void work()    {        System.out.println("Manager work");    }}public class Demo{    public static void main(String[] args) {    }}

模板方法设计模式

在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分（runCode()）暴露出去，由该类的子类去完成，提高了扩展性和复用性。

abstract class GetTime{    final void  getTime()//避免被复写    {        long beginTime = System.currentTimeMillis();        runCode();        long endTime = System.currentTimeMillis();        System.out.println("Run Time: " + (endTime - beginTime) + "ms");    }    abstract void runCode();}class SubTime extends GetTime{    void runCode()    {        {            for(int i=0; i<6000; i++)            {                System.out.println(i);            }        }    }}public class Demo{    public static void main(String[] args)    {        new SubTime().getTime();    }}

接口

初期理解，可认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class：用于类
interface：用于定义接口

特点

（1）格式：interface{}

（2）成员修饰符是固定的：

成员变量：public static final

成员函数：public abstract

（3）接口的出现将“多继承”通过另一种方式体现出来，即“多实现”；
（4）接口不可以创建对象，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化，否则子类是一个抽象类；
（5）接口可以被类多实现：

interface Inter//接口{    public static final int NUM = 4;    public abstract void show();}interface InterA//接口{    public abstract void method();}class Demo{    void f(){}}class Test extends Demo implements Inter, InterA//单继承+多实现{    public void show()    {        System.out.println("Test");    }    public void method()    {        System.out.println("method");    }}

（6）类与类之间：继承，类与接口之间：实现，接口与接口之间：继承（支持多继承）

    interface A    {        void methodA();    }    interface B //extends A    {        void methodB();    }    interface C extends B,A    {        void methodC();    }    class D implement C    {        public void methodA(){}        public void methodB(){}        public void methodC(){}    }

（7）扩展功能定义在接口中。