java基础之十->继承、Super、重写、抽象类、抽象方法、final

继承

一、表示子类跟父类的关系
二、当两个类或者多个类具有相同的属性和方法的时候，能够提取出来，变成父类，子类能够继承，is-a(是什么的关系)

为何使用继承

使用(extend)

一、使用继承的时候须要使用extend关键字
二、使用继承关系后，父类中的属性和方法均可以在子类中进行使用（非私有属性和非私有方法）
三、java中是单继承(若是包含多个父类，同时父类中包含重名方法，没法决定该调用谁)

父类 Pet

package com.msbline.oop.extend;
public class Pet {
    private String name;
    private int age;
    private String gender;
    public Pet() {
    }
    public Pet(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    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;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    //私有方法子类没法继承
 private void play(){
        System.out.println("play");
    }
}

子类 Dog

package com.msbline.oop.extend;
public class Dog extends Pet{
    private String sound;
    public Dog() {
    }
    public Dog(String name, int age, String gender, String sound) {
        super(name,age,gender);
        this.sound = sound;
    }
    public String getSound() {
        return sound;
    }
    public void setSound(String sound) {
        this.sound = sound;
    }
}

子类 Penguin

package com.msbline.oop.extend;
public class Penguin extends Pet{
    private String color;
    public Penguin() {
    }
    public Penguin(String name, int age, String gender, String color) {
        super(name,age,gender);
        this.color = color;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
}

测试 PetTest

package com.msbline.oop.extend;
public class PetTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("大黄");
        System.out.println(dog.getName());
    }
}

结语

Super

一、能够在子类中调用父类中被子类覆盖的方法，super.父类方法名称
二、当super在普通方法中使用的时候，能够任意位置编写
三、当super在构造方法中使用的时候，会调用父类的构造方法，必定要将super放在第一行
四、在构造方法中super关键字和this关键字不能同时出现
五、父类中私有的属性和方法不能被调用，包括构造方法
六、子类的构造方法中都会默认使用super关键字调用父类的构造方法
七、若是构造方法中显示指定了super的构造方法，那么无参的构造方法就不会被调用
总结：
一、在建立子类对象的时候必定会优先建立父类对象
二、全部的java类都具有同一个老祖宗类，称之为Object,是全部类的根类

重写

一、必需要存在继承关系，当父类中的方法没法知足子类需求的时候能够选择使用重写的方式

小结

注意：父类的静态方法子类能够进行调用，可是子类不能够重写

示例

父类 Pet

package com.msbline.oop.extend;
public class Pet {
    private String name;
    private int age;
    private String gender;
    
    public Pet() {
    }
    public Pet(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    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;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
 public String toString() {
        return "Pet{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", gender='" + gender + ''' +
                '}';
    }
    public void play(){
        System.out.println("play");
    }
}

子类 Dog

package com.msbline.oop.extend;
public class Dog extends Pet{
    private String sound;
    public Dog() {
    }
    public Dog(String name, int age, String gender, String sound) {
        super(name,age,gender); //在构造方法中必须位于第一行，而且不能跟this()一块儿调用
 this.sound = sound;
    }
    public String getSound() {
        return sound;
    }
    public void setSound(String sound) {
        this.sound = sound;
    }
    @Override
 public String toString() {
        return super.toString() + ",sound=" + sound ;
    }
    @Override
 public void play(){
        System.out.println("dog is playing stone");
    }
}

抽象类

java中的对象是对现实世界的具象化，可是在现实世界中，某些类并不具有实例化的意义，所以能够定义为抽象类

一、建立抽象类的时候须要添加abstract的关键字
二、不能进行实例化，也就是不能new对象

抽象方法

一、抽象类中的某些方法须要子类进行更丰富的实现，父类实现没有意义，此时能够将抽象类中的方法定义为抽象方法，没有具体的实现，只包含方法名称，返回值，参数列表，访问修饰符
二、使用abstract关键字修饰的方法叫作抽象方法，能够不写方法实现
三、子类在继承抽象父类的时候，必需要将父类中的抽象方法进行实现，或者将子类也定义为抽象类

示例

父类 Pet

package com.msbline.oop.abstracttest;
public abstract class Pet {
    private String name;
    private int age;
    public abstract void print();
    public void play(){
        System.out.println("playing");
    }
}

子类 Dog

package com.msbline.oop.abstracttest;
public class Dog extends Pet{
    private String sound;
    @Override
 public void print() {
        System.out.println("dog print");
    }
}

final