Java基础的重点知识-07-继承、抽象类

继承

就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。

1. 继承的格式
   通过extends关键字，可以声明一个子类继承另外一个父类，定义格式如下：

public class Person {
}
class Student extends Person{

    String name;
    int age;

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class Teacher extends Person{
    String name;
    int age;

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

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

这里的代码比较冗余，由此引出继承的优势之一：提高代码的复用性。

public class Person {
    String name;
    int age;

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

class Student extends Person{

    public Student(String name, int age) {
        super(name, age);
    }
}

class Teacher extends Person{

    public Teacher(String name, int age) {
        super(name, age);
    }
    
}

我们可以发现，子类能继承父类的属性。

注意点：

• 如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。
• 如果子类父类中出现重名的成员变量，这时的访问是有影响的。这时我们需要使用super关键字了，super关键字的作用类似于this关键字，能够标识子类和父类中的相同名称的不同的成员变量
• Fu类中的成员变量是非私有的，子类中可以直接访问。若Fu类中的成员变量私有了，子类是不能直接访问的。

2. 重点（方法重写）
   如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

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

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

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

    public void show(){
        System.out.println("我会说话。");
    }
}

class Student extends Person{

    public Student(String name, int age) {
        super(name, age);
    }

    public void show(){
        System.out.println("我会学习。");
    }
}

class Teacher extends Person{
    public void show(){
        System.out.println("我会授课。");
    }

    public Teacher(String name, int age) {
        super(name, age);
    }

}

这里我们可以看到，当我们的父类Person中定义了public void show()方法时，我们的子类也定义了同样的返回值、参数类型、方法名相同的方法，这时就实现了方法的重写。Person类中show（）方法的作用是打印“我会说话。”，而子类Student中的show（）方法是打印“我会学习。”，这里就体现了方法重现的特点。声明不变，重新实现。

这里我们回忆一下，方法重载的关注点是同一个类中的参数列表的参数个数、参数类型、参数顺序，而方法重载则是出现在俩个类中，关注点是返回值、方法名、参数列表。

3. super和this

父类空间优先于子类对象产生（通俗一点就是没有父亲哪里来的孩子）

• 在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。
• this.成员变量=>本类的，super.成员变量=>父类的 ，this.成员方法名()=>本类的 ，super.成员方法名() =>父类的

4. 继承的特点

• Java只支持单继承，不支持多继承。
• Java支持多层继承(继承体系)。

抽象类（abstract）

抽象方法：没有方法体的方法。
抽象类：包含抽象方法的类。

**注意：**抽象类中不一定有抽象方法，但是又抽象方法的类一定是抽象类。

public abstract class Bird {
    private void show(){
        System.out.println("show");
    }

    protected void play(){
        System.out.println("play");
    }
}


class Parrot extends Bird{
    
}

从上图中我们可以看到，虽然Bird（鸟类）被定义为了抽象类，但是其中没有抽象方法。

抽象方法： 修饰符 abstract 返回值类型 方法名 (参数列表)；
抽象类： abstract class 类名字 {}
抽象的使用： 继承抽象类的子类必须重写父类所有的抽象方法。
代码示例：

public abstract class Bird {
    public abstract void fly();
}


class Parrot extends Bird{

    @Override
    public void fly() {
        System.out.println("鹦鹉在飞");
    }
}

注意：

• 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
• 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
• 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类

public abstract class Bird {
    private String name;
    private String age;
    public abstract void fly();

    public Bird() {
    }

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


class Parrot extends Bird{

    public Parrot() {
    }

    public Parrot(String name, String age) {
        super(name, age);
    }

    @Override
    public void fly() {
        System.out.println("鹦鹉在飞");
    }
}

欢迎java热爱者了解文章，作者将会持续更新中，期待各位友友的关注和收藏。。。