Java的继承性

文章目录

前言

一、继承的特点及定义的格式

二、覆盖重写（Override）

三、继承关系中，构造方法的访问

四、发红包实例

---

前言

Java的三个特性分别是：封装性，继承性，多态性

        继承是多态的前提，如果没有继承，就没有多态

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

---

一、继承的特点及定义的格式

（一）：继承的特点：

  1.子类可以拥有父类的“内容”

  2.子类还可以拥有自己专有的内容

  注：子类---->派生类，父类---->基类，超类。

          在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。

          例如父类是员工,子类是讲师,那么讲师就是一个员工。

（二）继承的格式

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

public class 父类名称{

        //......

}

• 定义子类的格式：

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

        //........

}

（三）继承注意事项：

在父类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种：

• 直接：直接通过子类对象访问成员变量（ 等号左边是谁，就优先用谁，没有则向上找）
• 间接：间接通过成员方法访问成员变量（该方法属于谁，就优先用谁，没有则向上找 ）

public class Fu {
    int numFu  = 10;
    int num = 400;

    public void methodFu(){
        //int num = 30;
        System.out.println(num);
    }
}

public class Zi extends Fu{
    int numZi = 20;
    int num = 800;

    public void methodZi(){
        int num = 30;
        //因为本类当中有num,所以这里用的是本类的num
        System.out.println(num);//局部变量
        System.out.println(this.num);//本类的成员变量
        System.out.println(super.num);//父类的成员变量
    }
}

public class Deom01Extends {
    public static void main(String[] args) {
        //创建父类对象
        Fu fu1 = new Fu();
        System.out.println(fu1.numFu);

        //创建子类对象
        Zi zi1 = new Zi();
        System.out.println(zi1.numFu);
        System.out.println(zi1.numZi);

        //等号左边是谁，就优先用谁
        System.out.println(zi1.num);

        //间接
        zi1.methodZi();//800
        zi1.methodFu();//400

        zi1.methodZi();
    }
}

二、覆盖重写（Override）

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

重写（Override）：方法的名称一样，参数列表【也一样】

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

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

（二）注意事项

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

        @Override：写在方法的前面，用来检测是不是有效的正确覆盖重写。

• 子类方法的返回值必须【小于等于】父类方法的返回值范围。

        提示：java.lang. object类是所有类的公共最高父类，java.lang.String就是object的子类

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

        提示：public > protected > （default）> private   【（default）不是关键字default，而是什么都不写】

三、继承关系中，构造方法的访问

（一）访问的特点

1. 子类构造方法当中有一个默认隐含"super()"调用，所有一定是先调用父类构造，后执行子类构造
2. 子类构造可以通过super关键字来调用父类重载构造
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造

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

public class Zi extends Fu{
    //无参构造方法
    public Zi(){
//        super();//在调用父类无参构造方法时赠送的
//        super(20);
//        this(20);
        System.out.println("子类构造方法：");
    }
    public Zi(int a){
        System.out.println("重载");
    }
    public void method(){
//        super();//错误写法！只有子类构造方法，才能调用父类构造方法
    }
}

 （二）super关键字的用法

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

（三）this关键字的用法

1. 在本类的成员方法中，访问本类的成员变量
2. 在本类的成员方法中，访问本类的另一种成员方法
3. 在本类的构造方法中，访问本类的构造方法

注意：this(...)调用也必须是构造方法的第一个语句，super和this两种构造调用，不能同时使用

public class Fu {
    int num = 10;
    public void method(){
        System.out.println("父类方法");
    }
}

public class Zi extends Fu{
    int num = 20;
    @Override
    public void method(){
        super.method();//调用了父类方法
        System.out.println("子类方法");
    }
    public void show(){
        int num = 30;
        System.out.println(num);//30
        System.out.println(this.num);//20
        System.out.println(super.num);//10
    }
}

public class Demo03test {
    public static void main(String[] args) {
        Zi zi1 = new Zi();

        zi1.show();
        zi1.method();
    }
}

四、发红包实例

（一）分析

（二）完成

（1）用户类

public class User {
    private String name;//私有化姓名
    private int money;//私有化余额
    public User() {
    }
    //显示一下当前用户有多少钱
    public void show(){
        System.out.println("我叫" + name + "有多少钱：" + money);
    }
    public User(String name, int money) {
        this.name = name;
        this.money = 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;
    }
}

 （2）群主类

public class Manger extends User{
    public Manger(){

    }

    public Manger(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);

        //发红包需要平分
        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;
    }
}

（3）普通成员类

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) {
        Manger manager  = new Manger("群主",100);

        Member one = new Member("A",0);
        Member two = new Member("B",0);
        Member three = new Member("C",0);

        manager.show();//100
        one.show();//0
        two.show();//0
        three.show();//0
        System.out.println("==============");
        //群主发20块钱，分3份
        ArrayList<Integer> redlist = manager.send(20,3);
        //三个普遍成员收红包
        one.receive(redlist);
        two.receive(redlist);
        three.receive(redlist);

        manager.show();//100 - 20 = 80
        // 6 6 8 随机分给3个人
        one.show();
        two.show();
        three.show();
    }
}

 （五）结果

---