Java中多态的体现之继承

package cn.j.day09.demo1;
//继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接
// 访问父类中的非私有的属性和行为。
/*!!Java语言是单继承的，类的直接父类只能有一个，而一个父类可以多个子类。
 * 子类格式：public class 子类{}
 * 父类格式：public class 父类名称{}
 *
 * */
//调用子类方法
public class demo1extends {
    public static void main(String[] args) {
        demo01son son = new demo01son();
        son.method();//父类方法执行了
        demo01other other =new demo01other();
        other.method();//父类方法执行了
    }
}

//父类代码
public class demo01father {
    public void method(){
        System.out.println("父类方法执行了");
    }
}
//子类 son 代码
public class demo01son extends demo01father{}
//子类 other 代码
public class demo01other extends demo01father {}

变量重名

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

• 1.直接通过子类对象访问成员变量
• 等号左边优先，没有则向上找；
• 2.直接通过成员方法访问成员变量（创建子类对象，访问成员方法的同理）
• 该方法属于哪个对象创建就优先谁，否则继续向上找

//调用子类方法
public class extendsfiled {
    public static void main(String[] args) {
        zi  zi= new zi();
        zi.method();
    }
}

/*运行结果
58
188
88
*/

//子类代码
public class zi extends fu{
    int num = 188;
    public void method() {
        int num = 58;
        System.out.println(num);//，method方法的局部变量
        System.out.println(this.num);//子类的成员变量
        System.out.println(super.num);//父类的成员变量
    }
}

//父类代码
public class fu {
    int num =88;
}

覆盖重写（Override）

/*覆盖重写注意事项
* 1. 必须保证父类和子类之间的方法名称相同，参数列表也相同。
* @override 写在前面可以检测是否正确覆盖重写。（可写可不写，不确定情况下最好写上）
* 2. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
* 例如:public > protected > (default) > private
* (default)不是关键字default 而是留空
* 3. 子类方法覆盖父类方法，返回值类型必须小于等于父类。
*例如：object是String的父类
*/
//调用子类代码
public class demo01override {
    public static void main(String[] args) {
        newPhone newP =new newPhone();
        newP.call();//可以打电话
        newP.cell();//可以发短信
        newP.show();//可以来电显示 可以显示名字  可以显示头像
        System.out.println("==========");
        phone ph =new phone();
        ph.call();//可以打电话
        ph.cell();//可以发短信
        ph.show();//可以来电显示
    }
}
//父类代码
public class phone {
    public void call(){
        System.out.println("可以打电话");
    }
    public void cell(){
        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("可以显示头像");
    }
}

super的三种用法：

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

//父类代码
public class super_3 {
    int num = 3;
    public void method(){
        System.out.println("父类方法运行了");
    }
}
//子类代码
//super的三种用法
public class super_1 extends super_3 {
    int num = 30;
    public super_1(){
        super();//子类的构造方法中，访问父类的构造方法
    }
    public void method() {
        System.out.println(num);//访问子类的成员变量
        System.out.println(super.num);//访问父类成员变量
        super.method();//访问父类方法
    }
}

abstract的使用方法

//格式：修饰符 abstract 返回值类型 方法名 (参数列表)；
/*注意事项
* 抽象方法：加上abstract关键字，然后去掉大括号，直接分号结束；
* 抽象类：抽象方法所在的类，必须是抽象类才行，在class前加上abstract
* 抽象类和抽象方法的使用：
* 1.不能直接用new创建抽象类对象；
* 2.必须用一个子类来继承抽象父类。子类必须覆盖重写抽象父类中的所有抽象方法，
* 覆盖重写实现的方式：去掉抽象方法的abstract
*/
//调用子类方法
public class extend {
    public static void main(String[] args) {
        demo01game game = new demo01game();
        game.play();//玩王者荣耀
    }
}
//子类代码
public class demo01game extends demo01abstract{
    public void play(){
        System.out.println("玩王者荣耀");
    }
}
//父类代码
public abstract class demo01abstract {
    //一个抽象的方法，不确定玩的内容；
    public abstract void play();
}

综合案例–发红包

//调用子类方法
import java.util.ArrayList;
public class MainRedpacket {
    public static void main(String[] args) {
        mannage mannage=new mannage("群主",100);
        menber one =new menber("成员1",0);
        menber two =new menber("成员2",0);
        menber three =new menber("成员3",0);
        mannage.show();
        one.show();
        two.show();
        three.show();
        System.out.println("=================");
        ArrayList<Integer> redlist =mannage.send(20,3);
        one.receive(redlist);
        two.receive(redlist);
        three.receive(redlist);
        mannage.show();
        one.show();
        two.show();
        three.show();
    }
}
// 父类代码
public class user {
    private String name;
    private int monney;

    public user() {
    }

    public user(String name, int monney) {
        this.name = name;
        this.monney = monney;
    }
    public void show(){
        System.out.println("名字："+name+",钱包有："+monney+"元");
    }
    public String getName() {
        return name;
    }

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

    public int getMonney() {
        return monney;
    }

    public void setMonney(int monney) {
        this.monney = monney;
    }
}
//子类 manager代码
import java.util.ArrayList;

public class mannage extends user {
    public mannage() {
    }
    public mannage(String name, int monney) {
        super(name, monney);//调用父类方法，获取name，monney
    }
    public ArrayList<Integer> send(int totalmoney, int count) {
        ArrayList<Integer> redlist = new ArrayList<>();
        int leftmoney = super.getMonney();
        super.setMonney(leftmoney - totalmoney);
        if (leftmoney < totalmoney) {
            System.out.println("余额不足");
            return redlist;
        }
        // super.setMonney(leftmoney - totalmoney);
        //发红包，
        int avg = totalmoney / count;
        int ys = totalmoney % count;
        for (int i = 0; i < count - 1; i++) {
            redlist.add(avg);
        }
        int last = avg + ys;
        redlist.add(last);
        return redlist;
    }
}
//子类 menber 代码
import java.util.ArrayList;
import java.util.Random;

public class menber extends user{
    public menber() {
    }

    public menber(String name, int monney) {
        super(name, monney);
    }
    public void receive(ArrayList<Integer> list){
        int index =new Random().nextInt(list.size());
        //拿抽到的钱
        int delta =list.remove(index);
        //原先的钱
        int money=super.getMonney();
        //加的钱
        super.setMonney(money+delta);
    }
}