Java面向对象编程的三大特征之继承

一. 继承

1.1 继承的概念

什么是继承？就像你继承爸爸妈妈的容貌，财产等东西，这就是继承。但是继承的前提条件必须是，你必须是他的子孙。所以继承需要符合的关系是：is-a，父类更通用，子类更具体。在代码中怎么实现继承呢用extends关键字来实现

1.2 宠物继承案例

1.2.1 继承语法

	修饰符 SubClass extends SuperClass{
     
		//类定义部分
	}

继承通过extends关键字来实现，其中的SubClass称为子类，SuperClass称为父类、基类或超类，修饰符如果是public则该类在整个项目中可见; 若无public修饰符,则该类只在当前包可见;不可以使用private和protected修饰符.

/**
 * 父类，宠物类
 */
public class Pet {
     
    private String name="无名氏";        //昵称
    private int health=100;             //健康值
    private int love=0;                 //亲密度

    /**
     * 无参构造
     */
    public Pet(){
     
        this.health=90;
        System.out.println("执行宠物的无参构造方法。");
    }

    /**
     * 有参构造
     * @param name 昵称
     */
    public Pet(String name){
     
        this.name=name;
    }


    /**
     * 输出信息
     */
    public void print(){
     
        System.out.println(String.format(String.format("宠物自白:\n宠物昵称是:%s,健康值是%d,亲密度是%d",this.name,this.health,this.love)));
    }

    public String getName() {
     
        return name;
    }

    public int getHealth() {
     
        return health;
    }

    public int getLove() {
     
        return love;
    }
}

/**
 * 子类，狗狗类  extends 继承
 */
public class Dog extends Pet{
     
    private String strain;      //品种

    /**
     * 无参构造方法
     */
    public Dog(){
     }

    /**
     * 全参构造
     * @param name      昵称
     * @param strain    品种
     */
    public Dog(String name,String strain){
     
        super(name);
        this.strain=strain;
    }

    public String getStrain() {
     
        return strain;
    }
}

/**
 * 企鹅类
 */
public class Penguin extends Pet{
     
    private String sex = "Q仔";

    /**
     * 无参构造
     */
    public Penguin(){
     }

    /**
     * 有参构造
     * @param name  昵称
     * @param sex   性别
     */
    public Penguin(String name,String sex){
     
        super(name);        //调用父类有参构造
        this.sex=sex;
    }


    public String getSex(){
     
        return this.sex;
    }
}

/**
 * 测试类
 */
public class Test {
     
    public static void main(String[] args){
     
        //1.创建父类
        Pet pet = new Pet();
        pet.print();
        //有参构造
        Pet pets = new Pet("贝贝");
        pets.print();
        //2.创建狗狗对象
        Dog dog = new Dog("欧欧","金毛");
        dog.print();
        //3.创建企鹅对象
        Penguin pgn = new Penguin("楠楠","Q妹");
        pgn.print();
    }
}

以上就是狗狗类和企鹅类继承宠物类，它们都是宠物所以可以继承，而且它们都是相同的地方，把它们的相同的特征和行为集合起来，就可以称为它们的父类。

1.3 继承类型

需要注意的是 Java 不支持多继承，但支持多重继承。

1.4 多重继承关系的初始化顺序

优先加载父类属性 → 父类构造方法 → 子类属性 → 子类构造方法

二. super与this

super关键字:我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类
this关键字:指向自己的引用

	//访问父类构造方法  
	super();		//调用时必须是第一行语句    调用父类无参构造
	super(name);	//调用时必须是第一行语句	   调用父类有参构造
	//访问父类属性
	super.name
	//访问父类对象
	super.print();

三. 访问修饰符

访问修饰符	本类	同包	子类	其他
public	√	√	√	√
protected	√	√	√
默认的(friendly)	√	√
private	√

四. 方法的重写

重写是子类对父类的允许访问的方法的重新编写，返回值和形参都不能改变。即内壳不变，核心重写
重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法

/**
 * 动物类
 */
public class Animal {
     
    public void move(){
     
        System.out.println("动物可以移动");
    }
}
/**
 * 狗狗类继承动物类
 */
public class Dog extends Animal{
     
    @Override
    public void move(){
     
        System.out.println("狗可以跑和走");
    }
}
/**
 * 测试类
 */
public class TestDog {
     
    public static void main(String[] args) {
     
        Animal a = new Animal();
        a.move();

        Dog dog = new Dog();
        dog.move();
    }
}

关键字@Overrider的作用是声明重写

4.1 方法重写与方法重载

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

1. 方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
2. 方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
3. 方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

五. 抽象类和抽象方法

abstract修饰符，用来修饰类，使类不能实例化

/**
 * 宠物抽象类
 */
public abstract class Pet {
     
    //抽象类里面可以有实例方法和抽象方法，构造方法
    public void print(){
      }

    //抽象方法不能有方法体，并且，继承这个类的子类必须重写这个类的抽象方法，除非他的子类也是抽象类
    public abstract void show();
}
/**
 * 狗狗类,继承宠物抽象类
 */
public class Dog extends Pet{
     

    @Override
    public void show(){
     
        System.out.println("抽象方法");
    }
}

/**
 * 测试类 
 */
public class Test {
     
    public static void main(String[] args) {
     
        Dog dog = new Dog();
        dog.show();
    }
}

1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

六. final修饰符

final修饰类: 类不能被继承
final修饰变量: 变量变常量
final修饰方法: 方法不能被重写
final和abstract是相反的两种关键字，

abstract可以用来修饰类和方法,不能用来修饰属性和构造方法
final可以用来修饰类、属性和方法，不能用来修饰构造方法

6.1 声明类

	final class 类名{
     
		//类体
	}	

6.2 声明方法

	修饰符 final 返回值类型(){
     
		//方法体
	}

6.3 声明常量

	//成员变量
	修饰符 final 数据类型 = 值;

	//局部变量
	final 数据类型 = 值;