java之继承（继承的成员变量/方法、构造方法的访问特点；super、this关键字和实际的内存图解），抽象方法和抽象类（abstract关键字）以及其使用，发红包案例

最新推荐文章于 2021-02-12 19:22:24 发布

一只tobey

最新推荐文章于 2021-02-12 19:22:24 发布

阅读量955

点赞数 2

分类专栏： Java

本文链接：https://blog.csdn.net/zz2230633069/article/details/110289065

版权

Java 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。

继承描述的是事物之间的所属关系，这种关系是： is-a 的关系即“子类就是一个父类”。子类可以当作父类看待，例如父类是员工，子类是教师，那么is-a关系描述为“教师就是一个员工”。父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

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

定义父类的格式：（一个普通的类定义）

public class 父类名称{

// ...

}

定义子类的格式：(使用关键字extends)

public class 子类名称 extends 父类名称{

// ...

}

// 父类
public class Employee {
    String name; // 定义name属性
    // 定义员工的工作方法
    public void method() {
        System.out.println("尽心尽力地工作");
    }
}

//  定义员工的一个子类：教师
public class Teacher extends Employee {
    public void printName(){
        System.out.println("name="+name);
    }
}
// 定义员工的另一个子类：助教
public class Assistant extends Employee {
}

// 测试
public class Extends {
    public static void main(String[] args) {
        // 创建了一个子类对象
        Teacher teacher = new Teacher();
        // 虽然Teacher类什么都没写，但是继承来自父类method方法。
        teacher.method(); // 尽心尽力地工作
        teacher.name = "小范";
        teacher.printName(); // name=小范
        // 创建另一个子类对象
        Assistant assistant = new Assistant();
        assistant.method(); // 尽心尽力地工作
    }
}

继承中成员变量的访问特点

两种情况：成员变量重名和不重名。

1.父类和子类的成员变量不重名的情况下。访问无影响，正常访问形式，继承而来直接访问。

// 父类
class Fu {
    // Fu中的成员变量。
    int num = 5;
}
// 子类
class Zi extends Fu {
    // Zi中的成员变量
    int num2 = 6;
    // Zi中的成员方法
    public void show() {
        // 访问父类中的num，
        System.out.println("Fu num="+num); // 继承而来，所以直接访问。
        // 访问子类中的num2
        System.out.println("Zi num2="+num2);
    }
}
//测试
class ExtendDemo02 {
    public static void main(String[] args) {
// 创建子类对象
        Zi z = new Zi();
// 调用子类中的show方法
        z.show();
    }
}
演示结果：
        Fu num = 5
        Zi num2 = 6
}

2.父类和子类的成员变量重名的情况下。访问是有影响的！则创建子类对象时，访问有两种方式：

（1）直接访问：通过子类对象来访问成员变量：等号左边是谁，就优先用谁，没有则向上找。

（2）间接访问：通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则往上找。

下面是重名出现冲突，不能直接访问，有影响！
class Fu {
    // Fu中的成员变量。
    int num = 5;
}
class Zi extends Fu {
    // Zi中的成员变量，和父类变量重名了
    int num = 6;
    public void show() {
        // 原本想访问父类中的num
        System.out.println("Fu num=" + num);
        // 原本想访问子类中的num
        System.out.println("Zi num=" + num);
    }
}
class ExtendsDemo03 {
    public static void main(String[] args) {
        // 创建子类对象
        Zi z = new Zi();
        // 调用子类中的show方法
        z.show();
    }
}
演示结果：
        Fu num = 6  实际上都是子类中的变量，并没有访问到父类的变量num
        Zi num = 6

使用上述的两种访问方式：

// 父类
class Fu {
    // Fu中的成员变量。、
    int numF = 10;
    int num = 5;
    public void printFu(){
        // 使用本类中的，不会向下找子类。
        System.out.println("输出父类重名中的值："+num);
    }
}
// 子类
class Zi extends Fu {
    int numZ = 20;
    // Zi中的成员变量，和父类变量重名了
    int num = 6;
    public void show() {
        // 原本想访问父类中的num，但是本类当中有num，所以这里用的是本类的num，和预想不一样，这里的num为6。
        System.out.println("Fu num=" + num);
        // 原本想访问子类中的num，确实是子类中的num，所以值和预想是一样的，为6。
        System.out.println("Zi num=" + num);
    }
    public void printZi(){
        // num是本类中的变量还是父类中的变量？就近原则，是本类的num，所以数字是6
        System.out.println("输出子类重名中的值："+num);
    }
}
// 测试
class ExtendsDemo03 {
    public static void main(String[] args) {
        // 创建父类对象
        Fu f = new Fu();
        System.out.println(f.numF); // 只能使用父类的东西，没有任何子类内容。
        // 创建子类对象
        Zi z = new Zi();
        // 方式一：直接访问法：直接访问成员变量。等号左边是谁，就优先用谁，没有则向上找。
        System.out.println(z.num); // 由z调用num，z是由Zi创建出来的，也就是创建的等式中，左边的是Zi，所以用Zi中自己的变量。确实存在，优先z子类，所以打印出来是6
        System.out.println(z.numF); // 由z调用numF，z是由Zi创建出来的，也就是创建的等式中，左边的是Zi，所以用Zi中自己的变量。但是没有numF变量，所以向上找，找到了父类。
        System.out.println(z.numFZ); // 往上找也没有这个变量，那么编译报错。
        // 方式二：间接访问法：通过方法来访问成员变量。该方法属于谁，就优先用谁，没有则往上找。
        z.printZi(); // printZi这个方法是子类的，那么方法中的变量就会优先用子类的变量，确实存在，所以值是6.
        z.printFu(); // printFu这个方法是属于父类的的，子类是没有的，不存在，所以往上找，使用父类中的num变量，所以值是5.
    }
}

区分子类方法中重名的三种变量

使用局部变量：直接写局部变量

使用本类的成员变量：this.成员变量（使用this关键字）

使用父类的成员变量：super.父类变量（使用super关键字）

// 父类
class Fu {
    // Fu中的成员变量。
    int num = 5;
}
// 子类
class Zi extends Fu {
    // Zi中的成员变量，和父类变量重名了
    int num = 6;

    public void method() {
        // 局部变量
        int num = 7;
        System.out.println("使用局部变量的值：" + num); // 直接使用，值是7
        System.out.println("使用子类成员变量的值：" + this.num); // 需要添加this关键字，值是6
        System.out.println("使用父类成员变量的值：" + super.num); // 需要添加super关键字，值是5
    }
}
// 测试
class ExtendsDemo03 {
    public static void main(String[] args) {
        // 创建子类对象
        Zi z = new Zi();
        // 调用子类方法，查看打印内容
        z.method();
    }
}

继承中成员方法的访问特点

两种情况：成员方法重名和不重名。

1.父类和子类成员方法不重名的情况。访问方式不影响，直接访问。（和成员变量不重名名时的使用是一样的）

2.父类和子类成员方法重名的情况。访问方式是有影响的！访问方式只有一条：

创建的对象是谁，就优先用谁，如果没有则往上找。

// 父类
class Fu {
    // Fu中的成员方法。
    public void print(){
        System.out.println("这是父类方法");
    }
    public void printf(){
        System.out.println("这是父类独有的方法");
    }
}
// 子类
class Zi extends Fu {
    // Zi中的成员方法，和父类方法重名了
    public void print(){
        System.out.println("这是子类方法");
    }
}
// 测试
class ExtendsDemo03 {
    public static void main(String[] args) {
        // 创建子类对象
        Zi z = new Zi();
        z.print(); // 子类对象在调用该方法，那么优先用子类中的方法，同时也确实在。所以会打印出”这是子类方法“
        z.printf(); // 子类对象在调用该方法，那么优先用子类中的方法，但是不存在，需要往上找。所以会打印出”这是父类独有的方法“
    }
}

注意事项

无论是成员方法还是成员变量，如果没有都是向上找父类，不会向下找子类。

继承中方法的覆盖重写

重写（Override）

概念：在继承关系中，方法的名称一样，参数列表也一样。

重写（Override）：方法的名称一样，参数列表也一样。也叫做覆盖、覆写。

重载（Overload）：方法的名称一样，参数列表不一样。

方法的覆盖重写特点：创建的子类对象，所以优先用子类方法。

注意：

1.必须保证父子类之间的方法名称相同，参数列表也相同。

@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。也就是检测该方法是不是重写，如果不是则@Override会报错。@叫做annotation，注解。

这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。推荐还是加上这个注解。

2.子类方法的返回值必须【小于等于】父类方法的返回值范围。比如父类是Object，子类是String是可以的。

java.lang.Object类是所有类的公共最高父类。java.lang.String就是Object的子类。

3.子类方法的权限修饰符必须【大于等于】父类方法的权限修饰符。

备注：权限修饰符的权限从大到小的顺序public > protected > (default) > private. 其中（default）不是关键字default，而是什么都不写，留空。

上图中的方法名字应该是method，所以检查不是方法重写，那么就会编译器报错，所以@Override能安全检测的作用。

继承和覆盖重写的应用：

// 老款手机
public class Phone {
    public void call(){
        System.out.println("打电话");
    }
    public void send(){
        System.out.println("发短信");
    }
    public void show(){
        System.out.println("显示号码");
    }
}
// 新款手机
public class NewPhone extends Phone {
    @Override
    public void show() {
        super.show();
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}
//打印查看
public class PhoneTest {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.call();
        phone.send();
        phone.show();
        NewPhone newphone = new NewPhone();
        newphone.call();
        newphone.send();
        newphone.show();
    }
}

继承中构造方法的访问特点

1.子类构造方法中有一个默认隐含的“super()”调用（调用父类无参构造方法），所以一定是先调用的父类构造，后执行的子类构造。

2.子类构造可以通过super关键字来调用父类的重载构造。

3.子类构造方法的第一个语句，必须是super的父类构造调用（如果是默认隐含的，实际上也是第一个语句）。一个子类构造不能多次调用多次super构造。

总结：子类必须调用父类构造方法，不写则赠送super()；写了则用指定的super调用，super只能有一个并且是第一个语句位置。

super关键字的三种用法

1.在子类的成员方法中，访问父类的成员变量。

2.在子类的成员方法中，访问父类的成员方法。

3.在子类的构造方法中，访问父类的构造方法。注意必须是子类构造方法的第一个语句。

// 父类
public class Fu {
    int num = 10;
    public void method(){
        System.out.println("这是父类成员方法");
    }
    public Fu(){
        System.out.println("这是父类的构造方法。");
    }
}
//子类
public class Zi extends Fu{
    int num = 20;
    public void methodZi(){
        System.out.println(super.num); // 1.访问父类中的num变量
    }
    public void method(){
        super.method(); // 2.访问父类中method方法
        System.out.println("这是子类成员方法！");
    }
    public Zi(){
        super(); // 3.访问父类的构造器，如果没有任何参数，那么也可以隐藏即不写。
        System.out.println("这是子类的构造方法！");
    }
}

this关键字的三种用法

super关键字用来访问父类内容，this关键字访问本类内容。用法也有三种。

1.在本类的成员方法中，访问本类的成员变量。

2.在本类的成员方法中，访问本类的另一个成员方法。

3.在本类的构造方法中，访问本类的另一个构造方法。注意必须是子类构造方法的第一个语句。

备注：this（...）调用必须是构造方法中的第一个语句，同时super也必须是第一个，因此super和this不能同时使用。

public class Zi extends Fu{
    int num = 20;
    public void methodZi(){
        int num = 30;
        System.out.println(this.num); // 1.this 访问本类中的num变量 20
        System.out.println(super.num); // 访问父类中的num变量 10
        System.out.println(num); // 访问成员方法中的局部变量 30
    }
    @Override // 可写可不写，写了更保险。
    public void method(){
        this.methodZi(); // 2.访问本类中的methodZi()方法
        methodZi(); // 和上面语句作用一样
        super.method(); // 访问父类中method方法
    }
    // 构造方法
    public Zi(){
//        this();// 不能自己访问构造方法自己。
        this(12); // 3.在构造方法中，访问本类的另一个构造方法即下面的有参构造方法。
//        super(); // 不能同时使用this和super.
        System.out.println("这是子类的无参构造方法！");
    }
    public Zi(int num) {
//        this(); // 不能套娃，上面调用了这个，这个构造方法又调用上面构造方法，会形成死循环。编译器检测自动报错。
        this.num = num;
        System.out.println("子类有参数的构造方法！");
    }
}

super和this内存图解

Java继承的三个特点

1.Java语言是单继承的。一个类的直接父类只能由唯一一个。

2.Java语言可以多级继承。

3.一个子类的直接父类是唯一的，但是一个父类可以拥有很多子类。

抽象类

由来：父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。
定义：
抽象方法：没有方法体的方法。
抽象类：包含抽象方法的类。

格式和使用

抽象方法：使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：加上abstract关键字，然后去掉大括号（因为大括号的内容不确定），直接分号结束。抽象方法一定要在抽象类中。

修饰符 abstract 返回值类型方法名 (参数列表)；

代码举例：public abstract void run()；

抽象类：如果一个类包含抽象方法，那么该类必须是抽象类。

定义格式：在class之前写上abstract关键字就可以。

abstract class 类名字 {
}

代码举例：

public abstract class Animal {
public abstract void run()；
}

// 抽象方法所在的类必须是抽象类才行。只需要在class之前写上abstract即可。
public abstract class Animal {
    // 这是一个抽象方法，代表吃东西。但是具体吃什么（大括号的内容）不确定。
    public abstract void eat();
    // 这是一个普通成员方法
    public void normalMethod(){
    }
}

使用抽象类和抽象方法的步骤：

1.不能直接创建抽象类对象，即new 抽象类对象。必须用一个子类来继承抽象类。

2.子类必须覆盖重写抽象父类当中所有的抽象方法。

备注：覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体和大括号。

3.创建子类对象进行使用。

// 父类
public abstract class Animal {
    // 这是一个抽象方法，代表吃东西。但是具体吃什么（大括号的内容）不确定。
    public abstract void eat();
    // 这是一个普通成员方法
    public void normalMethod(){
    }
}
// 子类继承父类
public class Cat extends Animal {
    @Override // 方法覆盖重写
    public void eat(){
        System.out.println("猫吃鱼！");
    }
}
// 使用
public class AnimalTest {
    public static void main(String[] args) {
//        Animal animal = new Animal(); // 错误写法，不能直接创建抽象对象
        Cat cat = new Cat();
        cat.eat();
    }
}

抽象方法和抽象类的注意事项

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

发红包案例（主要内容是继承相关知识）

分析：

实现：

// 用户类，父类
public class User {
    private String name; // 姓名
    private int money; // 余额

    public User() {
    }

    public User(String name, int money) {
        this.name = name;
        this.money = money;
    }

    public void show(){
        System.out.println("我叫什么名字："+name+" 我有多少钱："+money);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}
// 群主类，子类
import java.util.ArrayList;
public class Manager extends User{
    public Manager() {
    }

    public Manager(String name, int money) {
        super(name, money);
    }
    // 发红包的方法
    public ArrayList<Integer> send(int totalMoney, int count){
        // 首先需要一个集合，用来存储若干个红包的金额
        ArrayList<Integer> redList = new ArrayList<>();
        // 首先看以下群主有多少钱
        int leftmoney = super.getMoney();
        if(totalMoney>leftmoney){
            System.out.println("余额不足！");
            return redList;
        }
        // 扣钱
        super.setMoney(leftmoney-totalMoney);
        // 发红包，需要重新拆分count份
        int avg = totalMoney/count; // 平分的钱
        int mod = totalMoney%count; // 平分剩下的钱
        // 除不开的零头，放在最后一个红包里头
        // 下面把红包数额放进集合中
        for (int i = 0; i < count-1; i++) {
            redList.add(avg);
        }
        // 最后一个红包
        int last = avg+mod;
        redList.add(last);
        return redList;
    }
}
// 成员类，子类
import java.util.ArrayList;
import java.util.Random;
public class Member extends User{
    public Member() {
    }

    public Member(String name, int money) {
        super(name, money);
    }
    // 收红包方法
    public void receive(ArrayList<Integer> list){
        // 从多个红包随便抽取一个给我自己。随机获取一个集合当中的索引编号。
        int index = new Random().nextInt(list.size());
        //根据索引，从集合当中删除，并且得到被删除的红包
        int delta = list.remove(index);
        // 当前成员的钱
        int money = super.getMoney();
        // 设置获取之后的总金额
        super.setMoney(money+delta);
    }
}
// 测试代码
public class MainRedPacket {
    public static void main(String[] args) {
        Manager manager = new Manager("群主",100);
        Member one = new Member("成员A",0);
        Member two = new Member("成员B",0);
        Member three = new Member("成员C",0);
        manager.show();
        one.show();
        two.show();
        three.show();
        System.out.println("========================");
        // 开始发红包
        ArrayList<Integer> list = manager.send(20,3);
        // 三个普通成员去收红包
        one.receive(list);
        two.receive(list);
        three.receive(list);
        manager.show();
        one.show();
        two.show();
        three.show();
    }
}

一只tobey

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
java之继承（继承的成员变量/方法、构造方法的访问特点；super、this关键字和实际的内存图解），抽象方法和抽象类（abstract关键字）以及其使用，发红包案例

继承多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。继承描述的是事物之间的所属关系，这种关系是： is-a 的关系即“子类就是一个父类”。子类可以当作父类看待，例如父类是员工，子类是教师，那么is-a关系描述为“教师就是一个员工”。父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。继承的定义：就是子类继承父类的属性和行
复制链接

扫一扫