java自学之路六（继承）

继承

格式：

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

public class Employee {
    public void method() {
        System.out.println("方法执行！");
    }
}

public class Teacher extends Employee{
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.method();
    }
}

super

访问父类的重名变量

    public void method(){
        int age = 20;
        System.out.println(age);  //20
        System.out.println(this.age);  //25
        System.out.println(super.age);  //30
    }

重写

用@Override可以检测是否重写成功

注意：

子类方法的返回值，必须小于等于父类方法的返回值范围。java.lang.object是所有类的公共最高父类
子类方法的权限必须大于等于父类方法的权限修饰符。

public > protected > (default) > private，default不是关键字，而是什么都不写，留空。

设计原则

对于已经投入使用的类，尽量不要进行修改，推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容

父子类构造方法的访问特点

注意：

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

public class Father {
    public Father(){
        System.out.println("父类构造方法");
    }
}

public class Son extends Father {
    public Son(){
        System.out.println("子类构造方法");
    }

    public static void main(String[] args) {
        Son son = new Son();
    }
}

带参数的情况，用super调用父类重载的构造方法

    public Father(int age){
        System.out.println(age);
    }

    public Son(){
        super(13);
        System.out.println("子类构造方法");
    }

    public static void main(String[] args) {
        Son son = new Son();
    }

总结：子类必须调用父类构造方法，不写则赠送super()，写了则用写的指定super调用，必须在第一行。

this的用法

public class Daughter {
    public Daughter(){
        this(23);  // 本类的无参构造，调用本类的有参构造。
    }
    public Daughter(int n){
        
    }
}

在本类的成员方法中，访问本类的成员变量。
在本类的成员方法中，访问本类的另一个成员方法。
在本类的构造方法中，访问本类的另一个构造方法。（this（...）调用必须是构造方法的第一个语句，唯一一个。）

继承特性（重要）

java语言是单继承的

抽象方法

加上abstract关键字，去掉大括号，直接分号结束

抽象方法所在的类，必须是抽象类，在class之前写上abstract即可

public abstract class Animal {
//    抽象方法
    public abstract void eat();
    public void method(){
        
    }
}

如何使用抽象方法和抽象类

不能直接创建new抽象类对象。
必须用一个子类来继承抽象父类。
子类必须覆盖重写父类当中所有的抽象方法，去掉抽象方法的abstract关键字，然后不上方法体大括号。

创建子类对象进行使用

public abstract class Animal {
//    抽象方法
    public abstract void eat();
    public void method(){
        System.out.println("执行了animal方法");
    }
}

public class Dog extends Animal{
    public void eat(){
        System.out.println("小狗吃东西");
    }
}

public class Demo01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
}

如果继承了抽象类并没有重写所有方法，则还是个抽象类。

习题分红包

总结：

范型首字母大写

子类用get set获取父类属性

public class User {
    private String name;
    private double money;

    public User() {
    }

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

    public void show(){
        System.out.println("我是"+name+",有"+getMoney()+"元");
    }

    public String getName() {
        return name;
    }

    public double getMoney() {
        return money;
    }

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

    public void setMoney(double money) {
        this.money = money;
    }
}

public class Host extends User{
    public Host() {
    }

    public Host(String name, double money) {
        super(name, money);
    }

    public ArrayList<Double> send(double gift, int count){
        ArrayList<Double> moneyArray = new ArrayList<>();
        double money = super.getMoney() - gift;
        if(gift > getMoney()){
            System.out.println(getMoney());
            System.out.println("余额不足");
            return moneyArray;
        }
        for (int i = 0; i < count; i++) {
            if(i==count-1){
                double lastGift = gift;
                moneyArray.add(lastGift);
            }else{
                double perGift = new Random().nextDouble()*(Math.floor(gift));
                gift -= perGift;
                moneyArray.add(perGift);
            }
        }



        setMoney(money);
        return moneyArray;
    }
}

public class Customer extends User{
    public Customer() {
    }

    public Customer(String name, double money) {
        super(name, money);
    }


    public double receive(ArrayList<Double> moneyArray){
        int index = new Random().nextInt(moneyArray.size());
        double delta = moneyArray.get(index);
        moneyArray.remove(index);
        super.setMoney(super.getMoney() + delta);
        return delta;
    }
}

public class Demo02Test {
    public static void main(String[] args) {
        Host host = new Host();
        Customer customer1 = new Customer();
        Customer customer2 = new Customer();
        Customer customer3 = new Customer();
        Customer customer4 = new Customer();
        host.setName("群主");
        customer1.setName("二哈");
        customer2.setName("三哈");
        customer3.setName("四哈");
        customer4.setName("五哈");
        host.setMoney(29);
        customer1.setMoney(0);
        customer2.setMoney(0);
        customer3.setMoney(0);
        customer4.setMoney(0);


        ArrayList<Double> res = host.send(27, 4);
        host.show();
        double r1 = customer1.receive(res);
        customer1.show();
        double r2 = customer2.receive(res);
        customer2.show();
        double r3 = customer3.receive(res);
        customer3.show();
        double r4 = customer4.receive(res);
        customer4.show();
        System.out.println(r1 + r2 + r3 + r4);
    }
}