Java语言入门||02_面向对象与常用类||day09_继承、super、this、抽象类

第一章继承

1.1 继承的概述

面向对象的三大特征：封装性，继承性，多态性
- ++继承是多态的前提++，如果没有继承，就没有多态
继承主要解决的问题就是：共性抽取【重点】
父类：也可以叫++基类，超类++
子类：也可以叫++派生类++
++继承关系当中的特点++：
1. 子类可以拥有父类的“内容”（可继承的）
2. 子类还可以拥有自己专有的内容

1.2 继承的格式

++在继承的关系中，“子类就是一个父类”++，也就是说子类可以被当做父类看待。
- 例如：父类是员工，子类是讲师，那么“讲师就是一个员工”
- ++关系：is-a++

定义父类的格式：（一个普通的类定义）

    public class 父类名称{
        //...
    }

定义子类的格式：

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

    定义一个父类：员工Employee.java
    public class Employee {
        public void method(){
            System.out.println("方法执行！！");
        }
    }
    
    //定义了一个员工的子类：讲师Teacher.java
    public class Teacher extends Employee {
    
    }
    
    //定义了员工另一个子类：助教Assistant.java
    public class Assistant extends Employee{
    
    }
    
    //主方法：Demo01Extends。java
    public static void main(String[] args) {
        //创建了一个子类对象
        Teacher teacher = new Teacher();
        //Teacher类虽然当中虽然什么的没写，但是会继承来自父类的method方法
        teacher.method();

        //创建另一个子类助教的对象
        Assistant assistant = new Assistant();
        assistant.method();
    }

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

子类父类继承关系中，如果成员变量不重名：（正常）：
- 创建++父类对象+±->++只能使用父类的东西，没有任何子类的内容++
- 创建++子类对象+±->++父类，本身的内容都有++
子类父类继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式：
1. 直接：通过子类对象访问成员变量
  - 等号左边是谁，就优先用谁，没有则向上找
2. 间接：通过成员方法访问成员变量
  - 该方法属于谁（方法定义在哪），就优先用谁，没有则向上找

    //定义一个父类：Fu.java
    public class Fu {
        int numFu = 10; //这里不封装为了方便
    
        int num = 100;
    
        public void methodFu(){
            //使用的是本类当中的，不会向下找子类的
            System.out.println(num);
        }
    }
    //定义一个子类：Zi.java
    public class Zi extends Fu {
        int numZi = 20;
    
        int num = 200;
    
        public void methodZi(){
            //因为本类当中有num，所以这里用的是本类的num
            System.out.println(num);
        }
    }
    //主方法：Demo01ExtendsField
    public static void main(String[] args) {
        Fu fu = new Fu();   //创建父类对象
        System.out.println(fu.numFu);   //只能使用父类的东西，没有任何子类的内容

        Zi zi = new Zi();
        System.out.println(zi.numFu);
        System.out.println(zi.numZi);
        System.out.println("==========");
        //等号左边是谁，就优先用谁
        System.out.println(zi.num); //优先子类200
        System.out.println("==========");

        //这个方法是子类的，优先用子类的，没有再向上找
        zi.methodZi();  //200
        //这个方法是在父类当中定义的，但是这个方法属于父类
        zi.methodFu();  //100

    }

1.4 区分子类方法中++重名++的三种变量

子类方法的局部变量：->直接写局部变量名
子类的成员变量：------>this.成员变量名
父类的成员变量：------>super.成员变量名

    //定义一个父类：Fu.java
    public class Fu {
        int num = 10;   //父类的成员变量
    }
    //定义一个子类：Zi.java
    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，父类的成员变量
        }
    }
    //主方法：Demo01ExtendsField.java
    public class Demo01ExtendsField {
        public static void main(String[] args) {
            Zi zi = new Zi();
            zi.method();
        }
    }

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

在父子类的继承关系当中，创建子类对象，访问成员方法（重名等）的规则：
1. 创建的对象是谁，就优先用谁，如果没有则向上找

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

1.6 继承中方法的覆盖重写—概念与特点

重写(Override)：
- 概念：在继承关系当中，方法的名称一样，参数列表也一样
重写(Override)和重载(Overload)区别:
- 重写(Override)：方法的名称一样，参数列表也一样
  - 也叫：覆盖，覆写————>一般称呼：覆盖重写
- 重载(Overload)：方法的名称一样，参数列表不一样
方法的覆盖重写特点：创建的是子类对象，则优先用子类方法（方法覆盖重写的时候，++new的是谁用的就是谁++）

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

方法覆盖重写的注意事项：

必须保证父子类之间++方法的名称相同，参数列表也相同++。
- @Override：写在方法前面，用来安全检测是不是有效的正确覆盖重写。————>注解，不叫注释
- 这个注解就算不写，只要满足要求，也是正确的方法覆盖重写
++子类方法的返回值++必须【小于等于】++父类方法的返回值范围++
- 扩展提示：++java.lang.Object类++是所有类的公共最高父类（++祖宗类++），java.lang.String就是Object的子类
- 父类：Object，子类：String（true）
- 父类：String，子类：Object（false）
++子类方法的权限++必须【大于等于】++父类方法的权限修饰符++
- 扩展提示：public > protected > (default) > private
- 注：(default)不是关键字default，而是什么都不写，留空
  - int num = 0;就是(default)

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

设计原则：
- 对于已经投入使用的类，尽量不要进行修改，推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新的内容
- 继承就是上面设计原则的体现

注：覆盖重写快捷方式子类中如果要覆盖重写父类某方法，直接写方法的名字然后根据提示回车
- 父类：public void show(){}
- 子类：show
注：覆盖重写时把父类的方法拿过来重复利用
- super.show();
- 这样就不用在写父类方法中重复的内容

    //本来的老款手机（定义的父类：Phone.java）
    public class Phone {
    
        public void call(){
            System.out.println("打电话");
        }
        public void send(){
            System.out.println("发短信");
        }
        public void show(){
            System.out.println("显示号码");
        }
    }
    //定义一个新手机，使用老手机作为父类(定义的子类：NewPhone.java)
    public class NewPhone extends Phone {
        @Override
        public void show() {
            //System.out.println("显示号码");
            super.show();
            System.out.println("显示姓名");
            System.out.println("显示头像");
        }
    }
    //主方法:Demo01Phone
    public static void main(String[] args) {
        //老款手机对象
        Phone phone = new Phone();
        phone.call();
        phone.send();
        phone.show();
        System.out.println("==========");
        //新款手机对象
        NewPhone newPhone = new NewPhone();
        newPhone.call();
        newPhone.send();
        newPhone.show();
    }

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

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

子类构造方法当中有一个默认隐含的“super()”调用，所以一定是==++先++调用的父类构造，后执行的子类构造==。
- super(); //在调用父类无参构造方法(不写编译器赠送)
子类构造可以通过super关键字，来调用父类++重载构造++。

super的父类构造调用，必须是子类构造方法的第一个语句,不能一个子类构造调用多次super构造【重点】

子类构造当中只能写一个super构造
super()方法必须写到第一个

    public class Zi {
        public Zi(){    //子类构造方法
            System.out.println("子类的无参构造");//错，因为super();必须写到第一个
            super();    //调用父类无参构造方法
            //super(10);  //调用父类有参构造方法
            //上面两个只能选一个来写
        }
    }

总结：
- 子类必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用，super只能写一个，还必须是第一个

    //定义了一个父类：Fu.java
    public class Fu {

        public Fu(){
            System.out.println("父类无参构造");
        }
    
        public Fu(int num){
            System.out.println("父类有参构造方法!");
        }
    }
    //定义了一个子类：Zi.java
    public class Zi extends Fu {

        public Zi(){
            //super();    //在调用父类无参构造方法(不写编译器赠送)
            super(10);  //在调用父类重载的构造方法
            System.out.println("子类无参构造方法!");
        }
    
        public void method(){
            //super();    //错误！，，只有子类构造方法才能调用父类构造方法
        }
    }
    //主函数Demo01Constructor.java
    public class Demo01Constructor {
        public static void main(String[] args) {
            Zi zi = new Zi();
    
        }
    }
    //结果是：
        父类有参构造方法!
        子类无参构造方法!

第二章 super关键字(用来访问父类内容)

2.1 super关键字的三种用法

在子类的成员方法中，访问父类的成员变量
在子类的成员方法中，访问父类的成员方法
在子类的构造方法中，访问父类的构造方法(构造中：super.();错–>super(123);对)

    //定义一个父类：Fu.java
    public class Fu {

        int num = 10;
    
        public void method(){
            System.out.println("父类方法");
        }
    }
    //定义一个子类：Zi.java
    public class Zi extends Fu {

        int num = 20;
    
        public Zi(){
            super();    //默认不写也行
        }
    
        public void methodZi(){
            System.out.println(num);
            System.out.println(super.num);  //父类当中的
        }
    
        public void method(){
            super.method(); //访问父类的成员方法
            System.out.println("子类方法");
        }
    }

第三章 this关键字(用来访问本类内容)

3.1 this关键字的三种用法

super关键字(用来访问父类内容),this关键字(用来访问本类内容),用法也有三种：
1. 在本类的成员方法中，访问本类的成员变量
2. 在本类的成员方法中，访问本类的另一个成员方法
3. 在本类的构造方法中，访问本类的另一个构造方法(构造中：this.();错–>this(123);对)
  - 注：this(…)调用也必须是构造方法的第一个语句,唯一一个
  - 注：super和this两种构造调用，不能同时使用–>因为都要是第一个语句，切唯一的
  - 一个类中，无参可以调用本类有参，本类有参可以再调用父类super();构造。

    //定义一个父类：Fu.java
    public class Fu {
        public Fu(){
            
        }
        
        int num = 30;
    }
    //定义一个子类：Zi.java
    public class Zi extends Fu {

        public Zi(){
            this(123);  //本类的无参构造，调用本类的有参构造
            //this(123, 234);
        }
    
        public Zi(int n){
            this(1, 2); //调用本类的双参构造
        }
    
        public Zi(int n, int m){
            super();    //调用父类的无参构造
        }
    
        int num = 20;
    
        public void showNum(){
            int num = 10;
            System.out.println(num);    //局部变量10
            System.out.println(this.num);   //本类成员变量20
            System.out.println(super.num);  //父类的成员变量30
        }
    
        public void methodA(){
            System.out.println("AAA");
        }
    
        public void methodB(){
            this.methodA();
            System.out.println("BBB");
        }
    }

3.2 super与this关键字图解

3.3 Java继承的三个特点

Java语言是单继承的。

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

    class A{
        
    }
    class B extends A{
        //对
    }
    class C{
        
    }
    class D extends A, C{
        //错
    }

Java语言可以多级继承
- 我有一个父亲，我父亲还有一个父亲，也就是爷爷
- Java继承机构的最顶端的人：java.lang.Object
```
    calss A{
        
    }
    class B extends A {
        //对
    }
    class C extends B {
        //对
    }
```
一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类
- 可以有很多的兄弟姐妹，生二胎
```
    class A {
        
    }
    class B extends A {
        //对
    }
    class C extends A {
        //对
    }
```

总结图：

第四章抽象类

4.1 抽象类的概念

概念：
- 如果父类当中的方法不确定如何进行{}方法体的实现，那么这就应该是一个抽象方法。

4.2 抽象方法和抽象类的格式

抽象方法：就是直接abstract关键字，然后去掉大括号，直接分号结束
- 注：下面表示一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定
```
    //例
    public abstract void eat();
```

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

注：抽象类中也可以定义普通的成员方法

    public abstract class Animal{
        
        //true
        public abstract void eat();
        //true
        public void normalMethod(){
            
        }
    }

    //定义一个抽象类：Animal.java
    public abstract class Animal {

        //抽象方法
        public abstract void eat();
        
        //普通成员方法
        public void normalMethod(){
            
        }
    }

4.3 抽象方法和抽象类的使用

不能直接创建new抽象类对象
必须用一个子类来继承抽象父类
子类必须覆盖重写抽象父类当中++所有的++抽象方法
- 覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号
创建子类对象进行使用

    //定义一个抽象类：Animal.java
    public abstract class Animal {
    
        //抽象方法
        public abstract void eat();
    
        //普通成员方法
        public void normalMethod(){
    
        }
    }
    //定义一个子类：Cat.java
    public class Cat extends Animal {

        @Override
        public void eat(){
            System.out.println("猫吃鱼");
        }
    }
    //主方法：DemoMain.java
    public static void main(String[] args) {
        //错，不能直接创建抽象类对象
        /*Animal animal = new Animal() {
        }*/
        Cat cat = new Cat();
        cat.eat();
    }

4.4 抽象方法和抽象类的注意事项

注：一个抽象类不一定含有抽象方法，只要保证抽象方法所在的类是抽象类，即可。
- 这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途（今后：设计模式下的适配器模式会用到）
注：子类可以用alt + enter来快速生成抽象方法
注意事项：

    //定义一个最高的抽象父类：Animal.java
    public abstract class Animal {
    
        public abstract void eat();
        public abstract void sleep();
    }
    //定义一个子类也是一个抽象类
    public abstract class Dog extends Animal {
    
        @Override
        public void eat() {
            System.out.println("狗吃骨头");
        }
    
        //public abstract void sleep();
    }
    //定义一个子类的实现类：DogGolden.java
    public class DogGolden extends Dog{
    
        @Override
        public void sleep() {
            System.out.println("呼呼呼");
        }
    }
    //定义另一个子类的实现类：Dog2Ha.java
    public class Dog2Ha extends Dog{
    
        @Override
        public void sleep() {
            System.out.println("哈哈哈");
        }
    }
    //主函数：DemoMain.java
    public static void main(String[] args) {
        //Animal animal = new Animal(); //错误

        //Dog dog = new Dog();    //错误,这也是抽象类

        Dog2Ha dog2Ha = new Dog2Ha();   //这是普通类，可以new对象
        dog2Ha.sleep();
        dog2Ha.eat();
        System.out.println("========");
        DogGolden dogGolden = new DogGolden();
        dogGolden.sleep();
        dogGolden.eat();
    }

4.5 day09综合案例：发红包_分析

题目：
分析：

4.6 day09综合案例：发红包_实现

    //用户类：父类——User.java
    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;
        }
    }
    //群主类：子类——Manager.java
    public class Manager extends User{
    
        public Manager(){
            //super();  //默认赠送
        }
    
        public Manager(String name, int money) {
            super(name, money); //调用父类的构造方法，就能把参数传入到父类的肚子里
        }
    
        public ArrayList<Integer> send(int totalMoney, int count){  //一共发多少钱，分成几份
            //1需要一个集合，用来存储若干个红包的金额
            ArrayList<Integer> listRed = new ArrayList<>();
    
            //2看一下群主自己有多少钱
            int leftMoney = super.getMoney();   //群主当前的余额
            if(totalMoney > leftMoney){
                System.out.println("余额不足");
                return listRed; //返回一个空集合
            }
    
            //3扣钱，其实就是重新设置余额
            super.setMoney(leftMoney - totalMoney);
    
            //4发红包需要拆分成count份
            int avg = totalMoney / count;   //整数除法直接取整
            int mod = totalMoney % count;   //余数，也就是甩下的零头
    
            //5把红包一个一个塞到集合当中
            for (int i = 0; i < count - 1; i++) {   //留出来最后一个来存储零头
                listRed.add(avg);
            }
    
            //6除不开的零头，包在最后一个红包当中
            int last = avg + mod;
            listRed.add(last);
    
            return listRed;
        }
    }
    //普通成员类：子类——Member.java
    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);
    
        }
    }
    //主方法——MainRedPackage.java
    public static void main(String[] args) {
        Manager manager = new Manager("群主", 100);

        Member one = new Member("成员A", 0);
        Member two = new Member("成员B", 10);
        Member three = new Member("成员C", 20);

        //显示一下余额
        manager.show();
        one.show();
        two.show();
        three.show();
        System.out.println("==============");

        //群主总共发了20块钱，分成了三份
        ArrayList<Integer> listRed = manager.send(20, 3);
        //三个普通成员去收红包
        one.receive(listRed);
        two.receive(listRed);
        three.receive(listRed);

        manager.show();
        one.show();
        two.show();
        three.show();
    }

狂野小白兔

发布了42 篇原创文章 · 获赞 6 · 访问量 1141

私信关注

Java语言入门||02_面向对象与常用类||day09_继承、super、this、抽象类

第一章 继承

1.1 继承的概述

1.2 继承的格式

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

1.4 区分子类方法中++重名++的三种变量

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

1.6 继承中方法的覆盖重写—概念与特点

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

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

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

第二章 super关键字(用来访问父类内容)

2.1 super关键字的三种用法

第三章 this关键字(用来访问本类内容)

3.1 this关键字的三种用法

3.2 super与this关键字图解

3.3 Java继承的三个特点

第四章 抽象类

4.1 抽象类的概念

4.2 抽象方法和抽象类的格式

4.3 抽象方法和抽象类的使用

4.4 抽象方法和抽象类的注意事项

4.5 day09综合案例：发红包_分析

4.6 day09综合案例：发红包_实现

猜你喜欢

第一章继承

第四章抽象类