Day 08Java基础学习笔记

继承extends（也叫扩展）

多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

通过extends关键字可以实现类的继承

    class 子类名 extends 父类名{}

继承的案例

创建一个Person类，定义两个功能吃饭、睡觉，再创建学生类、教师类，继承Person类，再定义两个自己独有的功能
创建Persen类
public class Person {
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
//创建子类学生类继承Person类
public class Student extends Person {
    public void play(){
        System.out.println("打游戏");
    }
}
//创建Teacher类继承Person类
public class Teacher extends Person {
    public void teach(){
        System.out.println("教书");
    }
}
//创建测试类，对继承进行测试
public class PersonExtends {
    public static void main(String[] args) {
        Student st = new Student();
        st.eat();   //用学生类调用继承方法
        st.play();  //调用自己的方法
        Teacher t =new Teacher();
        t.sleep();
        t.teach();
    }
}

继承的好处

提高了代码的复用性：多个类的相同成员可以放到一个类中
提高了代码的维护性：如果功能的代码需要修改，修改一处即可，继承的类中自动都被修改了
让类与类之间产生了关系，是多态的前提

Java中继承的特点

Java只支持单继承，不支持多继承

即一个类只能有一个直接父类，不可以有多个直接父类

    正确写法：class Sub extends Demo{}
    错误写法：class Sub extends Demo1,Demo2{}

Java支持多层继承

    class A{}
    class B extends A{}
    class C extends B{}
    例
    //
    public class Grandfather {
        public void show(){
            System.out.println("grandfather");
        }
    }
    public class Father extends Grandfather {
        public void method(){
            System.out.println("father");
        }
    }
    public class Son extends Father {
        public void function(){
            System.out.println("son");
        }
    }
    //测试类
    public class GrandfatherTest {
        public static void main(String[] args) {
            Son s = new Son();
            s.function();
            s.method();
            s.show();
        }
    }

Java中继承的注意事项

子类只能继承父类中所有非私有的成员（成员变量、成员方法）
子类不能父类的的构造方法，但可以同super关键字去访问父类构造方法
不要为了部分功能去继承，如果有两个类A,B，只有他们符合A是B的一种或者B是A的一种，就可以考虑使用继承

继承中成员变量的关系

案列演示：
//创建父类定义成员变量
public class Field {
    int num = 10;
    public void method(){
        System.out.println(num);
    }
}
//创建子类继承父类，并定义与父类同名成员变量
public class FieldExtends extends Field {
    int num = 15;
    public void show(){
        System.out.println(num);
    }
    //在子类中定义新的方法，在方法内再定义与父类成员变量同名变量
    public void function(){  
        int num = 5;
        System.out.println(num);
    }
}
//测试类
public class FieldTest {
    public static void main(String[] args) {
        FieldExtends fe = new FieldExtends();
        fe.show();  // 15
        fe.function();   // 5
        fe.method();   //10
    }
}

通过案列可以知道在子类中访问一个变量的顺序

在子类方法的局部范围找，有就使用
在子类的成员范围找，有就使用
在父类成员范围找有就使用
如果找不到，就报错

super关键字

用法与this关键字类似

this 代表对本类对象的引用
super 代表父类存储空间的标识（可以理解为对父类对象的引用）

用法

访问成员变量

this.成员变量
super.成员变量（访问父类的成员变量，不能访问父类的private变量）
访问静态成员时，也可以用  父类名.静态成员

访问构造方法
```
this(...)  super(...)
```

访问成员方法

this.成员方法（）  super.成员方法（）

案列演示

    //创建父类
    public class FatherSuper {
        int num = 10;
        public FatherSuper(){
            System.out.println("父类构造方法");
        }
        public void show(){
            System.out.println("父类成员方法");
        }
    }
    public class SonSuper extends FatherSuper {
        int num = 15 ;
        public SonSuper(){
            System.out.println("子类构造方法");
        }
        public void method(){
            System.out.println("子类成员方法");
        }
        public void function(){
            int num = 5;                    
            System.out.println(num);        //打印方法内局部变量
            System.out.println(super.num);  //打印父类成员变量
            System.out.println(this.num);   //打印本类成员变量
            super.show();                   //调用父类成员方法
            this.method();                  //调用本类成员方法

        }
    }
    测试类
    public class SuperTest {
        public static void main(String[] args) {
            SonSuper ss = new SonSuper();
            ss.function();
        }
    }

继承中构造方法的关系

子类中所有的构造方法默认都会访问父类中空参数的构造方法，除非显示使用super/this调用了父类或者本类的其他构造方法。
在类中对本类或者父类构造方法的调用，只能在构造方法中，不能在实例方法总中调用构造方法（更不能在类方法中调用构造方法）

注意构造方法不能递归调用

    class A {
        public A(int i){
            this(1 ,2);
        }
        public A(int a ,int b){
            this(2);
        }
    }

案例演示

    //创建父类
    public class A {
        public A(){
            System.out.println("父类空参构造");
        }
        public A(String name){
            System.out.println("父类有参构造");
        }
    }
    //创建子类继承父类  
    public class B extends A {
        public B(){           //这一步默认执行了  super（）；调用了父类空参
            System.out.println("子类空参构造");
        }
        public B(String name){
            super(name);  //调用父类有参构造方法
            System.out.println("子类有参构造");
        }
    }
    测试类
    public class C {
        public static void main(String[] args) {
            B b = new B();
            B b1 = new B("tom");
        } 
    }

如果父类没有空参构造，子类的构造方法中就必须显式调用父类带参构造super(...);

super(…)或者this(…)必须出现在构造方法第一条语句上否则，就会有父类数据的多次初始化

方法重写

子类中出现和父类中一摸一样的方法声明，称为方法覆盖（Override）或重写（OverWrite）

使用特点

如果方法名不同就调用对应的方法
如果方法名相同最终使用的是自己的（使用子类的引用的时候，在多态情况下，使用父类的引用，则有可能调用的是父类静态方法）

方法重写的应用

当子类需要父类功能时，而功能主体子类有自己的特有的内容时，可以重写父类的方法，这样即沿袭了父类的功能，又定义了特有的内容。

方法重写是多态实现的条件

//首先创建 一个手机父类
public class PhoneF {
    public void call(String name){   //定义一个方法
        System.out.println("给"+name+"打电话");
    }
}
//在创建一个手机子类继承父类
public class PhoneS extends PhoneF {
    public void call(String name){   //同名同修饰词   对父类中的方法进行重写
        super.call(name);
        System.out.println("听天气预报");  //在继承父类之后在身再加的打印语句
    }
}
//创建测试类
public class PhoneTest {
    public static void main(String[] args) {
        PhoneS ps = new PhoneS();
        ps.call("Tom");
    }
}

方法重写的注意事项

父类中私有的方法不能被重写，编译报错；
子类重写父类方法时，访问权限不能更低，编译报错；
子类重写父类方法时，返回值类型可以相同，也可以是父类返回值的子类型；
父类的实例方法（非静态方法），子类不能重新定义为静态方法
子类中的重写父类方法，按照重写的原则（访问权限不能变小，返回值类型同类或者为子类，方法名相同，形参列表相同）；
子类想重写父类的方法，最好是让方法的签名一模一样；

final关键字

final关键字是最终的意思，可以修饰类，成员变量，成员方法 - 修饰类，类不能被继承（不能放在extends后面） - 修饰变量，变量将变成常量只能被赋值一次，不论是在子类还是本类中，都不能被修改（常量一般是大写字母表示 final int ONE = 1） - 修饰方法，方法不能被重写（子类只用使用权，没有修改权）

final修饰局部变量

在方法内部，该变量不可以被改变
在方法声明上，基本类型是这个参数的值不能被改变，引用类型，是这个参数只想的地址值不能被改变

总结

类中非static的final变量（实例final变量）可以在生命的时候赋值，如果声明的时候没有赋值的话，就必须在以下两个地方赋值，一个是构造代码块一个是构造方法中，如果这两个地方没有赋值，编译报错。

如果是static修饰的final变量的话，则只能在两个地方赋值，声明的时候，或者在静态代码块中。

多态（polymorphism）

某一个事物，在不同时刻表现出来的不同状态

在Java中，对一个事物的引用可以分成两种类型，一种是编译时的类型，一种是运行时的类型。编译时的类型指的是声明这个变量时指定的类型；运行时类型指的是实际赋给这个变量的对象的类型。

    若Student类继承自Person类，则下面的写法是正确的
    Person p = new Student();

注意

父类引用不能调用子类特有的方法，因为使用了父类的引用，就代表站在父类角度来看待当前子类对象，只能看到从父类继承而来的特性，或者是子类重写的父类的方法。成员变量没有多态性，只能看到父类的成员变量。

多态中的成员访问特点

成员变量编译看左边，运行看右边；
构造方法创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化
成员方法便宜看左边，运行看右边
静态方法编译看左边，运行看右边

多态的前提条件

有继承关系
有方法重写
有父类引用指向子类对象

多态中成员访问特点

成员变量和静态方法没有多态性只有被子类重写的成员方法才有多态性