【2018-8-15】【day09】

• 继承是多态的前提，如果没有继承，就没有多态。
• 继承主要解决的问题就是：共性抽取。
• 父类：基类、超类。
• 子类：派生类。
• 继承关系的特点：
• 子类可以拥有父类的“内容”
• 子类可以拥有自己专有的内容。
• 继承父类：public class Teacher extends Employee{}
• 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，有两种方式：
• 直接通过子类对象访问成员变量。
• 间接通过成员方法访问成员变量。

package yap06;

public class Son extends Father{
    int num = 20;
    public void method(){
        int num = 30;
        System.out.println(num);//本方法内的num = 30；
        System.out.println(this.num);//子类的num = 20;
        System.out.println(super.num);// 父类的num = 10;
    }
}

1. 在父子类的继承关系当中，创建子类对象，访问成员方法原则：

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

注意：无论是成员方法还是成员变量，如果没有都是向上找，绝对不会向下找子类的。

重写（Override）/覆盖

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

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

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

注意：

1. 必须保证父子类之间方法的名称相同，参数列表也相同。
2. @Override  写在方法前面，用来检测是不是有效的正确覆盖重写。

这个注解就算不写，只要满足要求，也算覆盖重写。

【其实只是一个安全检测手段，平时最好写上】

1. 子类方法的返回值必须小于等于父类方法的返回值范围。

Java.lang.Object  java.lang.String就是Object的子类。

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

Public>protected>(default)>private

备注：（default）不是关键字，而是什么都不写，留空。

 

1.  

 子类构造方法当中有一个默认隐含的“super（）”调用。

所以先调用父类。

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

Super父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造。

总结：

子类必须调用父类构造方法，不写则赠送super（）；写了就用写的super。Super只能是一个，而且必须是第一个。

1. Super关键字：

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

1. This关键字：

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。//强调是本类的而不是父类（或其他类）的
3. 在本类的构造方法中，访问本类的另一个构造方法。

注意：this（…）调用也必须是构造方法的第一个语句，唯一一个。

Super和this两种构造调用，不能同时使用。

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

Java语言可以多级继承。

Java.lang.Object←A←B……

一个父类可以拥有很多个子类。

1. 抽象：如果父类当中的方法不确定如何进行{}方法实现，就应该是一个抽象方法。

（比如说图形的面积计算）

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

抽象方法所在的类必须是抽象类。

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

1. 不能直接创建new抽象对象。
2. 必须用一个子类继承父类。
3. 子类必须覆盖重写抽象父类当中所有的抽象方法。

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

1. 穿件子类对象。

1. 抽象类的注意事项：

1. 抽象类不能创建对象，只能创建抽象子类。
2. 抽象类中可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类一定是抽象类。
4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则编译器报错，除非该子类也是抽象类。

//发红包案例：
//父类：
package yap08;

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;
    }
}
//群主：
package yap08;

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

        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;
    }
}
//普通成员：
package yap08;

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);
    }
}
//运行：
package yap08;

import java.util.ArrayList;

public class MainRed {
    public static void main(String[] args) {
        Manager manager = new Manager("群主",100);
        Member member1 = new Member("A",0);
        Member member2 = new Member("B",0);
        Member member3 = new Member("C",0);

        manager.show();
        member1.show();
        member2.show();
        member3.show();

        System.out.println("--------------");
        ArrayList<Integer> redList = manager.send(20,3);
        member1.receive(redList);
        member2.receive(redList);
        member3.receive(redList);

        manager.show();
        member1.show();
        member2.show();
        member3.show();
    }
}