Java学习笔记（六）--继承 final关键字 多态 抽象类 接口

继承

1.通过extends关键字可以实现类与类的继承。
格式：class 子类名 extends 父类名{}
-父类：基类，超类
-子类：派生类
需求：学生类和老师类（非继承类版代码）
学生类：

public class Student{
    private String name;
    private int age;

    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }

    public Student(){}
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    public void eat(){
        System.out.println("学生需要吃饭！");
    }
}

老师类：

public class Teacher {
        //私有化成员变量
        private String name;
        private int age;

        //set/get方法
        public void setName(String name){
            this.name = name;
        }
        public String getName(){
            return name;
        }

        public void setAge(int age){
            this.age = age;
        }
        public int getAge(){
            return age;
        }

        //有参数+无参数的构造
        public Teacher(){}
        public Teacher(String name,int age){
            this.name = name;
            this.age = age;
        }

        //吃饭和睡觉的方法
        public void eat(){
            System.out.println("老师需要吃饭！");
        }
}

找一个父类：人类

public class Person {
    //私有化成员变量
    private String name;
    private int age;

    //set/get方法
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }

    //有参数和无参数的构造
    public Person(){}
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //吃饭和睡觉的方法
    public void eat(){
        System.out.println("人都需要吃饭！");
    }

2.继承的好处：
-提高了代码的复用性，多个类相同的成员可以放到同一个类中。
-提高了代码的维护性，如果功能的代码需要修改，修改一处即可。
-让类与类之间产生了关系，是多态的前提。
3.继承的特点：
-Java只支持单继承，不支持多继承
-Java支持多层继承
4.继承间成员变量关系：
-名字不同，很简单
-名字相同，首先在子类局部范围找，然后在子类成员范围找，最后在父类成员范围找（不能访问到父类的局部范围），如果没有就报错（不考虑父亲的父亲）。（就近原则）

需求：在show方法中输出40,30,20,10

class Fu {
    public int num = 10;
    public int num4 = 50;
}
class Zi extends Fu {
    public int num2 = 20;
    public int num = 30;    

    public void show() {
        int num = 40;
        System.out.println(num);//输出40
        System.out.println(this.num);//this代表的是本类的一个对象，谁调用我，我指代谁
        System.out.println(num2);
        System.out.println(super.num);//super可以理解为父类的一个对象
        System.out.println(num4);
    }
}

5.通过super关键字去访问父类的成员
super：代表父类存储空间的标识（可以理解为父类的对象）
6.this和super的使用区别：
-成员变量：
this.成员变量 本类的成员变量
super.成员变量 父类的成员变量
-成员方法：
this.成员方法() 本类的成员方法
super.成员方法() 父类的成员方法
7.继承间的成员方法关系：
-方法名不同，非常简单
-方法名相同，首先在子类中找，然后在父类中找，如果还是没有就报错。(不考虑父亲的父亲)
8.继承间构造方法的关系：
子类中所有的构造方法默认都会访问父类中空参数的构造方法(super())。每一个子类的构造方法第一行，有一条默认的语句：super（）；
原因：子类会继承父类的数据，可能还会使用父类的数据，所以子类初始化之前，一定要完成父类数据的初始化。
注意：仅仅是数据的初始化，并没有创建父类的对象，创建对象前必须用new申请空间。
假如父类没有无参构造，调用父类的其他构造方法，带参构造。super（…）；

---

final关键字

1.final：最终的意思，它可以修饰类、方法、变量。
2.特点：
-修饰方法，方法不能被重写；
-修饰类，类不能被继承；
-修饰变量，变量值不能再被改变，此时变量就相当于变成一个常量。
–常量：
第一种：字面值常量
“hello”，24，‘a’
第二种：自定义变量
变量用final修饰；
定义的常量；
final 数据类型 变量名；

---

多态

1.多态：同一个对象，在不同时刻表现出来的不同状态。
2.多态的前提：
-有继承关系
-有方法重写（有方法重写多态才有意义）
-有父类引用指向子类对象

Fu f = new Fu(); //左边是Fu类型的引用，右边是Fu类型的对象
Zi z = new Zi();
Fu f = new Zi();

3.多态的情况下，成员访问特点：
-成员变量：编译看左边，运行看左边
-构造方法：子类构造默认访问父类的无参构造
-成员方法：编译看左边，运行看右边（方法和变量不一样的原因是有方法重写）
-静态成员方法：编译看左边，运行看左边（静态内容和类相关，与对象无关）

---

抽象类

1.抽象类特点：
-抽象类和抽象方法必须用abstract关键字修饰；
-抽象类不一定有抽象方法，但是有抽象方法的类一定是抽象类；
-抽象类不能实例化，按照多态的方式，由具体的子类实例化（抽象类多态）；
-抽象类的子类：
–要么是抽象类；
–要么重写抽象类的所有抽象方法。
2.抽象类的作用：强制要求子类必须要重写某些方法。
3.抽象类的组成：
-成员变量：可以是变量，也可以是常量。
-构造方法：抽象类不能实例化，构造方法用于子类访问父类数据的初始化。
-成员方法：既可以是抽象的，也可以是非抽象的。
4.抽象类的分析过程：
分析：
从具体到抽象。
实现：
从抽象到具体。
使用：
使用具体的类。
5.多态：
-具体类多态

class Fu{}
class Zi extends Fu{}

-抽象类多态

sbstract class Fu{}
class Zi extends Fu{}

-接口多态

---

接口

1.类实现接口代表着这个类自身功能的一种扩展。接口代表着一种扩展能力。
2.接口的特点：
第一点：定义接口要用interface表示，格式：

public interface 接口名[extends 父接口1，父接口2，…]{
    public static final常量；//零个到多个常量定义
    public abstract 方法名(); //零个到多个抽象方法定义
}

第二点：一个类可以实现一个或接口，实现接口用implements关键字，Java中一个类只能继承一个父类，这样不够灵活，可以使用多个接口加以补充，格式：

class 类名 extends 父类名 implements 接口名1，接口名2，…{
    类体部分； //如果继承了抽象类，就必须实现继承的抽象方法；还要实现接口的抽象方法
}

注意：
–如果要继承父类，继承父类必须在实现接口之前。
–在给接口命名的时候，为和普通的类区分，常在名字前加I，例如：IPlayGame
第三点：接口不能实例化，按照多态的方式，有具体的子类实例化（接口多态）。
第四点：接口的实现类：
–要么是抽象类；
–要么重写接口中的所有抽象方法。
3.多态的前提：
-有继承或者实现关系；
-有方法的重写；
-有父类引用或者父类接口引用指向子类对象或者实现类对象。
4.接口的成员特点：
-成员变量：只能是常量。
默认修饰符：public static final
-构造方法：没有构造方法
-成员方法：只能是抽象方法。
默认修饰符：public abstract
5.类与类：
继承关系。只能是单继承，可以是多层继承。
类与接口：
实现关系。可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口。
接口与接口：
继承关系。可以单继承，也可以多继承。
6.接口和抽象类的关系：

-接口和抽象类的区别：
–抽象类：
成员变量：可以是变量，也可以是常量
构造方法：有构造方法
成员方法：可以是抽象方法，也可以是非抽象方法
–接口：
成员变量：只能是常量。默认修饰符：public static final
构造方法：没有构造方法
成员方法：只能是抽象方法。默认修饰符：public abstract

-关系区别：
–类与类：
继承关系。可以单继承，也可以多层（重）继承。
–类与接口：
实现关系。可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口。
–接口与接口：
继承关系。可以单继承，也可以多继承。

-设计理念区别：
抽象类被继承体现的是“is a”的关系，抽象类定义的是共性内容。
接口被实现体现的是“like a”的关系，接口定义的是扩展功能。