3.1_8 JavaSE入门 P7 【面向对象】继承&多态

已于 2022-04-29 09:16:50 修改
阅读量3.5k 收藏
点赞数
分类专栏： 三.Java 文章标签： java
于 2021-03-25 18:07:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43529621/article/details/115209518
版权

相关链接

目录

Part7 【面向对象】继承&多态

1 继承

  • 继承的概述

    • 多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需在定义这些属性和行为，只要继承那个类(extends)即可
    • 单独的这个类称为父类，基类或者叫超类，多个类可以称为子类或者派生类
    • 有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员

  • 实现继承的方式

    • 通过extends关键字可以实现类与类的继承

    • 格式：public class 子类名 extends 父类名{}

案例代码一  【1.a 人类父类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 人类父类   继承的概述
 *
 * 标准人类
 *
 * 继承的格式：
 * 		public class 子类名 extends 父类名 {}
 *
 * 继承的好处：
 * 		A:提高了代码的复用性
 * 		B:提高了代码的维护性
 * 		C:让类与类之间产生了关系，是多态的前提
 *
 * 继承的弊端：
 * 		让类与类之间产生了关系，也就让类的耦合性增强了。
 *
 * 		开发原则：高内聚，低耦合。
 * 			内聚：就是自己完成某件事情的能力
 * 			耦合：类与类的关系
 */
public class Demo1POJO {
    private String name;
    private int age;

    /**
     * @introduction 无参构造
     */
    public Demo1POJO() {
    }

    /**
     * @introduction 全参构造
     * @param name
     * @param age
     */
    public Demo1POJO(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

案例代码一  【1.a.1 人类子类–学生类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 人类子类——学生类  继承的概述
 *
 * 标准人类
 *
 * 继承的格式：
 * 		public class 子类名 extends 父类名 {}
 *
 * 继承的好处：
 * 		A:提高了代码的复用性
 * 		B:提高了代码的维护性
 * 		C:让类与类之间产生了关系，是多态的前提
 *
 * 继承的弊端：
 * 		让类与类之间产生了关系，也就让类的耦合性增强了。
 *
 * 		开发原则：高内聚，低耦合。
 * 			内聚：就是自己完成某件事情的能力
 * 			耦合：类与类的关系
 */
public class Demo1POJOExtendStudent extends Demo1POJO {
    public Demo1POJOExtendStudent() {
    }

    public void study() {
        System.out.println("学生要好好学习");
    }
}

案例代码一  【1.a.2 人类子类–老师类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 人类子类——老师类  继承的概述
 *
 * 标准人类
 *
 * 继承的格式：
 * 		public class 子类名 extends 父类名 {}
 *
 * 继承的好处：
 * 		A:提高了代码的复用性
 * 		B:提高了代码的维护性
 * 		C:让类与类之间产生了关系，是多态的前提
 *
 * 继承的弊端：
 * 		让类与类之间产生了关系，也就让类的耦合性增强了。
 *
 * 		开发原则：高内聚，低耦合。
 * 			内聚：就是自己完成某件事情的能力
 * 			耦合：类与类的关系
 */
public class Demo1POJOExtendTeacher extends Demo1POJO {
    public void teach() {
        System.out.println("老师要好好讲课");
    }
}

案例代码一  【1.b 人类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 人类的测试类 继承的概述
 *
 * 标准人类
 *
 * 继承的格式：
 * 		public class 子类名 extends 父类名 {}
 *
 * 继承的好处：
 * 		A:提高了代码的复用性
 * 		B:提高了代码的维护性
 * 		C:让类与类之间产生了关系，是多态的前提
 *
 * 继承的弊端：
 * 		让类与类之间产生了关系，也就让类的耦合性增强了。
 *
 * 		开发原则：高内聚，低耦合。
 * 			内聚：就是自己完成某件事情的能力
 * 			耦合：类与类的关系
 */
public class Demo1 {
    public static void main (String[] args){
        Demo1POJOExtendStudent student = new Demo1POJOExtendStudent();
    }
}

1.1 继承的好处和弊端

  • 继承的好处

    • A： 提高了代码的复用性，多个类相同的成员可以放到同一个类中;
    • B： 提高了代码的维护性，如果功能的代码需要修改，修改一处即可;
    • C：让类与类之间产生了关系，是多态的前提，好处的第三点同时也是继承的弊端。

  • 继承的弊端

    • A： 类与类之间产生了关系，让类的耦合性增强了
      • 开发原则：高内聚低耦合
        • 内聚：自己完成某件事情的能力
        • 耦合：类与类的关系

1.2 Java中继承的特点

  • Java中只支持单继承，不支持多继承

    • 一个类只能有一个父类，不可以有多个父类
    • public class Son extends Father{} // ok
    • public class Son extends Father,GrandFather // Error

  • Java中类支持多层继承(继承体系)

    • Public class GrandFather{}
    • Public class Father extends GrandFather{}
    • Public class Son extends Father{}

案例代码二   Java中继承的特点 【2.a 人类爷爷类】

package com.groupies.base.day07;
/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introductoin 人类爷爷类 Java中单继承以及多级继承
 *
 * Java中只支持单继承，不支持多继承
 *      一个类只能有一个父类，不可以有多个父类
 *      public class Son extends Father{}  // ok
 *      public class Son extends Father,GrandFather // Error
 *
 *
 * Java中类支持多层继承(继承体系)
 *      Public class GrandFather{}
 *      Public class Father extends GrandFather{}
 *      Public class Son extends Father{}
 */
public class Demo2POJOGrandFather {
    public void grandFatherSay(){
        System.out.println("爷爷都是从孙子熬过来的");
    }
}

案例代码二   Java中继承的特点 【2.a.1 人类父类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类父类   Java中类支持多层继承,不支持多继承
 *
 * Java中只支持单继承，不支持多继承
 *      一个类只能有一个父类，不可以有多个父类
 *      public class Son extends Father{}  // ok
 *      public class Son extends Father,GrandFather // Error
 *
 *
 * Java中类支持多层继承(继承体系)
 *      Public class GrandFather{}
 *      Public class Father extends GrandFather{}
 *      Public class Son extends Father{}
 */
public class Demo2POJOExtendFather extends Demo2POJOGrandFather{
    public void fatherSay(){
        System.out.println("爸爸都是从儿子走过来的");
    }
}

案例代码二   Java中继承的特点 【2.a.1.1 人类子类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类子类  Java中类支持多层继承
 *
 * Java中只支持单继承，不支持多继承
 *      一个类只能有一个父类，不可以有多个父类
 *      public class Son extends Father{}  // ok
 *      public class Son extends Father,GrandFather // Error
 *
 *
 * Java中类支持多层继承(继承体系)
 *      Public class GrandFather{}
 *      Public class Father extends GrandFather{}
 *      Public class Son extends Father{}
 */
public class Demo2POJOExtendSon extends Demo2POJOExtendFather{
    public static void main(String[] args) {
        Demo2POJOExtendSon son = new Demo2POJOExtendSon();
        son.fatherSay();//爸爸都是从儿子走过来的
        son.grandFatherSay();//爷爷都是从孙子熬过来的
    }
}

//Java中类只支持单继承，不支持多继承
//public class Demo2POJOExtendSon1 extends Demo2POJOExtendFather,Demo2POJOGrandFather{

1.3 Java继承中成员变量的特点

From No.3.6_8 【JVM原理】 JVM与数据类型 (未完成)

  • A.局部变量
  • a.定义位置：定义在局部范围中，如：函数内，语句内等;
  • b.初始值：无,先定义,赋值后才能使用;
  • c.调用方式：- - -
  • d.作用域： 只在所属的区域有效;
  • e.物理存储： 存储在 虚拟机栈(JVM Stack) 中（栈内存分为：虚拟机栈和本地方法栈）;
    • 变量名 和 值 都在虚拟机栈(JVM Stack)的栈帧(Stack Frame) 的 局部变量表(Local Variable Table) 中;
  • f.生命周期：与方法共存亡，随着方法的调用而存在，随着方法调用完毕自动回收释放;
  • B.成员变量（别名：实例变量）
  • a.定义位置：在类中,方法外;
  • b.初始值：有默认初始化值;
  • c.调用方式：对象调用;
  • d.作用域：在整个类中都可以被访问;
  • e.物理存储：
    • 对象的实例存储在 堆内存(Heap) 中。堆内存速度慢、成本低、空间较大。这个堆内存会有一个内存地址;
    • 对象的引用存储在 ==虚拟机栈(JVM Stack)中
  • f.生命周期：与对象共存亡，随着对象的创建而存在，随着对象被回收而释放;
  • C.静态变量（别名：类变量）
  • a.定义位置：由staic修饰的，在类中,方法外;
  • b.初始值：有默认初始化值;
  • c.调用方式：对象调用，类名调用;
  • d.作用域：全局中都能使用、被所有对象所共享;
  • e.物理存储：存储在 方法区(Method Area) 的 静态域(Static Field) 中;
  • f.生命周期：与类共存亡，随着类的加载而存在，随着类的消失而消失。
  • 成员变量名称不一样，使用的时候非常简单
  • 成员变量名称一样的情况：
    • 在子类中访问变量：（就近原则）
      • 在方法的局部范围找，如果有就使用
      • 在子类的成员范围找，如果有就使用
      • 在父类的成员范围找，如果有就使用
      • 如果还找不到 就报错

在这里插入图片描述

案例代码三  Java继承中成员变量的特点 【3.a 父类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类父类   Java继承中成员变量的特点
 *
 * Java继承中成员变量的特点：
 * 		A:成员变量名称不一样，使用的时候非常简单。
 * 		B:成员变量名称一样的情况
 * 			在子类方法中访问变量：
 * 				a:在方法的局部范围找，如果有就使用
 * 				b:在子类的成员范围找，如果有就使用
 * 				c:在父类的成员范围找，如果有就使用
 * 				d:如果还找不到，就报错
 * 			就近原则。
 */
public class Demo3POJOFather{
    //为了演示案例的方便，这里我们使用public修饰了成员变量，实际开发中，修饰符使用private
    //年龄
    public int age = 45;//c:在父类的成员范围找，如果有就使用
}

案例代码三  Java继承中成员变量的特点 【3.a.1 子类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类子类   Java继承中成员变量的特点
 *
 * Java继承中成员变量的特点：
 * 		A:成员变量名称不一样，使用的时候非常简单。
 * 		B:成员变量名称一样的情况
 * 			在子类方法中访问变量：
 * 				a:在方法的局部范围找，如果有就使用
 * 				b:在子类的成员范围找，如果有就使用
 * 				c:在父类的成员范围找，如果有就使用
 * 				d:如果还找不到，就报错
 * 			就近原则。
 */
public class Demo3POJOExtendSon extends Demo3POJOFather {
    //身高
    public int height = 170;
    //年龄
    public int age = 20;//b:在子类的成员范围找，如果有就使用

    public void show() {
        System.out.println(height);
        System.out.println(age);
    }

    public void printAge() {
        int age = 10;//a:在方法的局部范围找，如果有就使用
        System.out.println(age);
    }
}

案例代码三  Java继承中成员变量的特点 【3.b 父类和子类的测试类】

package com.groupies.base.day07;
/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类测试类  Java继承中成员变量的特点
 * Java继承中成员变量的特点：
 * 		A:成员变量名称不一样，使用的时候非常简单。
 * 		B:成员变量名称一样的情况
 * 			在子类方法中访问变量：
 * 				a:在方法的局部范围找，如果有就使用
 * 				b:在子类的成员范围找，如果有就使用
 * 				c:在父类的成员范围找，如果有就使用
 * 				d:如果还找不到，就报错
 * 			就近原则。
 */
public class Demo3 {
    public static void main(String[] args) {
        Demo4POJOExtendSon s = new Demo4POJOExtendSon();
        /*
            10
            20
            45
         */
        s.printAge();//d:如果经过a,b,c还找不到，就报错
    }
}

2 super关键字以及继承中的方法重写

2.1 super关键字的概述和使用

  • super的用法和this很像

    • this代表本类对象的引用
    • super代表父类存储空间的标识（可以理解为父类对象引用）
    • super（）且放在第一行 ； 目的是在初始化当前对象时，先保证了父类对象先初始化 。

  • 用法（this和super均可如下使用）

    • 访问成员变量
      • this.成员变量
      • super.成员变量
    • 访问构造方法
      • this(…)
      • super(…)
    • 访问成员方法
      • this.成员方法()
      • super.成员方法()

  • 构造方法中this()或者super()要放在第一行

    • 在构造函数中，如果你不指定 构造器之间的调用关系 ，那么编译器会给你加上 super（）且放在第一行 ； 目的是在初始化当前对象时，先保证了父类对象先初始化 。所以，你指定了构造函数间的调用，那么this（）必须在第一行，以保证在执行任何动作前，对象已经完成了初始化。
    • 构造函数只能被构造函数调用，因为对象只会初始化一次。
    • this()和super()这样的方法被称为构造方法，顾名思义，他的作用就是在JVM堆中构建出一个指定类型的对象，如果你调用了两个这种形式的方法，岂不是代表着构建出了两个对象。
    • 同理，为了避免构建出两个对象这种问题的出现，Java在编译时对这种情况做了强校验， 用户不能再同一个方法内调用多次this()或super()，同时为了避免对对象本身进行操作时，对象本身还未构建成功(也就找不到对应对象),所以对this()或super()的调用只能在构造方法中的第一行实现，防止异常。
    • 在普通的成员方法中，如果调用super()或者this()，你是想要重新创建一个对象吗？抱歉Java为了保证自身对象的合理性，不允许你做这样的操作。

案例代码四  super关键字的概述和使用 【4.a 父类】

package com.groupies.base.day07;
/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类父类   super关键字的概述
 *
 * super和this的用法很像：
 * 		this:代表本类对象的引用
 * 		super:代表父类的存储空间(可以理解为代表父类对象的引用)
 *
 * 用法：
 * 		访问成员变量：
 * 			this.成员变量
 * 			super.成员变量
 * 		访问构造方法：
 * 			this(...)
 * 			super(...)
 * 		访问成员方法：
 * 			this.成员方法()
 * 			super.成员方法()
 */
public class Demo4POJOFather{
    //为了演示案例的方便，这里我们使用public修饰了成员变量，实际开发中，修饰符使用private
    //年龄
    public int age = 45;//c:在父类的成员范围找，如果有就使用
}

案例代码四  super关键字的概述和使用 【4.a.1 子类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类子类   super关键字的概述
 *
 * super和this的用法很像：
 * 		this:代表本类对象的引用
 * 		super:代表父类的存储空间(可以理解为代表父类对象的引用)
 *
 * 用法：
 * 		访问成员变量：
 * 			this.成员变量
 * 			super.成员变量
 * 		访问构造方法：
 * 			this(...)
 * 			super(...)
 * 		访问成员方法：
 * 			this.成员方法()
 * 			super.成员方法()
 */

public class Demo4POJOExtendSon extends Demo4POJOFather {
    //年龄
    public int age = 20;

    public void printAge() {
        int age = 10;
        //我要访问局部范围的age? //10
        System.out.println(age);
        //我要访问成员范围的age? //20
        System.out.println(this.age);
        //我要访问父类成员范围的age? //45
        System.out.println(super.age);
    }
}

案例代码三  super关键字的概述和使用 【3.b 父类和子类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类测试类  super关键字的概述
 *
 * super和this的用法很像：
 * 		this:代表本类对象的引用
 * 		super:代表父类的存储空间(可以理解为代表父类对象的引用)
 *
 * 用法：
 * 		访问成员变量：
 * 			this.成员变量
 * 			super.成员变量
 * 		访问构造方法：
 * 			this(...)
 * 			super(...)
 * 		访问成员方法：
 * 			this.成员方法()
 * 			super.成员方法()
 */
public class Demo4 {
    public static void main(String[] args) {
        Demo4POJOExtendSon s = new Demo4POJOExtendSon();
        //s.show();
        //10
        //20
        //45
        s.printAge();//d:如果经过a,b,c还找不到，就报错
    }
}

2.2 Java继承中构造方法的特点

  • 子类所有构造方法都默认访问父类的空参数的构造方法
  • 为什么呢？
    • 因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化
    • 每一个构造方法的第一条默认语句都是super
  • 如果父类中没有构造方法，该怎么办呢？
    • 在父类中加一个无参的构造方法
    • 通过使用super关键字去显示的调用父类的带参构造方法
    • 通过这里我们发现第一种解决方案最简单，所以，建议我们自定义类的时候永远自己给出无参构造方法

案例代码五  Java继承中构造方法的特点 【5.a 父类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类父类   Java继承中构造方法的访问特点
 *
 * Java继承中构造方法的访问特点：
 * 		A:子类构造方法执行前都会先执行父类无参构造方法
 * 		B:为什么呢?
 * 			因为子类继承父类，会继承父类的非私有成员。
 * 			而子类在初始化的时候，可能会使用父类的数据，如果父类数据没有先初始化，
 * 			子类就不能使用这些数据，所以，在子类初始化之前，一定要先完成父类数据的初始化。
 *
 * 		注意：在子类的构造方法中，默认第一行有一条语句：super()
 *
 * 问题：假如父类中没有无参构造方法，怎么办呢?
 * 		A:在父类中添加一个无参构造方法。
 * 		B:可以通过super去访问父类的带参构造方法。
 * 建议使用第一种解决方案，其实就是要求我们写代码的时候，每次都手动的给出无参构造方法。
 */
public class Demo5POJOFather {

    /**
     * @introduction Father无参构造方法
     */
    public Demo5POJOFather() {
        System.out.println("Father无参构造方法");
    }

    /**
     * @introduction Father带参构造方法
     * @param name 姓名
     */
    public Demo5POJOFather(String name) {
        System.out.println("Father带参构造方法");
        System.out.println("father:" + name);
    }
}

案例代码五  Java继承中构造方法的特点 【5.a.1 子类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类子类   Java继承中构造方法的访问特点
 *
 * Java继承中构造方法的访问特点：
 * 		A:子类构造方法执行前都会先执行父类无参构造方法
 * 		B:为什么呢?
 * 			因为子类继承父类，会继承父类的非私有成员。
 * 			而子类在初始化的时候，可能会使用父类的数据，如果父类数据没有先初始化，
 * 			子类就不能使用这些数据，所以，在子类初始化之前，一定要先完成父类数据的初始化。
 *
 * 		注意：在子类的构造方法中，默认第一行有一条语句：super()
 *
 * 问题：假如父类中没有无参构造方法，怎么办呢?
 * 		A:在父类中添加一个无参构造方法。
 * 		B:可以通过super去访问父类的带参构造方法。
 * 建议使用第一种解决方案，其实就是要求我们写代码的时候，每次都手动的给出无参构造方法。
 */
public class Demo5POJOExtendSon extends Demo5POJOFather {
    String name;
    public Demo5POJOExtendSon() {
        //super();
        System.out.println("Son无参构造方法");
    }

    public Demo5POJOExtendSon(String name) {
        super( name);
        //this();
        System.out.println("Son带参构造方法");
        System.out.println("son:" + name);
    }
}

案例代码五  Java继承中构造方法的特点 【5.b 父类和子类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类测试类  Java继承中构造方法的访问特点
 *
 * Java继承中构造方法的访问特点：
 * 		A:子类构造方法执行前都会先执行父类无参构造方法
 * 		B:为什么呢?
 * 			因为子类继承父类，会继承父类的非私有成员。
 * 			而子类在初始化的时候，可能会使用父类的数据，如果父类数据没有先初始化，
 * 			子类就不能使用这些数据，所以，在子类初始化之前，一定要先完成父类数据的初始化。
 *
 * 		注意：在子类的构造方法中，默认第一行有一条语句：super()
 *
 * 问题：假如父类中没有无参构造方法，怎么办呢?
 * 		A:在父类中添加一个无参构造方法。
 * 		B:可以通过super去访问父类的带参构造方法。
 * 建议使用第一种解决方案，其实就是要求我们写代码的时候，每次都手动的给出无参构造方法。
 */
public class Demo5 extends Demo5POJOFather {
    public static void main(String[] args) {
        /*
            Father无参构造方法
            Son无参构造方法
         */
        Demo5POJOExtendSon s1 = new Demo5POJOExtendSon();

        System.out.println("--------------");

        /*
            Father带参构造方法
            father:林青霞
            Son带参构造方法
            son:林青霞
         */
        Demo5POJOExtendSon s2 = new Demo5POJOExtendSon("林青霞");
    }
}

2.3 Java继承中成员方法的特点

  • 通过子类对象去访问一个方法
    • 首先在子类中找
    • 然后在父类中找
    • 如果还是没有就会报错

案例代码六  Java继承中成员方法的特点 【6.a 父类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类父类  Java继承中成员方法的访问特点
 *
 * Java继承中成员方法的访问特点：
 * 		A:子类中方法和父类中方法的声明不一样，这个太简单
 * 		B:子类中方法和父类中方法的声明一样，调用的到底是谁的呢?
 * 			执行的是子类中的方法。
 *
 * 通过子类对象调用方法：
 * 		a:在子类中找，有就使用
 * 		b:在父类中找，有就使用
 * 		c:如果没有就报错
 */
public class Demo6POJOFather {
    public void method(){
        System.out.println("Father method");
    }
    public void show(){
        System.out.println("Father show");
    }
}

案例代码六  Java继承中成员方法的特点 【6.a.1 子类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类子类  Java继承中成员方法的访问特点
 *
 * Java继承中成员方法的访问特点：
 * 		A:子类中方法和父类中方法的声明不一样，这个太简单
 * 		B:子类中方法和父类中方法的声明一样，调用的到底是谁的呢?
 * 			执行的是子类中的方法。
 *
 * 通过子类对象调用方法：
 * 		a:在子类中找，有就使用
 * 		b:在父类中找，有就使用
 * 		c:如果没有就报错
 */
public class Demo6POJOExtendSon extends Demo6POJOFather {

    @Override
    public void method() {
        super.method();
    }

    /**
     * @introduction 重写父类方法
     */
    @Override
    public void show() {
        System.out.println("Son show");
    }
}

案例代码六  Java继承中成员方法的特点 【6.b 父类和子类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类测试类  Java继承中成员方法的访问特点
 *
 * Java继承中成员方法的访问特点：
 * 		A:子类中方法和父类中方法的声明不一样，这个太简单
 * 		B:子类中方法和父类中方法的声明一样，调用的到底是谁的呢?
 * 			执行的是子类中的方法。
 *
 * 通过子类对象调用方法：
 * 		a:在子类中找，有就使用
 * 		b:在父类中找，有就使用
 * 		c:如果没有就报错
 */
public class Demo6 {
    public static void main(String[] args) {
        Demo6POJOExtendSon s = new Demo6POJOExtendSon();

        //直接调用父类的method方法：Father method
        s.method();

        //重写了父类的show方法：Son show
        s.show();
    }
}

2.4 方法重写的概述和使用

  • 方法重写的概述

    • 方法重写：子类中出现了和父类中一摸一样的方法声明

  • 方法重写的应用

    • 当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写中的方法，这样重写父类中的方法
    • 这样，即沿袭了父类的功能，又定义了子类特有的内容

  • 方法重写的注意事项

    • 注解
      • @Override
      • 表明该方法的重写父类的方法
    • 方法重写的注意事项
      • 父类中私有方法不能被重写
      • 子类重写父类方法时，访问权限不能更低
      • 子类重写父类方法时，建议访问权限一摸一样

案例代码七  方法重写的概述和使用 【7.a 手机类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 手机类   方法重写@Override
 *
 * 方法重写：子类中出现了和父类中一模一样的方法声明的情况。
 *
 * 方法重写的应用：
 * 		当子类需要父类的功能，而功能主体子类又有自己的特有内容的时候，就考虑使用方法重写，
 * 		这样即保证了父类的功能，还添加了子类的特有内容。
 */
public class Demo7POJOPhone {
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
}

案例代码七  方法重写的概述和使用 【7.a.1 手机类的子类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 手机类的子类   方法重写@Override
 *
 * 方法重写：子类中出现了和父类中一模一样的方法声明的情况。
 *
 * 方法重写的应用：
 * 		当子类需要父类的功能，而功能主体子类又有自己的特有内容的时候，就考虑使用方法重写，
 * 		这样即保证了父类的功能，还添加了子类的特有内容。
 */
public class Demo7POJOExtendPhone extends Demo7POJOPhone{
    @Override
    public void call(String name) {
        //子类独有的功能
        System.out.println("开启视频功能");
        //调用父类call方法
        super.call(name);
    }
}

案例代码七  方法重写的概述和使用 【7.b 手机类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 手机类的测试类   方法重写@Override
 *
 * 方法重写：子类中出现了和父类中一模一样的方法声明的情况。
 *
 * 方法重写的应用：
 * 		当子类需要父类的功能，而功能主体子类又有自己的特有内容的时候，就考虑使用方法重写，
 * 		这样即保证了父类的功能，还添加了子类的特有内容。
 */
public class Demo7 {
    public static void main(String[] args) {
        //给林青霞打电话
        Demo7POJOPhone p1 = new Demo7POJOPhone();
        p1.call("林青霞");
        System.out.println("----------");
        //开启视频功能
        //给林青霞打电话
        Demo7POJOExtendPhone p2 = new Demo7POJOExtendPhone();
        p2.call("林青霞");

    }
}

3 多态

3.1 多态的概述

  • 多态概述
    • 某一个事物，在不同时刻表现出来的不同状态。
  • 举例
    • 猫可以是猫的类型。猫 m = new 猫();
    • 同时猫也是动物的一种，也可以把猫称为动物
      • 动物 d = new 猫();
      • 水在不同时刻的状态
  • 多态的前提和体现
    • 有继承关系
    • 有方法重写
    • 有父类引用指向子类对象

案例代码八  多态的概述 【8.a 动物类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类   多态
 *
 * 多态：同一个对象，在不同时刻体现出来的不同状态。
 * 举例：
 * 		猫：猫是猫，猫是动物。
 * 		水：液体，固体，气体。
 *
 * Java中多态的前提：
 * 		A:有继承关系
 * 		B:有方法重写
 * 		C:有父类引用指向子类对象
 * 			Fu f = new Fu();
 * 			Zi z = new Zi();
 *
 * 			Fu f = new Zi();
 */
public class Demo8POJOAnimal {
}

案例代码八  多态的概述 【8.a.1 动物类子类–猫类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类子类--猫   多态
 *
 * 多态：同一个对象，在不同时刻体现出来的不同状态。
 * 举例：
 * 		猫：猫是猫，猫是动物。
 * 		水：液体，固体，气体。
 *
 * Java中多态的前提：
 * 		A:有继承关系
 * 		B:有方法重写
 * 		C:有父类引用指向子类对象
 * 			Fu f = new Fu();
 * 			Zi z = new Zi();
 *
 * 			Fu f = new Zi();
 */
public class Demo8POJOExtenCat extends Demo8POJOAnimal{

}

案例代码八  多态的概述 【8.b 动物类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类测试类   多态
 *
 * 多态：同一个对象，在不同时刻体现出来的不同状态。
 * 举例：
 * 		猫：猫是猫，猫是动物。
 * 		水：液体，固体，气体。
 *
 * Java中多态的前提：
 * 		A:有继承关系
 * 		B:有方法重写
 * 		C:有父类引用指向子类对象
 * 			Fu f = new Fu();
 * 			Zi z = new Zi();
 *
 * 			Fu f = new Zi();
 */
public class Demo8 {
    public static void main(String[] args) {
        //由父类引用指向子类对象
        Demo8POJOAnimal a = new Demo8POJOExtenCat();
    }
}

3.2 多态中成员的访问特点

  • 成员变量访问特点
    • 编译看左边，运行看左边
  • 成员方法访问特点
    • 编译看左边，运行在左

案例代码九  多态中成员的访问特点 【9.a 动物类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类   多态中成员访问特点
 *
 * 多态中成员的访问特点：
 * 		A:成员变量
 * 			编译看左边，执行看左边。
 * 		B:成员方法
 * 			编译看左边，执行看右边。
 *
 * 		为什么成员变量和成员方法的访问不一样呢?
 * 			因为成员方法有重写，而变量没有。
 */
public class Demo9POJOAnimal {
    public int age = 40;

    public void eat() {
        System.out.println("吃东西");
    }
}

案例代码九  多态中成员的访问特点 【9.a.1 动物类子类–猫类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类子类--猫   多态中成员访问特点
 *
 * 多态中成员的访问特点：
 * 		A:成员变量
 * 			编译看左边，执行看左边。
 * 		B:成员方法
 * 			编译看左边，执行看右边。
 *
 * 		为什么成员变量和成员方法的访问不一样呢?
 * 			因为成员方法有重写，而变量没有。
 */
public class Demo9POJOExtenCat extends Demo9POJOAnimal {
    public int age = 20;
    public int weight = 10;

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

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

案例代码九  多态中成员的访问特点 【9.b 动物类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类测试类   多态中成员访问特点
 *
 * 多态中成员的访问特点：
 * 		A:成员变量
 * 			编译看左边，执行看左边。
 * 		B:成员方法
 * 			编译看左边，执行看右边。
 *
 * 		为什么成员变量和成员方法的访问不一样呢?
 * 			因为成员方法有重写，而变量没有。
 */
public class Demo9 {
    public static void main(String[] args) {
        //由父类引用指向子类对象
        Demo9POJOAnimal a = new Demo9POJOExtenCat();
        System.out.println(a.age);
        //System.out.println(a.weight);//不能访问

        a.eat();
        //a.playGame();//不能访问
    }
}

3.3 多态的好处和弊端

  • 多态的好处
    • 提高了程序的扩展性
  • 多态的弊端
    • 不能访问子类特有功能
    • 那么如何访问子类的特有功能呢？
      • 通过多态中的转型

案例代码十  多态的好处和弊端 【10.a 动物类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类   多态的好处和弊端
 *
 * 多态的好处：提高了程序的扩展性
 * 		具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。
 * 多态的弊端：不能使用子类的特有功能
 */
public class Demo10POJOAnimal {
    public int age = 40;

    public void eat() {
        System.out.println("吃东西");
    }
}

案例代码十  多态的好处和弊端 【10.a.1 动物类子类–猫类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类子类--猫   多态的好处和弊端
 *
 * 多态的好处：提高了程序的扩展性
 * 		具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。
 * 多态的弊端：不能使用子类的特有功能
 */
public class Demo10POJOExtendCat extends Demo10POJOAnimal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

案例代码十  多态的好处和弊端 【10.a.2 动物类子类–狗类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类子类--狗   多态的好处和弊端
 *
 * 多态的好处：提高了程序的扩展性
 * 		具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。
 * 多态的弊端：不能使用子类的特有功能
 */
public class Demo10POJOExtendDog extends Demo10POJOAnimal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookDoor() {
        System.out.println("狗看门");
    }
}

案例代码十  多态的好处和弊端 【10.a.3 动物类子类–猪类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类子类--猪   多态的好处和弊端
 *
 * 多态的好处：提高了程序的扩展性
 * 		具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。
 * 多态的弊端：不能使用子类的特有功能
 */
public class Demo10POJOExtendPig extends Demo10POJOAnimal {
    @Override
    public void eat() {
        System.out.println("猪吃白菜");
    }
}

案例代码十  多态的好处和弊端 【10.b 动物类的操作类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类的操作类   多态的好处和弊端
 *
 * 多态的好处：提高了程序的扩展性
 * 		具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。
 * 多态的弊端：不能使用子类的特有功能
 */
public class Demo10Operator {

    public void useAnimal(Demo10POJOExtendCat cat) {
        cat.eat();
    }

    public void useAnimal(Demo10POJOExtendDog dog) {
        dog.eat();
        dog.lookDoor();
    }

    public void useAnimal(Demo10POJOExtendPig pig) {
        pig.eat();
    }

}

案例代码十  多态的好处和弊端 【10.c 动物类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类测试类   多态的好处和弊端
 *
 * 多态的好处：提高了程序的扩展性
 * 		具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。
 * 多态的弊端：不能使用子类的特有功能
 */
public class Demo10 {
    public static void main(String[] args) {
        //由父类引用指向子类对象
        Demo10Operator ao = new Demo10Operator();
        Demo10POJOExtendCat c = new Demo10POJOExtendCat();
        Demo10POJOExtendDog d = new Demo10POJOExtendDog();
        Demo10POJOExtendPig p = new Demo10POJOExtendPig();

        ao.useAnimal(c);//猫吃鱼

        ao.useAnimal(d);//狗吃骨头
                        //狗看门

        ao.useAnimal(p);//猪吃白菜
    }
}

3.4 多态中的转型问题

  • 向上转型
    • 从子到父
    • 父类引用指向子类对象
  • 向下转型
    • 从父到子
    • 父类引用转为子类对象

案例代码十一  多态中的转型问题 【10.a 动物类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类  多态中的转型问题
 *
 *	向上转型
 *		从子到父
 *		父类引用指向子类对象
 *	向下转型
 *		从父到子
 *		父类引用转为子类对象
 */
public class Demo11POJOAnimal {
    public void eat() {
      System.out.println("吃东西");
    }
}

案例代码十一  多态中的转型问题 【10.a.1 动物类的子类–猫类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类子类--猫类  多态中的转型问题
 *
 *	向上转型
 *		从子到父
 *		父类引用指向子类对象
 *	向下转型
 *		从父到子
 *		父类引用转为子类对象
 */
public class Demo11POJOExtendCat extends Demo11POJOAnimal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

案例代码十一  多态中的转型问题 【10.a.1 动物类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 动物类的测试类  多态中的转型问题
 *
 *	向上转型
 *		从子到父
 *		父类引用指向子类对象
 *	向下转型
 *		从父到子
 *		父类引用转为子类对象
 */
public class Demo11 {
    public static void main(String[] args) {
        Demo11POJOAnimal a = new Demo11POJOExtendCat();
        a.eat();

        //a.playGame();
        /*
            不能访问
            多态的弊端：无法访问子类特有方法
            现在我就想使用子类特有方法，怎么办呢？
            创建子类对象就可以了
        */
        Demo11POJOExtendCat c1 = new Demo11POJOExtendCat();
        c1.eat();
        c1.playGame();

        /*
            现在代码虽然可以访问子类的特有功能，但是不合理
            因为我们发现内存中有两个猫类的对象
            这个时候，我们得想办法把多态中的猫对象还原
            这个时候就需要使用多态中的转型了
            父类引用转为子类对象
         */
        Demo11POJOExtendCat c2 = (Demo11POJOExtendCat) a;
        c2.eat();
        c2.playGame();
    }
}

3.5 多态中的内存图

在这里插入图片描述

4 课后练习

4.1 练习1 经理、程序员

练习1  经理、程序员 【1.a 员工类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 员工类    课后基础练习1
 *
 *  1.	定义项目经理类
 * 			属性：
 * 				姓名 工号 工资 奖金
 * 			行为：
 * 				工作work
 *  2.	定义程序员类
 * 			属性：
 * 				姓名 工号 工资
 * 			行为：
 * 				工作work
 *  3.	要求:向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
 *  4.	编写测试类:完成这两个类的测试
 */
public class HomeWork1POJO {
    private String name;
    private String ID;
    private double salary;

    public HomeWork1POJO() {
    }

    public HomeWork1POJO(String name, String ID, double salary) {
        this.name = name;
        this.ID = ID;
        this.salary = salary;
    }

    public void work() {
        System.out.println("员工在工作");
    }

    public String getName() {
        return name;
    }

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

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

练习1  经理、程序员 【1.a.1 经理类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 员工类子类--项目经理类   课后基础练习1
 *
 *  1.	定义项目经理类
 * 			属性：
 * 				姓名 工号 工资 奖金
 * 			行为：
 * 				工作work
 *  2.	定义程序员类
 * 			属性：
 * 				姓名 工号 工资
 * 			行为：
 * 				工作work
 *  3.	要求:向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
 *  4.	编写测试类:完成这两个类的测试
 */
public class HomeWork1POJOExtendManager extends HomeWork1POJO {

    private double bonus;

    public HomeWork1POJOExtendManager() {
        super();
    }

    public HomeWork1POJOExtendManager(String name, String ID, double salary, double bonus) {
        super(name, ID, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println(this.getName() + "..." + this.getID() + "..." + this.getSalary() + "..." + this.getBonus() + "项目经理正在看着程序员敲代码");
    }

}

练习1  经理、程序员 【1.a.2 程序员类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 员工类子类--程序员类    课后基础练习1
 *
 *  1.	定义项目经理类
 * 			属性：
 * 				姓名 工号 工资 奖金
 * 			行为：
 * 				工作work
 *  2.	定义程序员类
 * 			属性：
 * 				姓名 工号 工资
 * 			行为：
 * 				工作work
 *  3.	要求:向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
 *  4.	编写测试类:完成这两个类的测试
 */
public class HomeWork1POJOExtendProgrammer extends HomeWork1POJO {
    private String name;
    private int ID;
    private double salary;

    public HomeWork1POJOExtendProgrammer() {
        super();
    }

    public HomeWork1POJOExtendProgrammer(String name, String ID, double salary) {
        super(name, ID, salary);
    }

    @Override
    public void work() {
        System.out.println(this.getName() + "..." + this.getID() + "..." + this.getSalary() + "程序员正在敲代码");
    }

}

练习1  经理、程序员 【1.b 员工类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 员工类的测试类  课后基础练习1
 *
 *  1.	定义项目经理类
 * 			属性：
 * 				姓名 工号 工资 奖金
 * 			行为：
 * 				工作work
 *  2.	定义程序员类
 * 			属性：
 * 				姓名 工号 工资
 * 			行为：
 * 				工作work
 *  3.	要求:向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
 *  4.	编写测试类:完成这两个类的测试
 */
public class HomeWork1 {
    public static void main(String[] args) {
        HomeWork1POJO manager = new HomeWork1POJOExtendManager("林青霞", "00001", 10000.66, 20000.66);
        HomeWork1POJO programmer = new HomeWork1POJOExtendProgrammer("周伯通", "015231", 12345);
        manager.work();
        programmer.work();
    }
}

4.2 练习2 老师、学生

练习2  老师、学生 【2.a 人类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类
 *
 * 分析以下需求，并用代码实现
 * 1.	已知学生类和老师类如下：
 * 			属性:
 * 				姓名,年龄
 * 			行为:
 * 				吃饭
 * 			老师有特有的方法:
 * 				讲课
 * 			学生有特有的方法:
 * 				学习
 *
 * 2.	要求:向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
 * 3.	编写测试类:完成这两个类的测试
 */
public class HomeWork2POJO {
    private String name;
    private int age;

    public HomeWork2POJO() {
    }

    public HomeWork2POJO(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

练习2  老师、学生 【2.a.1 人类的子类–老师类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类子类--老师类
 *
 * 分析以下需求，并用代码实现
 * 1.	已知学生类和老师类如下：
 * 			属性:
 * 				姓名,年龄
 * 			行为:
 * 				吃饭
 * 			老师有特有的方法:
 * 				讲课
 * 			学生有特有的方法:
 * 				学习
 *
 * 2.	要求:向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
 * 3.	编写测试类:完成这两个类的测试
 */
public class HomeWork2POJOExtendTeacher extends HomeWork2POJO {
    public HomeWork2POJOExtendTeacher() {
    }

    public HomeWork2POJOExtendTeacher(String name, int age) {
        super(name, age);
    }

    public void teach() {
        System.out.println("老师要好好讲课");
    }
}

练习2  老师、学生 【2.a.2 人类的子类–学生类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类子类--学生列
 *
 * 分析以下需求，并用代码实现
 * 1.	已知学生类和老师类如下：
 * 			属性:
 * 				姓名,年龄
 * 			行为:
 * 				吃饭
 * 			老师有特有的方法:
 * 				讲课
 * 			学生有特有的方法:
 * 				学习
 *
 * 2.	要求:向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
 * 3.	编写测试类:完成这两个类的测试
 */
public class HomeWork2POJOExtendStudent extends HomeWork2POJO {
    public HomeWork2POJOExtendStudent() {
    }

    public HomeWork2POJOExtendStudent(String name, int age) {
        super(name, age);
    }

    public void study() {
        System.out.println("学生要好好听讲");
    }
}

练习2  老师、学生 【2.b 人类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类的测试类 课后基础练习2
 *
 * 分析以下需求，并用代码实现
 * 1.	已知学生类和老师类如下：
 * 			属性:
 * 				姓名,年龄
 * 			行为:
 * 				吃饭
 * 			老师有特有的方法:
 * 				讲课
 * 			学生有特有的方法:
 * 				学习
 *
 * 2.	要求:向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
 * 3.	编写测试类:完成这两个类的测试
 */
public class HomeWork2 {
    public static void main(String[] args) {
        HomeWork2POJOExtendStudent s = new HomeWork2POJOExtendStudent("小明", 20);
        HomeWork2POJOExtendTeacher t = new HomeWork2POJOExtendTeacher("苍老师", 18);

        s.study();//学生要好好听讲
        t.teach();//老师要好好讲课

    }
}

4.3 练习3 经理、服务员

练习3  经理、服务员 【3.a 员工类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 员工类    课后基础练习3
 *
 * 分析以下需求,并用代码实现：
 * 	1.定义员工类:
 * 		属性:
 * 			工号,姓名
 * 		行为:
 * 			工作方法(用简单的输出语句模拟)
 * 	2.定义经理类:
 * 		属性:
 * 			工号,姓名,奖金
 * 		行为:
 * 			工作方法(管理员工,简单输出语句模拟)
 * 	3.定义服务员类:
 * 		属性:
 * 			工号,姓名
 * 		行为:
 * 			工作方法(为客户服务,简单输出语句模拟)
 * 	4.定义测试类:
 * 		分别创建经理类对象和服务员类对象
 * 		调用各自的工作方法
 * 		要求:
 * 			分析各个事物之间的继承关系,抽取出相关的类
 */
public class HomeWork3POJO {
    private String name;
    private String ID;

    public HomeWork3POJO() {
    }

    public HomeWork3POJO(String name, String ID) {
        this.name = name;
        this.ID = ID;
    }

    public String getName() {
        return name;
    }

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

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public void work(){
        System.out.println("所有人都需要工作");
    }
}

练习3  经理、服务员 【3.a.1 员工类的子类–经理类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 员工类子类--经理类 课后基础练习3
 *
 * 分析以下需求,并用代码实现：
 * 	1.定义员工类:
 * 		属性:
 * 			工号,姓名
 * 		行为:
 * 			工作方法(用简单的输出语句模拟)
 * 	2.定义经理类:
 * 		属性:
 * 			工号,姓名,奖金
 * 		行为:
 * 			工作方法(管理员工,简单输出语句模拟)
 * 	3.定义服务员类:
 * 		属性:
 * 			工号,姓名
 * 		行为:
 * 			工作方法(为客户服务,简单输出语句模拟)
 * 	4.定义测试类:
 * 		分别创建经理类对象和服务员类对象
 * 		调用各自的工作方法
 * 		要求:
 * 			分析各个事物之间的继承关系,抽取出相关的类
 */
public class HomeWork3POHOExtendManager extends HomeWork3POJO {
    private double bonus;

    public HomeWork3POHOExtendManager() {
    }

    public HomeWork3POHOExtendManager(String name, String ID, double bonus) {
        super(name, ID);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println(this.getName() + "..." + this.getID() + "..." + this.getBonus() + "...  项目经理正在上班");
    }
}

练习3  经理、服务员 【3.a.2 员工类的子类–服务员类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 员工类子类--服务员类    课后基础练习3
 *
 * 分析以下需求,并用代码实现：
 * 	1.定义员工类:
 * 		属性:
 * 			工号,姓名
 * 		行为:
 * 			工作方法(用简单的输出语句模拟)
 * 	2.定义经理类:
 * 		属性:
 * 			工号,姓名,奖金
 * 		行为:
 * 			工作方法(管理员工,简单输出语句模拟)
 * 	3.定义服务员类:
 * 		属性:
 * 			工号,姓名
 * 		行为:
 * 			工作方法(为客户服务,简单输出语句模拟)
 * 	4.定义测试类:
 * 		分别创建经理类对象和服务员类对象
 * 		调用各自的工作方法
 * 		要求:
 * 			分析各个事物之间的继承关系,抽取出相关的类
 */
public class HomeWork3POHOExtendWaiter extends HomeWork3POJO {
    public HomeWork3POHOExtendWaiter() {
    }

    public HomeWork3POHOExtendWaiter(String name, String ID) {
        super(name, ID);
    }

    @Override
    public void work() {
        System.out.println(this.getName() + "..." + this.getID() + "... 服务员正在上班 ");
    }

}

练习3  经理、服务员 【3.b 员工类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 员工类测试类 课后基础练习3
 *
 * 分析以下需求,并用代码实现：
 * 	1.定义员工类:
 * 		属性:
 * 			工号,姓名
 * 		行为:
 * 			工作方法(用简单的输出语句模拟)
 * 	2.定义经理类:
 * 		属性:
 * 			工号,姓名,奖金
 * 		行为:
 * 			工作方法(管理员工,简单输出语句模拟)
 * 	3.定义服务员类:
 * 		属性:
 * 			工号,姓名
 * 		行为:
 * 			工作方法(为客户服务,简单输出语句模拟)
 * 	4.定义测试类:
 * 		分别创建经理类对象和服务员类对象
 * 		调用各自的工作方法
 * 		要求:
 * 			分析各个事物之间的继承关系,抽取出相关的类
 */
public class HomeWork3 {
    public static void main(String[] args) {
        HomeWork3POHOExtendManager m = new HomeWork3POHOExtendManager("张飞", "007", 1000);
        m.work();//张飞...007...1000.0...  项目经理正在上班

        HomeWork3POHOExtendWaiter w = new HomeWork3POHOExtendWaiter("小乔", "9527");
        w.work();//小乔...9527... 服务员正在上班 
    }
}

4.4 练习4 工人、学生、班长

练习4  工人、学生、班长 【4.a 人类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类  课后练习4
 *
 * 分析以下需求，并用代码实现：
 * 1. 定义Person类
 * 		属性：
 * 			姓名name、性别gender、年龄age、国籍nationality；
 * 		方法：吃饭eat、睡觉sleep，工作work。
 * 	2.根据人类，派生一个学生类Student
 * 		增加属性：
 * 			学校school、学号stuNumber；
 * 		重写工作方法（学生的工作是学习）。
 * 	3.根据人类，派生一个工人类Worker
 * 		增加属性：
 * 			单位unit、工龄workAge；
 * 		重写工作方法（工人的工作是盖房子）。
 * 	4.根据学生类，派生一个班长类 StudentLeader
 * 		增加属性：
 * 			职务job；
 * 		增加方法：开会meeting。
 * 	5.编写测试类分别对上述3类具体人物进行测试。
 * 	6.要求运行结果:
 * 		学生需要学习!
 * 		工人的工作是盖房子!
 * 		班长喜欢开会!
 */
public class HomeWork4POJO {
    private String name;
    private String gender;
    private int age;
    private String nationality;

    public HomeWork4POJO() {
    }

    public HomeWork4POJO(String name, String gender, int age, String nationality) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.nationality = nationality;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getNationality() {
        return nationality;
    }

    public void setNationality(String nationality) {
        this.nationality = nationality;
    }

    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }

    public void work() {
        System.out.println("工作");
    }
}

练习4  工人、学生、班长 【4.a.1 人类的子类–工人】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类子类--工人  课后练习4
 *
 * 分析以下需求，并用代码实现：
 * 1. 定义Person类
 * 		属性：
 * 			姓名name、性别gender、年龄age、国籍nationality；
 * 		方法：吃饭eat、睡觉sleep，工作work。
 * 	2.根据人类，派生一个学生类Student
 * 		增加属性：
 * 			学校school、学号stuNumber；
 * 		重写工作方法（学生的工作是学习）。
 * 	3.根据人类，派生一个工人类Worker
 * 		增加属性：
 * 			单位unit、工龄workAge；
 * 		重写工作方法（工人的工作是盖房子）。
 * 	4.根据学生类，派生一个班长类 StudentLeader
 * 		增加属性：
 * 			职务job；
 * 		增加方法：开会meeting。
 * 	5.编写测试类分别对上述3类具体人物进行测试。
 * 	6.要求运行结果:
 * 		学生需要学习!
 * 		工人的工作是盖房子!
 * 		班长喜欢开会!
 */
public class HomeWork4POJOExtendWorker extends HomeWork4POJO {
    private String unit;
    private int workAge;

    public HomeWork4POJOExtendWorker() {
    }

    public HomeWork4POJOExtendWorker(String name, String gender, int age, String nationality, String unit, int workAge) {
        super(name, gender, age, nationality);
        this.unit = unit;
        this.workAge = workAge;
    }

    @Override
    public void work() {
        //super.work();
        System.out.println("【name:" + this.getName() + "】 【gender:" + this.getGender() + "】 【age:" +
                                   this.getAge() + "】 【nationality:" + this.getNationality()  + "】 【unit:" +
                                   this.unit + "】 【workAge:" + this.workAge + "】..." + "工人的工作是盖房子");
    }
}

练习4  工人、学生、班长 【4.a.2 人类的子类–学生】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类子类--学生类  课后练习4
 *
 * 分析以下需求，并用代码实现：
 * 1. 定义Person类
 * 		属性：
 * 			姓名name、性别gender、年龄age、国籍nationality；
 * 		方法：吃饭eat、睡觉sleep，工作work。
 * 	2.根据人类，派生一个学生类Student
 * 		增加属性：
 * 			学校school、学号stuNumber；
 * 		重写工作方法（学生的工作是学习）。
 * 	3.根据人类，派生一个工人类Worker
 * 		增加属性：
 * 			单位unit、工龄workAge；
 * 		重写工作方法（工人的工作是盖房子）。
 * 	4.根据学生类，派生一个班长类 StudentLeader
 * 		增加属性：
 * 			职务job；
 * 		增加方法：开会meeting。
 * 	5.编写测试类分别对上述3类具体人物进行测试。
 * 	6.要求运行结果:
 * 		学生需要学习!
 * 		工人的工作是盖房子!
 * 		班长喜欢开会!
 */
public class HomeWork4POJOExtendStudent extends HomeWork4POJO {
    private String school;
    private String stuNumber;

    public HomeWork4POJOExtendStudent() {
        super();
    }

    public HomeWork4POJOExtendStudent(String name, String gender, int age, String nationality, String school, String stuNumber) {
        super(name, gender, age, nationality);
        this.school = school;
        this.stuNumber = stuNumber;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public String getStuNumber() {
        return stuNumber;
    }

    public void setStuNumber(String stuNumber) {
        this.stuNumber = stuNumber;
    }

    @Override
    public void work() {
        //super.work();
        System.out.println("【name:" + this.getName() + "】 【gender:" + this.getGender() + "】 【age:" +
                                   this.getAge() + "】 【nationality:" + this.getNationality() + "】 【school:" +
                                   this.getSchool() + "】 【number:" + this.getStuNumber() + "】学生的工作是学习");
    }
}

练习4  工人、学生、班长 【4.a.2.1 人类的子类–班长】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类子类--学生类子类--班长  课后练习4
 *
 * 分析以下需求，并用代码实现：
 * 1. 定义Person类
 * 		属性：
 * 			姓名name、性别gender、年龄age、国籍nationality；
 * 		方法：吃饭eat、睡觉sleep，工作work。
 * 	2.根据人类，派生一个学生类Student
 * 		增加属性：
 * 			学校school、学号stuNumber；
 * 		重写工作方法（学生的工作是学习）。
 * 	3.根据人类，派生一个工人类Worker
 * 		增加属性：
 * 			单位unit、工龄workAge；
 * 		重写工作方法（工人的工作是盖房子）。
 * 	4.根据学生类，派生一个班长类 StudentLeader
 * 		增加属性：
 * 			职务job；
 * 		增加方法：开会meeting。
 * 	5.编写测试类分别对上述3类具体人物进行测试。
 * 	6.要求运行结果:
 * 		学生需要学习!
 * 		工人的工作是盖房子!
 * 		班长喜欢开会!
 */
public class HomeWork4POJOExtendStudentLeader extends HomeWork4POJOExtendStudent {
    private String job;

    public HomeWork4POJOExtendStudentLeader() {
    }

    public HomeWork4POJOExtendStudentLeader(String name, String gender, int age, String nationality, String school, String stuNumber, String job) {
        super(name, gender, age, nationality, school, stuNumber);
        this.job = job;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public void meeting() {
        System.out.println("【name:" + this.getName() + "】 【gender:" + this.getGender() + "】 【age:" +
                                   this.getAge() + "】 【nationality:" + this.getNationality() + "】 【school:" +
                                   this.getSchool() + "】 【number:" + this.getStuNumber() + "】 【job:"+ this.getJob() + "】..."
                                   + "班长要开会");
    }
}

练习4  工人、学生、班长 【4.b 人类的测试类】

package com.groupies.base.day07;

/**
 * @author GroupiesM
 * @date 2021/3/24
 * @introduction 人类测试类  课后练习4
 *
 * 分析以下需求，并用代码实现：
 * 1. 定义Person类
 * 		属性：
 * 			姓名name、性别gender、年龄age、国籍nationality；
 * 		方法：吃饭eat、睡觉sleep，工作work。
 * 	2.根据人类，派生一个学生类Student
 * 		增加属性：
 * 			学校school、学号stuNumber；
 * 		重写工作方法（学生的工作是学习）。
 * 	3.根据人类，派生一个工人类Worker
 * 		增加属性：
 * 			单位unit、工龄workAge；
 * 		重写工作方法（工人的工作是盖房子）。
 * 	4.根据学生类，派生一个班长类 StudentLeader
 * 		增加属性：
 * 			职务job；
 * 		增加方法：开会meeting。
 * 	5.编写测试类分别对上述3类具体人物进行测试。
 * 	6.要求运行结果:
 * 		学生需要学习!
 * 		工人的工作是盖房子!
 * 		班长喜欢开会!
 */
public class HomeWork4 {
    public static void main(String[] args) {
        HomeWork4POJOExtendStudent s = new HomeWork4POJOExtendStudent("静静", "female", 20, "国中", "黑马", "heima001");

        System.out.println("s.work");
        s.work();//【name:静静】 【gender:female】 【age:20】 【nationality:国中】 【school:黑马】 【number:heima001】学生的工作是学习

        HomeWork4POJOExtendWorker w = new HomeWork4POJOExtendWorker("胖三斤", "male", 50, "鲜朝", "家里蹲", 10);
        System.out.println("w.work");
        w.work();//【name:胖三斤】 【gender:male】 【age:50】 【nationality:鲜朝】 【unit:家里蹲】 【workAge:10】...工人的工作是盖房子

        HomeWork4POJOExtendStudentLeader leader = new HomeWork4POJOExtendStudentLeader("芳芳", "male", 38, "国中", "杭州体育学院","NO1","服务");
        System.out.println("leader.work");
        leader.meeting();//【name:芳芳】 【gender:male】 【age:38】 【nationality:国中】 【school:杭州体育学院】 【number:NO1】 【job:服务】...班长要开会
    }
}

21/03/25

M

GroupiesM
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
07_javase面向对象之继承
04-24
关键字super/this的用法和区别;在继承中子类和父类构造方法的关系;方法重写;final关键字
JavaSE进阶 面向对象多态
11-12
JavaSE 进阶 面向对象多态 在 JavaSE 中，面向对象多态是指同一个对象可以具有多种形态，例如一个人可以是老师、丈夫、父亲等。这种多态性是通过方法的重写和重载来实现的。 多态的形式有很多，例如： 1. 方法...
3.1_1 =========JAVASE入门==========
GroupiesM的博客
09-23 166
JavaSE入门 P1 - P20目录
javase基础三大特征之一“多态”_classfu public final void show(1)
最新发布
m0_60635245的博客
04-21 509
*概述：**同一对象，在不同时刻表现出来的不同形态有继承关系：public class Cat extends Animal{//继承关系@Overridepublic void eat(){//方法重写System.out.println(“猫爱吃鱼”);方法重写：System.out.println(“动物吃肉”);父类引用指向子类对象：//多态，父类引用指向子类对象，这里也就是下面说的向上转型概述。
JavaSE篇学习之路：（六）【面向对象------中】，2024年最新牧原网上面试一般等几天
2401_84102536的博客
04-19 364
当子类继承父类后，继承过来的方法无法满足子类的需求，子类将这个方法进行重写。
JavaSE详细笔记
qq_43881783的博客
03-16 269
java基础到高级详细笔记
JavaSE知识梳理
ChinaLiyq的博客
03-17 532
个人学习-还在整理中
Java入门-学习黑马程序员Java基础视频教程（到P92）
孟孟单单的博客
06-07 2560
Java基础学习
JavaSE基础篇 面向对象三大基本特征【继承】_默认继承object类,还是必须继承(2)
2401_84141419的博客
04-17 744
​​​​​​​ ​​​​​​​ B类则称为子类(subclass)、派生类、扩展类。实际上调用的也不是父类的方法，是他子类自己的方法（因为已经继承过来了就属于自己的）例如：class C extends B，class B extends A，也就是说，C 直接继承 B，B 直接继承 A；，Object类是java 语言提供的根类（老祖宗类），也就是说，一个对象与生俱来就有 Object类型中所有的特征。（2）间接继承：Z直接继承了Y，Y又继承X，所以Z间接继承了X。
资料搜集-JAVA系统的梳理知识3-面试篇
java技术专家全栈成长之路
01-06 6789
> 作者：ppxyn。本文来自读者投稿，同时也欢迎各位投稿，**对于不错的原创文章我根据你的选择给予现金(50-200)、付费专栏或者任选书籍进行奖励！所以，快提 pr 或者邮件的方式（邮件地址在主页）给我投稿吧！** 当然，我觉得奖励是次要的，最重要的是你可以从自己整理知识点的过程中学习到很多知识。 **目录** <!-- MarkdownTOC --> - [前言](...
day01-继承&修饰符&多态&抽象类.pdf
08-23
1.继承 2.修饰符 3.多态 4.抽象类 小车穿沿在蜿蜒曲折的盘山公路上
Java SE编程入门教程 java封装继承多态（共56页）.pptx
12-04
Java SE编程入门是一个涵盖广泛的主题，它涉及到Java语言的基础、面向对象编程概念以及Java标准版（Java SE）的核心特性。以下是一些关键知识点的详细解释： 1. **封装**：封装是面向对象编程的三大特性之一，其...
JavaSE进阶 面向对象继承
11-12
JavaSE进阶面向对象继承 继承是Java语言中的一种机制，允许一个类继承另一个类的特征和行为。继承的优点是可以提高代码的可重用性，减少代码冗余，提高开发效率。 1. 继承的定义：继承是指一个类继承另一个类的...
3.5.1_2 Maven - pom.xml 添加maven-assembly-plugin(官方标准打包插件)
GroupiesM的博客
06-05 7775
Maven打包操作步骤
3.1_21 JavaSE入门 P20 【正则】Pattern模式类、Matcher匹配器、元字符、分组捕获、反向引用
GroupiesM的博客
09-22 5517
JavaSE入门 P20 【正则】Pattern模式类、Matcher匹配器、元字符、分组捕获、反向引用 1.入门 2.底层实现 3.基本语法 4.元字符使用案例 5.Pattern模式类 6.Matcher匹配器 7.PatternSyntaxException异常类 8.应用案例 9.常用正则
3.1_2 JavaSE入门 P1 【Java基础】Java语言概述、JDK编译
GroupiesM的博客
01-26 4283
JavaSE入门 P1 【Java基础】Java语言概述
3.1_14 JavaSE入门 P13 【其他】异常，File，IO，字节(符)流，字节(符)缓冲流，转换流
GroupiesM的博客
05-10 3955
JavaSE入门 P13 【其他】异常，File，IO，字节(符)流，字节(符)缓冲流，转换流 1.异常 2.File类 3.IO流 4.NIO（new IO） 5.IO流练习
3.5.1_1 Maven导入本地JAR包
GroupiesM的博客
05-29 3802
Maven导入本地JAR包操作步骤
"JavaSE面向对象特性总结：封装、继承、多态
面向对象的特性包括封装、继承和多态。其中，封装是把数据和方法包装进类中，隐藏其具体实现细节，对外提供公共访问方法，以提高安全性和复用性。继承是指当一个类的属性与行为均与现有类相似时，这一个类可以定义为...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值