java-继承,super关键字,this关键字,抽象方法和抽象类,红包案例分析实现

继承的概述

继承主要解决的问题就是:

共性抽取

继承关系当中的特点:

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

继承的格式

在继承的关系中,子类就是一个父类.
例如:父类是员工,子类是讲师,那么讲师就是一个员工

定义父类的格式

public class 父类名称{
//…
}

定义子类的格式

public class 子类名称 extends 父类名称{
// …
}
创建一个员工父类

package demo1;

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

创建两个个子类,老师和助教

package demo1;

public class Teacher extends Employee {

}

package demo1;

public class Assistant extends Employee{

}

主程序

package demo1;

public class t1 {
    public static void main(String[] args) {
        //创建子类对象
        Teacher teacher = new Teacher();
        teacher.method();

        Assistant assistant = new Assistant();
        assistant.method();
        
    }
}

继承中成员变量的访问特点

创建Fu父类

package demo1;

public class Fu {
    int numFu = 10;

    int num = 200;
}

创建Zi子类

package demo1;

public class Zi extends Fu{
    int numZi = 20;

    int num = 100;
}

主程序

package demo1;

public class t1 {
    public static void main(String[] args) {
        //创建父类对象
        Fu fu = new Fu();
        System.out.println(fu.numFu); //只能使用父类的东西,没有任何的子类内容

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

        //父类子类成员变量重名情况
        System.out.println(zi.num); //100


    }
}

区分子类方法中重名的三种情况

1. 局部变量:直接写
2. 本类的成员变量:this.成员变量名
3. 父类的成员变量:super.成员变量名
   创建一个Fu父类

package demo1;

public class Fu {
    int num =10;
}

创建一个Zi子类

package demo1;

public class Zi extends Fu{
    int num =20;

    public void method(){
        int num = 30;
        System.out.println(num); //30局部变量
        System.out.println(this.num); //20本类成员变量
        System.out.println(super.num); //10父类成员变量
    }
}

主程序

package demo1;

public class t1 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();


    }
}

继承中成员方法的访问特点

在父子类的继承关系当中,创建子类对象,去访问成员方法的规则:

创建的对象是谁,就优先用谁,如果没有就向上找
创建一个Fu父类

package demo1;

public class Fu {
    public void methodFu(){
        System.out.println("父类执行");
    }
    public void method(){
        System.out.println("父类重名方法执行");
    }
}

创建一个Zi子类

package demo1;

public class Zi extends Fu{
        public void methodZi(){
            System.out.println("子类执行");
    }
    public void method(){
        System.out.println("子类重名方法执行");
    }
}

主程序

package demo1;

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

        zi.methodFu();
        zi.methodZi();

        //创建是谁,就优先用谁的方法
        zi.method(); //子类重名方法执行


    }
}

注意事项:

无论是成员方法还是成员变量,如果没有都是向上找父类绝对不会向下找子类的

继承中方法的覆盖重写概念

重写与重载的概念区分

重写概念:

在继承关系当中,方法的名称一样,参数列表也一样以后直接叫覆盖重写就行,更加容易理解

重载概念:

在继承关系当中,方法的名称一样,参数列表不一样

继承中方法的覆盖重写注意事项

1. 必须保证父子类之间方法的名称相同,参数列表也相同
   @Override:写在方法前面,用来检测是不是有效的正确覆盖重写
   与python的装饰器等同,非侵入式方法
2. 子类方法的返回值必须小于等于父类方法的返回值范围
3. 子类方法的权限必须大于等于父类方法的权限修饰符
   扩展:public > protected > (default) > private
   备注:(default)不是关键字default,而是什么都不写,留空
   创建Fu父类

package demo1;

public class Fu {
    //子类方法的权限必须要大于等于父类权限
     Object method(){
        return null;
    }
}

创建Zi子类

package demo1;

public class Zi extends Fu{
    //子类方法的返回值要小于等于父类方法的返回值范围
    @Override
    public String method(){ 
        return null;
    }
}

主程序

package demo1;

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

        zi.methodFu();
        zi.methodZi();

        //创建是谁,就优先用谁的方法
        zi.method(); //子类重名方法执行


    }
}

继承中方法的覆盖重写应用场景

继承使用类似与产生一个新的手机.第一已经投入使用的类,尽量不做修改,重新定义一个新的类,来重复利用其中的共性内容,并添加新的内容
创建一个Phone父类

package demo1;
//本来得老款手机
public class Phone {
    public void call(){
        System.out.println("打电话");
    }
    public void send(){
        System.out.println("发短线");
    }
    public void show(){
        System.out.println("显示号码");
    }

}

创建一个newPhone子类

package demo1;
//定义一个新手机,使用老是偶见作为父类
public class newPhone extends Phone{
    @Override
    public void show(){
        super.show(); //把父类的show方法拿来重复利用
        System.out.println("显示头像");
        System.out.println("显示姓名");
    }
}

主程序

package demo1;

public class t1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.call();
        phone.send();
        phone.show();


        newPhone newPhone = new newPhone();
        newPhone.call();
        newPhone.show();
        newPhone.send();
    }
}

继承中构造方法的访问特点

继承关系中,父子类构造方法的访问特点:

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

super关键字的三种用法

super关键字的用法有三种:

1. 在子类的成员方法中,访问父类的成员变量
2. 在子类的成员方法中访问父类的成员方法
3. 在子类的构造方法中访问父类的构造方法
   创建一个Fu父类

package demo1;

public class Fu {
    int num = 10;

    public void method(){
        System.out.println("父类方法");
    }

}

创建一个Zi子类

package demo1;

public class Zi extends Fu{
    int num = 20;

    public Zi(){
        super(); //在子类的构造方法中访问父类的构造方法
    }
    public void methodZi(){
        System.out.println(super.num); //父类中的num
    }
    public void method(){
        super.method(); //访问父类中的method
        System.out.println("子类方法");
    }

}

this关键字的三种用法

this关键字用来访问本类内容,与python的self等同,三种用法:

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

在第三种用法当中要注意:

A.this(…)调用也必须是构造方法的第一个语句
B.super和this1两种构造调用,不能同时使用
创建Fu父类

package demo1;

public class Fu {
    int num = 30;
}

创建Zi子类

package demo1;

public class Zi extends Fu {
    int num = 20;

    public Zi(){
        this(123);  //本类的无参构造,调用本类的有参构造
    }
    public Zi(int n){

    }

    public void showNum() {
        int num = 10;
        System.out.println(num);//局部变量
        System.out.println(this.num);//本类中的成员变量
        System.out.println(super.num); //父类中的成员变量
    }
    public void methodA(){
        System.out.println("AAA");
    }
    public void methodB(){
        //本类的成员方法中,访问本类的另一个成员方法
        this.methodA();
        System.out.println("BBB");
    }
}

super与this关键字内存图情况

java继承的三个特点

Java语言是单继承的:

一个类的直接父类只能有唯一一个

抽象的概念

到底抽象方法的使用场景是什么??

当父类定义的一个方法时,但是此方法不能确定方法体内容具体写什么的时候,例如:狗吃骨头,猫吃鱼,而父类动物就用抽象方法写一个共性的吃,到子类的时候分别对抽象方法进行实现,从而变为吃骨头,吃鱼.

抽象方法和抽象类的格式

抽象方法:

抽象方法就是加上abstract关键字,然后去掉大括号,直接分号结束

抽象类:

抽象方法所在的类,必须是抽象类才行.在class之前写上abstract即可
创业一个Animal类

package demo1;

public abstract class Animal {
    //这是一个抽象方法,代表吃东西,但是具体吃什么(大括号的内容)不确定
    public abstract void eat();

    //这是普通的方法
    public void normalMethod(){

    }
}

抽象方法和抽象类的使用

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

1. 不能直接创建new抽象类对象
2. 必须用一个子类来继承抽象父类
3. 子类必须覆盖重写抽象父类当中所有的抽象方法
   覆盖重写(实现):子类去掉抽象方法的abstract关键字,然后补上方法体大括号
4. 创建子类对象进行使用
   创建一个抽象父类Animal

package demo1;

public abstract class Animal {
    //这是一个抽象方法,代表吃东西,但是具体吃什么(大括号的内容)不确定
    public abstract void eat();
}

创建子类继承抽象父类,覆盖重写抽象方法

package demo1;

public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

主程序:创建子类对象进行使用

package demo1;

public class t1 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
    }
}

抽象方法个抽象类的注意事项

1. 抽象类不能创建对象
2. 一个抽象类不一定含有抽象方法,只要保证抽象方法所在的类是抽象类,即可
   这样没有抽象方法的抽象类,也不能直接创建对象,在一些特殊场景下有用途
3. 抽象类的子类,必须重写抽象类中所有的抽象方法.除非子类也是一个抽象类

发红包案例实现

抽象出来一个父类User,抽象出名字和余额

package demo1;

public class User {
    private String  name;
    private int balance;

    public User() {
    }

    public User(String name, int balance) {
        this.name = name;
        this.balance = balance;
    }
    //展示用户余额
    public void show(){
        System.out.println("我叫"+name+"我有多少钱:"+balance);
    }


    public String getName() {
        return name;
    }

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

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }


}

创建一个群主子类Manager

package demo1;

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

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

    public Manager(String name, int balance) {
        super(name, balance);
    }
    public ArrayList<Integer> send(int totaMoney,int count){
        ArrayList<Integer> redList = new ArrayList<>();
        int surpluseMoney = super.getBalance();
        if (totaMoney<surpluseMoney){
            super.setBalance(surpluseMoney-totaMoney);
            for (int i = 0; i < count; i++) {
                if (i ==count-1){
                    //把最后剩下的一点碎钱,包在最后一个红包里面
                    redList.add(totaMoney/count+totaMoney%count);
                }
                redList.add(totaMoney / count); //整除

            }

        }
        else {
            System.out.println("余额不足");
            return redList;
        }
        return redList;

    }
}

创建一个Member子类

package demo1;

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

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

    public Member(String name, int balance) {
        super(name, balance);
    }
    public void receive(ArrayList<Integer> redList){
        Random rnd = new Random();
        int index = rnd.nextInt(redList.size());
        int redMoney = redList.remove(index);
        int surplus = super.getBalance();
        super.setBalance(surplus+redMoney);
    }
}

主程序

package demo1;

import java.util.ArrayList;

public class t1 {
    public static void main(String[] args) {
        Manager manager = new Manager("群主",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
        //群主发红包了
        ArrayList<Integer> redList = manager.send(20, 3);
        one.receive(redList);
        two.receive(redList);
        three.receive(redList);

        manager.show(); //80
        one.show(); //8
        two.show(); //6
        three.show(); //6

    }
}