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 数据类型 =;
©️2020 CSDN 皮肤主题: 黑客帝国 设计师:上身试试 返回首页