菜鸡学习day09_继承性&方法重写Override&继承的三个特征&抽象类抽象方法

菜鸡学习day09

package day09;
/*
继承性（共性抽取）
继承是多态的前提
子类会继承父类的变量和方法
父类
public class 父类名称{
}
子类
public class 子类名称 extends 父类名称{
}


若成员变量重名，则创建子类对象时，有两种访问方式：
1.直接通过子类对象访问成员变量
    等号左边是谁就优先用谁，向上最近
2.间接通过成员方法访问成员变量
    若调用的子类方法中有则优先子类
重名
局部变量    直接写
本类        this.变量名
父类        super.变量名

父子成员方法的访问
若重名，创建的对象是谁，则优先用谁，没有就向上找

重写Override（覆盖重写）
继承关系中，方法名称和参数列表都一样
与重载Overload区别：  重载的参数列表不一样
注：1.必须保证方法名称和参数列表都一样（参数名可不同）
    2.子类方法的返回值必须小于父类方法的返回值范围
    (Object类是所有类的公共最高父类)
    3.子类方法的权限必须大于等于父类方法的修饰符
    public > protected > （default）留空 > private
@Override 写在方法前，检查是否覆盖重写

保留继承旧类后，覆盖重写发展新功能

父子构造方法
子类构造方法中，无参默认有super调用，super（）
可通过super关键字来子类构造调用父类重载构造？？有参
super父类调用必须在子类构造方法中使用，且是第一个语句

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

this用法
1.在本类成员方法中，访问本类成员变量         this.num
2.在本类成员方法中，访问本类另一个成员方法    this.method()
3.在本类构造方法中，访问本类另一个构造方法    this(num);本类的无参构造调用本类的有参构造
                                                这里this也必须是第一个语句
                                                super和this不能同时使用
继承的三个特征
1.Java是单继承的（一个类的直接父类只有一个）
2.Java可以多级继承      （A-B-C）A是C的父类，但不是直接父类（B）
                       Object最高
3.父类可以有很多子类

抽象方法
如果父类的方法不能确定具体的方法体，则为抽象方法
格式：         public abstract void 抽象方法名();
创建抽象对象步骤
    1.所在类必须为抽象类（在class前面加abstract）
    2.不能直接创建抽象类对象，必须先用子类继承抽象父类，
    3.子类覆盖重写所有抽象方法（去掉抽象方法中的abstract，补上{}）
    4.创建子类对象进行使用
如果子类没法覆盖所有抽象方法，也为abstract
 */
public class D0901 {
    public static void main(String[] args) {
       //Fulei fu = new Fulei();//调用了父类构造方法
        Zilei zi = new Zilei();//先后调用了父类子类两个构造方法//若父为抽象类
        zi.method();//zi，且子类中有method，所以调用的是子类方法
        zi.method1();//覆盖重写成功
        zi.chouxiangfangfa();//调用抽象方法
    }
}

package day09;
//加上abstract 变成抽象类
public abstract class Fulei {
    int num = 1;

    public void method(){
        System.out.println("调用了父类方法method。");
    }
    public void method1(){
        int a = 100;
        System.out.println("覆盖重写失败");
    }

    public Fulei(int num){
        System.out.println("父类构造方法。");
    }
    public abstract void chouxiangfangfa();
}

package day09;

public class Zilei extends Fulei {
    int num = 3;
    public void method(){
        int num = 33;
        System.out.println("调用了子类方法method。");
        System.out.println(num);//局部
        System.out.println(this.num);//子类
        System.out.println(super.num);//父类
    }

    @Override//检查
    public void method1(){
        int b = 66;
        System.out.println("覆盖重写成功" + b);
    }

    public Zilei(){
        super(10);//通过super调用父类重载构造
        System.out.println("子类构造方法。");
    }

    @Override//检查
    public  void chouxiangfangfa(){

    };//继承抽象父类，覆盖重写
}

package day0902; 
//发红包，平均分配
import java.util.ArrayList;
import java.util.Scanner;

public class D0902 {
    public static void main(String[] args) {
        Fa one = new Fa("群主",100);
        Shou two = new Shou("成员1",0);
        Shou three = new Shou("成员2",0);
        Shou four = new Shou("成员3",0);

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

        Scanner sc = new Scanner(System.in);
        System.out.print("群主输入红包金额：");
        int famoney = sc.nextInt();
        System.out.print("群主输入红包个数：");
        int fenshu = sc.nextInt();

        ArrayList<Integer> list = one.fa(famoney,fenshu);
        two.shou(list);
        three.shou(list);
        four.shou(list);
        one.show();
        two.show();
        three.show();
        four.show();
    }
}

package day0902;

public class Yonghu {
    String name;
    int money;

    public Yonghu() {
    }

    public Yonghu(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 day0902;


import java.util.ArrayList;


public class Fa extends Yonghu {
    public Fa() {
    }

    public Fa(String name, int money) {
        super(name, money);
    }

    public ArrayList<Integer> fa(int famoney, int fenshu) {
       /* */
        ArrayList<Integer> list = new ArrayList<>();
        int yue = super.getMoney();
        if(famoney > yue){
            System.out.println("余额不足。");
        }
        else{
            for (int i = 0; i < fenshu - 1; i++) {
                list.add(famoney / fenshu);
            }
            list.add(famoney - famoney / fenshu * (fenshu - 1));
            System.out.println(list);
            super.setMoney(yue - famoney);
        }
        return list;
    }
}

package day0902;

import java.util.ArrayList;
import java.util.Random;

public class Shou extends Yonghu {
    public Shou() {
    }

    public Shou(String name, int money) {
        super(name, money);
    }

    public void shou(ArrayList<Integer> list){
        int yue = super.getMoney();
        Random ran = new Random();
        int num = ran.nextInt(list.size());
        super.setMoney(yue + list.remove(num));
    }
}