[Java] 继承和抽象类

更慢了，加快进度吧

第一章 继承

1.1 继承概述

继承就是类和对象的三大特性之一，他的概述就是顾名思义，某个类继承某个类

被继承的对象叫做父类（基类、超类）

继承的对象叫做子类（派生类）

特点：

• 继承是多态·的前提，没有继承就没有多态

• 继承主要解决的问题是：共性抽取

• 子类可以拥有父类中的内容

• 子类还可以拥有自己的成员和方法

• 同时，继承是子类指向父类的，通俗的讲，就是爸爸不知道儿子的存在，但是儿子知道他的爸爸

1.2 继承的格式

//定义父类的名称（就是一个普通的类定义）
public class 父类名称{

}


//定义子类格式
public class 子类名称 extends 父类名称{

}

1.3 成员的变量的访问特点

• 在父子类继承关系当中，如果父子成员变量重名，那么创建子类对象的时候，访问有两种方式
  • 第一种：直接通过子类对象访问成员变量
    • 有限用子类的对象，没有再找爸爸
  • 第二种： 简介通过成员方法访问成员变量
    • 该方法属于谁，就优先用谁，没有再找爸爸

在子类中访问父类的重名的成员变量：

• 使用关键字super 用法：super.父类的成员变量

在子类中访问父类的重名的成员方法：

• 还是super

1.4 继承中的覆盖重写（Override）

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

注意：

• 创建的是子类对象，则优先调用子类的方法

• 必须保证名称相同，参数列表也相同（当然，是要在继承的条件下）

• @Override写在创建方法的代码前一行，用来检测下面的函数是否是重写

  • @Override
    	public void 方法名（参数）{
    		
    	}
    

• 子类方法的返回值必须小于等于父类方法的 返回值范围(例如：父类是int，那子类就不能是long)

• Java.lang Object类是所有类的公共最高父类（祖宗类）

• 子类方法的权限必须大于等于父类方法中的权限修饰符

  • public > projected > > private

作用：对函数的某些方法进行更新迭代

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

继承关系中，夫子类构造方法的访问特点

1. 子类构造的时候，先触发父类的构造函数，再触发子类的构造函数
   1. 即：子类构造方法中，有一个隐含的”super（）“语句（调用父类构造方法）
2. 通过super关键字，来调用父类重载部分（给父类的有参构造传参）（例，super(20);）
3. 只有子类构造方法中才能使用super（）；（调用父类的构造方法）
4. super();必须是子类构造函数中的第一句；

1.6 super关键字的三种用法

1. 在子类的成员方法中，访问父类的成员变量
2. 在子类的成员方法中，访问父类的成员方法
3. 在子类的构造方法中，访问父类的构造方法

1.7 this关键字的三种用法

1. super用来访问父类内容，this关键字用来访问子类内容
2. 在本类的成员方法中，访问本类中的另一个成员的方法
3. 在本类的构造方法中，访问本类的另一个构造方法（直接this（参数）就调用了）
   1. this（）调用必须是构造方法中的第一句
   2. super和this两周构造的调用，不能同时使用，因为他们都争第一

1.8 super 和 this 的内存图

1.9 Java继承的三个特点

1. Java是单继承的（即子类只能有一个直接父类，但是可以有爷爷）（避免了菱形问题）
2. Java可以多级继承（可以有爷爷，有祖宗）
3. 父类可以有多个子类（多态的达成的基础）

第二章 抽象类

2.1 抽象的概念

如果父类中的方法不确定如何实现，那么就是一个抽象方法

就比如，创建一个动物类，里面有一个吃东西方法，但是我无法定义吃什么，怎么吃

2.2 抽象的格式

抽象方法：加上abstract关键字，然后去掉大括号，直接分号结束；相当于是纯虚函数

抽象类： 抽象方法所在的类，必须是在抽象类中

注意: 子类必须对父类中的抽象方法进行重写（子类中去掉abstract关键字，然后补上方法体）

public abstract class Father {

    public abstract void eat();
}


//子类
package your_father;

public class Son extends Father{
    public void eat(){
        System.out.println("我是你爹");
    }
}

C++ 虚函数 == Java 普通函数

C++ 纯虚函数 == Java 抽象函数

C++ 抽象类 == Java 抽象类

C++ 虚基类 == Java 接口

2.3 抽象类的创建和使用

注意事项：

• 抽象类不能直接创建对象
• 抽象类中，可以有构造方法，是供子类创建对象的时候，初始化父类成员变量用的
• 抽象类中，不一定包含抽象方法，但是有抽象方法的类，一定是抽象类
• 抽象类的子类，必须重写抽象父类中的所有的抽象放法，否则，编译无法通过，除非，该子类也是抽象类

第三章 继承的综合案例

3.1 综合案例： 群主发普通红包

群主法普通红包。某群中有很多名成员，群主给成员发普通红包。

普通红包规则：

1. 群主的一笔金额，从群主余额中扣除，平均分成n等分，让成员领取。
2. 成员领取红包之后，将钱保存在他们自己的余额中。

请完成发红包操作：

3.2 案例分析

3.3 案例实现

User类中

package RedBag;

public abstract class User {

    private String name;
    private int money;

    public User() {
    }

    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;
    }

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

    //展示一下用户有多少钱
    public void show(){
        System.out.println("我叫"+ this.name + "我有" + this.money + "元");
    }
}

群主Manager类中

package RedBag;

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("余额不足");
        }else{
            //扣群主的余额，然后重新设置余额
            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;
    }
}

成员Member类中：

package RedBag;

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> redList){
        //从中随机抽取一个，然后拿给自己
        //随机获取一个索引编号
        int index = new Random().nextInt(redList.size());
        //根据索引，领取红包之后，将红包中的这个数据删除
        int delta = redList.remove(index);

        int money = super.getMoney();
        super.setMoney(money + delta);

    }
}

运行·的主函数main类中

package RedBag;

import java.util.ArrayList;

public class main {
    public static void main(String[] args) {
        Manager manager = new Manager("群主",300);
        Member one = new Member("one",0);
        Member two = new Member("two",0);
        Member three = new Member("three",0);
        Member four = new Member("four",0);
        manager.show();
        one.show();
        two.show();
        three.show();
        four.show();
        System.out.println("====================================");

        System.out.println("我他妈要发红包啦!");


        ArrayList<Integer> redList = manager.send(100,4);

        System.out.println("哈哈哈哈哈哈哈哈哈哈goooooooood!!!!!!");
        one.receive(redList);
        two.receive(redList);
        three.receive(redList);
        four.receive(redList);


        System.out.println("发完了,我穷了QAQ");
        manager.show();
        one.show();
        two.show();
        three.show();
        four.show();


    }
}

注意，四个类都在your_father包下

运行结果：

我叫群主我有300元
我叫one我有0元
我叫two我有0元
我叫three我有0元
我叫four我有0元
====================================
我他妈要发红包啦!
哈哈哈哈哈哈哈哈哈哈goooooooood!!!!!!
发完了,我穷了QAQ
我叫群主我有200元
我叫one我有25元
我叫two我有25元
我叫three我有25元
我叫four我有25元

Process finished with exit code 0

    manager.show();
    one.show();
    two.show();
    three.show();
    four.show();


}

}

注意，**四个类都在your_father包下**





运行结果：

```java
我叫群主我有300元
我叫one我有0元
我叫two我有0元
我叫three我有0元
我叫four我有0元
====================================
我他妈要发红包啦!
哈哈哈哈哈哈哈哈哈哈goooooooood!!!!!!
发完了,我穷了QAQ
我叫群主我有200元
我叫one我有25元
我叫two我有25元
我叫three我有25元
我叫four我有25元

Process finished with exit code 0