继承

继承的含义：

　　在Java中继承就是指一个类可以继承另一个类，被继承的类叫做：父类/超类/基类，继承其它类的类叫做子类。继承后，子类中就拥有了父类中的所有的成员（成员变量和成员方法）。

继承的好处：

1. 提高代码的复用性（能够有效的减少代码的冗余）。
2. 使类与类之间产生关系。

继承的格式：

使用extends关键字，可以声明一个子类继承另一个父类。

class 父类 {
    ...
}

class 子类 extends 父类 {
    ...
}

注：Java是单继承，一个类只能继承一个直接的父类，并且要满足日常的语言风格

继承的演示：

人类:
public class Person {
    // 成员变量
    String name;
    int age;
    
    // 功能方法
    public void eat(){
        System.out.println("吃东西...");
    }

    public void sleep(){
        System.out.println("睡觉...");
    }
}
老师类: extends 人类
public class Teacher extends Person {
    double salary;// 独有的属性
    public void teach(){}// 独有的方法
}
学生类: extends 人类
public class Student extends Person{

}
Dog:  extends 人类
public class Dog extends Person{// 语法上是可以的,但不符合现实逻辑(不符合is a的关系)

}   
测试:
public class Test {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        System.out.println(t.name);
        System.out.println(t.age);
        t.eat();
        t.sleep();
    }
}

 

继承后成员的访问规则：

构造方法不能被继承：

对于构造方法来说，是不可以被继承的，因为构造方法的主要作用就是给自己本类的属性赋值，所以继承到子类没有意义。

继承后私有成员的访问规则：

父类的私有成员可以被子类继承，但是子类不能直接访问。私有成员只能在自己本类中被直接调用，其它类想调用只能通过间接的方式（如把私有成员用public修饰的方法调用）。

public class Fu{
    private int num = 100;//私有成员，只能在父类内部使用。
    private void method(){
        System.out.println("私有成员方法");
    }
}
public class Zi extends Fu{

}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        System.out.println(z.num);// 编译错误
        z.method();// 编译错误
    }
}

继承后非私有成员的访问规则：

当通过子类访问非私有成员时，先在子类中找，如果找到就使用子类的，找不到就继续去“父类”中找。

public class Fu{
    int money = 100;
    public void method(){
        System.out.println("Fu 类中的成员方法method");
    }
}
public class Zi extends Fu{
    int money = 1;
     public void method(){
        System.out.println("Zi 类中的成员方法method");
    }
}
public class Demo{
    public static void main(String[] args){
        Zi z = new Zi();
        System.out.println(z.money);//1
        z.method();// Zi 类中的成员方法method
    }
}

方法重写：

概念：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

重写的注意事项：

1. 重写时发生在子类和父类之间的
2. 子类重写父类方法，返回值类型、方法名和参数列表必须一模一样
3. 重写可以在方法的上方写关键之@Qverride注解，让系统自己辨认重写的方法是否正确
4. 子类方法重写父类方法，必须保证权限大于等于父类的权限（public>protected>默认>private）

class Fu{
    public void sport(){
        System.out.println("Fu 运动的方式跑步");
    }

    public void run(){
        System.out.println("Fu 第1圈");
        System.out.println("Fu 第2圈");
        System.out.println("Fu 第3圈");
    }
}

class Zi extends Fu{
    // 子类方法的实现和父类方法的实现完全不同
    @Override
    public void sport() {
        System.out.println("Zi 运动的方式游泳");
    }

    // 子类方法的实现要保留父类方法的功能,但要在父类功能的基础之上额外增加功能
    @Override
    public void run() {
        // 让父类的方法执行=====复制父类的代码过来
        super.run();// 调用父类的方法

        // 额外增加的代码
        System.out.println("Zi 第4圈");
        System.out.println("Zi 第5圈");
        System.out.println("Zi 第6圈");
        System.out.println("Zi 第7圈");
        System.out.println("Zi 第8圈");
        System.out.println("Zi 第9圈");
        System.out.println("Zi 第10圈");
    }
}

public class Test {
    public static void main(String[] args) {
        /*
            方法重写的使用场景:
                当父类的方法无法满足子类的需求的时候,子类就会去重写父类的方法
         */
        // 创建子类对象
        Zi zi = new Zi();
        // 调用运动的方法
        zi.sport();
        // 调用跑步的方法
        zi.run();

    }
}

this关键字和super关键字：

this：存储的是当前对象的引用；

this可以访问：本类的成员属性、成员方法、构造方法

super：存储的是父类的对象的引用；

super可以访问：父类的成员属性、成员方法、构造方法；

this关键字的三种用法：

this访问本类成员变量: this.成员变量

public class Student{
    String name = "张三";
    public void show(){
        String name = "李四";
        System.out.println("name = " + name);// 李四
        System.out.println("name = " + this.name);// 张三
    }
}

this访问本类成员方法: this.成员方法名();

public class Student{
    public void show(){
        System.out.println("show方法...");
        this.eat();
    }
    public void eat(){
        System.out.println("eat方法...");
    }
}

this访问本类构造方法: **this()可以在本类的一个构造方法中，调用另一个构造方法

public class Student{
    public Student(){
        System.out.println("空参构造方法...");
    }

    public Student(String name) {
        this();//当使用this()调用另一个构造方法时，此代码必须是此构造方法的第一句有效代码。
        System.out.println("有参构造方法...");
    }
}
public class Demo {
    public static void main(String[] args) {
        Student stu2 = new Student();
    }
}

super关键字的三种用法

super访问父类的成员变量: super.父类成员变量名

super访问父类的成员方法: super.成员方法名();

super访问父类的构造方法: super()

public class Fu{
    public Fu(){
        System.out.println("Fu 类的空参构造方法..");
    }
    public Fu(String name, int age) {
        System.out.println("Fu 类的有参构造方法..");
    }
}
public class Zi extends Fu{
    public Zi(){
        super();// 调用父类的空参构造方法
        System.out.println("Zi 类的空参构造方法..");
    }
    public Zi(String name,int age){
        super(name,age);// 调用父类的有参构造方法
         System.out.println("Zi 类的有参构造方法..");
    }
}
public class Demo {
    public static void main(String[] args) {
        Zi zi = new Zi();
        System.out.println("----------------------");
        Zi z2 = new Zi("刘德华", 17);
    }
}

this关键字的注意事项：

1. 只有在本类的构造方法中使用this调用其他构造方法
2. 在本类的构造方法中使用this调用其他构造方法，必须放在该构造方法的第一行
3. 两个构造方法不能使用this同时相互调用

super关键字：

1. 子类的构造方法默认会调用父类的空参构造方法
2. super访问父类的构造方法,可以用来初始化从父类继承过来的属性
3. 在子类的构造方法中,使用super调用父类的构造方法,必须放在子类构造方法的第一行
4. super访问成员变量和成员方法，优先在父类中查找，如果没有，继续向上查找，再没有则报错
5. 子类构造方法会默认的调用父类中的空参构造，如果父类中只有有参构造，则子类会报错

注：Object类是所有类的父类，所以它的方法都可以用