Java笔记-面向对象-继承（2020.5.13）

（如有问题，欢迎各位大佬批评指正）

面向对象-继承

特点：

1. 子类可以拥有父类的内容
2. 子类还可以拥有自己的专属内容
3. 子类就是一个父类，也就是说，子类可以被当做父类看待

super关键字

1. super.成员变量名
2. 直接访问父类中的成员变量

package md.array.demo01.demo06;

/*
* super
* 1.在子类的成员方法中，访问父类的成员变量。
* 2.在子类的成员方法中，访问父类的成员方法。
* 3.在子类的构造方法中，访问父类的构造方法。
* */

public class Zi extends Fu{

    int num  = 20;
    //在子类方成员方法中，访问父类的成员变量
    public void methodZi() {
        System.out.println(super.num);
    }
    //在子类的构造方法中访问父类构造方法
    public Zi () {
        super();
    }
    //在子类的成员方法中，访问父类的成员方法
    public void method (){
        super.method();
        System.out.println("子类方法");
    }
}

this关键字与super对比

package md.array.demo01.demo07;
/*
* super 关键字是用来访问父类内容，而this关键字用来调用本类中的内容。
* this关键字可以
* 1.在本类的成员方法中，访问本类的成员变量
* 2.在本类的成员方法中，访问本类的另一个成员方法
* 3.在本类的构造方法中，访问本类的另一个构造方法
* super和this只能使用一个，且必须方法第一个位置
* */
public class Zi extends Fu{
    int num = 20;

    //访问本类的一个构造方法
    public Zi() {
       this(20,"233");
    }

    public  Zi (int num) {
        this();
    }

    public Zi (int num, String str) {

    }

    //访问本类中的成员变量
    public void method () {
        int num = 10;
        System.out.println(this.num);//20
        System.out.println(super.num);
    }

    public void methodA() {

    }
    //访问本类中的另一个成员变量
    public void methodB() {
        this.methodA();
    }

}

this和super的内存图

方法重写

1. 重写：方法名一样，参数列表也一样
2. 重载：方法名一样，参数列表不同
3. 重写的特点：创建的是子类的对象，则首先使用子类的方法

方法重写的注意事项

1. 必须保证父子类之间方法名称相同，参数列表也相同
2. @override，用来检测是不是有效的覆盖重写
3. 子类的返回值必须【小于等于】父类的方法的返回值范围
4. 子类的权限必须【大于等于】父类方法的权限修饰符

权限修饰符

public > protected > (default) > private
default：指的是不加任何修饰符的默认状态

构造方法

package md.day04;

/*
* 构造方法注意事项
* 1.构造方法的名称必须和所在类的名称完全相同
* 2.构造方法不要写返回值类型void也没有
* 3.构造方法不能有return
* 4.如果没有编写任何的构造方法，那么编译器会默认给出一个构造方法
* 5.一旦编写了至少一个构造方法，那么编译器将不会给出默认的构造方法
* 6.构造方法也可以进行重载
* */

public class demo03PersonOne {
    public static void main(String[] args) {
        PersonOne personOne = new PersonOne();

        PersonOne personOne2 = new PersonOne("赵丽颖", 18);

        System.out.println("我叫：" + personOne2.getName() + ",我今年：" + personOne2.getAge());

        personOne2.setAge(22);
        System.out.println("我叫：" + personOne2.getName() + ",我今年：" + personOne2.getAge());

    }
}

一个标准的类

package md.day05;
/*
 * 一个标准类通常需要以下四个部分组成
 * 1.所有的成员变量都要使用private进行修饰
 * 2.为每个成员变量编写一对Getter和Setter方法
 * 3.编写一个无参数的构造方法
 * 4.编写一个全参数的构造方法
 * */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

类继承构造方法访问

package md.array.demo01.demo05;

public class Demo01 {
    /*
    * 1.子类构造方法当中有一个默认隐含的super()调用，所以一定是先调用父类构造，后执行子类构造。
    * 2.子类构造可以通过super关键字用来调用父类重载构造
    * 3.super的父类构造调用，必须是子类构造的第一个语句。不能一个子类调用多次super构造
    * 注意：
    * 子类必须调用父类构造方法，不写则赠送一个super();写了则用写的指定的super调用，super只能有一个
    * */
    public static void main(String[] args) {
        Zi zi = new Zi();
    }
}

Java继承的特点