13-面向对象进阶_01(static、继承)

一 statc 关键字

1. static概述

static表示静态，是Java中的一个修饰符，可以修饰成员方法和成员变量。

1.1 静态变量

被static修饰的成员变量，叫做静态变量

特点：

• 被该类所有对象共享

• 不属于对象，属于类

• 随着类的加载而加载，优先于对象存在

调用方法：

• 类名调用（推荐） Student.teacherName = "阿伟老师";

• 对象名调用 s1.teacherName = "阿伟老师";

1.2 静态方法

被static修饰的成员方法，叫做静态方法

特点：

• 多用在测试类和工具类中

• Javabean类中很少会用

调用方法：

• 类名调用（推荐）

• 对象名调用

1.3 类的分类

Javabean类： 用来描述一类事物的类。比如：Student、Teacher、Dog、Cat等

测试类： 用来检查其他类是否书写正确，带有main方法的类，是程序的入口

工具类： 帮助我们做一些事情，但是不描述任何事物的类

1. 类名见名知意

2. 私有化构造方法

3. 方法定义为静态

单例设计模式： 后续多线程阶段讲解

2. 静态变量示例

//Student.java
package com.yq.a01staticdemo1;
​
public class Student {
    //属性：姓名、年龄、性别
    //新增属性: 老师的姓名
    private String name;
    private int age;
    private String gender;
    public static String teacherName;
​
    public Student() {
    }
​
    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
​
    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;
    }
​
    public String getGender() {
        return gender;
    }
​
    public void setGender(String gender) {
        this.gender = gender;
    }
​
    //行为
    public void study(){
        System.out.println(name + "正在学习");
    }
​
    public void show(){
        System.out.println(name+ ", " + age + ", " + gender +", " + teacherName);
    }
​
}
​

//StudentTest.java
package com.yq.a01staticdemo1;
​
public class StudentTest {
    public static void main(String[] args) {
        //1.创建第一个学生对象
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(23);
        s1.setGender("男");
        //s1.teacherName = "阿伟老师";     // 不推荐的对象调用方式  
        Student.teacherName = "阿伟老师";  // 推荐的类名调用方式 
​
        s1.study();
        s1.show();
​
        //2.创建第二个学生对象
        Student s2 = new Student();
        s2.setName("李四");
        s2.setAge(24);
        s2.setGender("女");
        //s2.teacherName = "阿伟老师";     // 不推荐的对象调用方式
​
        s2.study();
        s2.show();
    }
}
​

static内存图

静态变量是随着类的加载而加载的, 优先于对象出现的

练习： 判断一下属性是否可以被定义为静态

public class Student {
    String name;           // 不可以 - 每个学生姓名不同
    int age;               // 不可以 - 每个学生年龄不同
    String teacherName;    // 可以 - 所有学生共享同一个老师
    String cup;            // 不可以 - 每个学生有自己的水杯
    String GirlFriendName; // 不可以 - 每个学生女朋友不同
}

3. 工具类实践

3.1 数组工具类

//ArrayUtil.java
package com.yq.a02staticdemo2;
​
/*
需求: 在实际开发中, 经常会遇到一些数组使用的工具类
      按照以下要求编写一个数组的工具类: ArrayUtil
      1.提供一个工具类方法printArr, 用于返回整数数组中的内容
        返回的字符串格式如: [10, 20, 50, 34, 100] (只考虑整数数组, 且只考虑一维数组)
      2.提供一个工具类方法getAverage, 用于返回平均分. (只考虑浮点型数组, 且只考虑一维数组)
      3.定义一个测试类TestDemo, 调用该工具类的工具方法, 并返回结果
*/
public class ArrayUtil {
    //私有化构造方法 不让外界创建他的对象
    private ArrayUtil(){}
​
    //需要定义为静态 方便调用
    public static String printArr(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
​
    public static double getAverage(double[] arr){
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum +arr[i];
        }
        return sum / arr.length;
    }
}
​

//TestDemo.java
package com.yq.a02staticdemo2;
​
public class TestDemo {
    public static void main(String[] args) {
        //测试工具类中的两个方法是否正确
​
        int[] arr1 = {1, 2, 3, 4, 5};
        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);
​
        double[] arr2 = {1.5, 3.7, 4.9, 5.8, 6.6};
        double avg = ArrayUtil.getAverage(arr2);
        System.out.println(avg);
    }
}
​

3.2 学生工具类

需求： 定义一个集合，用于存储3个学生对象。学生类的属性为：name age gender。定义一个工具类，用于获取集合中最大学生的年龄。

//Student.java
package com.yq.a03staticdemo3;
​
public class Student {
    private String name;
    private int age;
    private String gender;
​
    public Student() {
    }
​
    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
​
    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;
    }
​
    public String getGender() {
        return gender;
    }
​
    public void setGender(String gender) {
        this.gender = gender;
    }
}
​

//StudentUtil.java
package com.yq.a03staticdemo3;
​
import java.util.ArrayList;
​
public class StudentUtil {
    private StudentUtil(){}
​
    //静态方法
    public static int getMaxAgeStudents(ArrayList<Student> list){
        //1.定义一个参照物
        int max = list.get(0).getAge();
​
        //2.循环遍历集合
        for (int i = 1; i < list.size(); i++) {
            //i 索引   list.get(i) 表示学生对象 我们还需要getAge才能进行比较
            int tempAge = list.get(i).getAge();
            if ( tempAge > max){
                max = tempAge;
            }
        }
​
        //3.返回max
        return max;
    }
}
​

//Test.java
package com.yq.a03staticdemo3;
​
import java.util.ArrayList;
​
public class Test {
    public static void main(String[] args) {
        //1.创建一个集合用来存储学生对象
        ArrayList<Student> list = new ArrayList<>();
​
        //2.创建三个学生对象
        Student stu1 = new Student("zhangsan", 23, "男");
        Student stu2 = new Student("lisi", 24, "女");
        Student stu3 = new Student("wangwu", 25, "男");
​
        //3.把学生对象添加到集合中
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
​
        //4.调用工具类中方法
        int maxAgeStudents = StudentUtil.getMaxAgeStudents(list);
​
        System.out.println(maxAgeStudents);
    }
}
​

4. static注意事项

规则总结：

• 静态方法只能访问静态变量和静态方法

• 非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法

• 静态方法中没有this关键字

总结：

• 静态方法中，只能访问静态

• 非静态方法可以访问所有

• 静态方法中没有this关键字

//student.java
package com.yq.a04staticdemo4;
​
/*
    总结:
        静态方法中，没有this关键字
        静态方法中，只能访问静态
        非静态方法可以访问所有
*/
​
public class Student {
    String name;
    int age;
    static String teacherName;
​
    //this: 表示当前调用者的地址值
    //这个this是由虚拟机赋值的
    // public void show1(Student this){  // this参数是隐式的，可以不用显式声明
    public void show1(){
        System.out.println("this: " + this);
        System.out.println(this.name + " ," + this.age + ", " + this.teacherName);
        //调用其他方法
        this.show2();
​
        method();  //可以调用，非静态方法可以访问所有
    }
​
    public void show2(){
        System.out.println("show2");
    }
​
    //静态方法中，只能访问静态
    public static void method(){
        //System.out.println(name);  无法调用
        //this.show1();              无法调用
        System.out.println("静态方法");
    }
}
​

//StudentTest.java
package com.yq.a04staticdemo4;
​
public class StudentTest {
    public static void main(String[] args) {
        Student.teacherName = "tom老师";
​
        Student s1 = new Student();
        System.out.println("s1: " + s1);
        s1.name = "zhangsan";
        s1.age = 23;
        s1.show1();
​
        System.out.println("==============");
        Student s2 = new Student();
        s2.name = "lisi";
        s2.age = 24;
        System.out.println("s2: " + s2);
        s2.show1();
    }
}
​

static内存图：

静态方法不能访问非静态

非静态可以访问所有

5. 重新认识main方法

public class HelloWorld {
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}
​
/*
public: 被JVM调用，访问权限足够大（权限修饰符）
static: 被JVM调用，不用创建对象，直接类名访问
        在静态方法中如果要直接调用类的其他方法（不通过对象实例），那么被调用的方法也必须是静态的
        
void:   被JVM调用，不需要给JVM返回值
main:   一个通用的名称，虽然不是一个关键，但是被JVM识别
String[] args: 以前用于接收键盘录入数据的，现在没有（为了兼容以前的版本，相当于固定格式）
​
*/

main方法参数使用示例：

package com.yq.a05staticdemo5;
​
public class Test {
    public static void main(String[] args) {
        // [] 数组
        // String 数组类型
        // args  数组名
        System.out.println(args.length);
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
​
    }
}
​
/*
    Edit Configurations(Test)
    Program argumengts中写入传递的数据，空格隔开
    运行结果类似如下：
        3
        Hello
        World
        Java
*/

总结

static关键字在Java中主要用于创建类级别的成员，它具有以下特点：

1. 静态变量：被所有对象共享，属于类而非对象

2. 静态方法：通过类名直接调用，常用于工具类

3. 访问限制：静态方法只能访问静态成员，非静态方法可以访问所有成员

4. 工具类设计：私有构造方法 + 静态方法

理解static关键字的内存原理和使用场景，对于编写高质量的Java代码至关重要。

二 继承

1.概述

封装： 对象代表什么，就得封装对应的数据，并提供数据对应的行为

继承： Java中提供一个关键字extends，用这个关键字我们可以让一个类和另一个类建立起继承关系

public class Student extends Person {}
public class 子类 extends 父类 {}

• Student称为子类（派生类）

• Person称为父类（基类或超类）

使用继承的好处：

• 可以把多个子类中重复的代码抽取到父类中，提高代码的复用性

• 子类可以在父类的基础上，增加其他的功能，使子类更强大

什么时候用继承： 当类与类之间，存在相同（共性）的内容，并满足子类是父类的一种时，可以使用继承来优化代码

继承的特点：

• Java只支持单继承：一个子类只能继承一个父类

• 不支持多继承：子类不能同时继承多个父类

• 但支持多层继承：子类A继承父类B，父类B可以继承父类C

• 每一个类都直接或者间接的继承于Object

  public class A {} //默认继承于Object , 相当于 public class A extends Object {}

1.1 继承实践：动物案例

需求分析： 四种动物的行为：

• 布偶猫：吃饭、喝水、抓老鼠

• 中国狸花猫：吃饭、喝水、抓老鼠

• 哈士奇：吃饭、喝水、看家、拆家

• 泰迪：吃饭、喝水、看家、蹭一蹭

画图法: 从下往上看
下面: 子类
上面: 父类
需要把子类中的共性内容抽取到父类中
​
核心:
1、共性内容抽取
2、子类是父类中的一种
​
书写代码: 从上往下写

图像：

代码实现：

//Animal.java
package com.yq.a06oopextendsdemo06;
​
public class Animal {
    //若权限修饰符为 private 则子类无法访问了
​
    //注意事项: 子类只能访问父类中非私有的成员
    public void eat(){
        System.out.println("吃东西");
    }
​
    public void drink(){
        System.out.println("喝水");
    }
}
​
​
//Cat.java
package com.yq.a06oopextendsdemo06;
​
public class Cat extends  Animal{
    public void catchMouse(){
        System.out.println("猫在抓老鼠");
    }
}
​
//Dog.java
package com.yq.a06oopextendsdemo06;
​
public class Dog extends Animal{
    public void lookHome(){
        System.out.println("狗看家");
    }
}
​
​
//Husky.java
package com.yq.a06oopextendsdemo06;
​
public class Husky extends Dog{
    public void breakHome(){
        System.out.println("哈士奇在拆家");
    }
}
​
​
//Lihua,java
package com.yq.a06oopextendsdemo06;
​
public class Lihua extends Cat{
}
​
//Ragdoll.java
package com.yq.a06oopextendsdemo06;
​
public class Ragdoll extends Cat {
}
​
//Teddy.java
package com.yq.a06oopextendsdemo06;
​
public class Teddy extends Dog{
    public void touch(){
        System.out.println("泰迪又在蹭我的腿");
    }
}
​
​
//Test.java
package com.yq.a06oopextendsdemo06;
​
public class Test {
    public static void main(String[] args) {
        //创建对象 并调用方法
​
        //1.创建布偶猫对象
        Ragdoll rd = new Ragdoll();
        rd.eat();
        rd.drink();
        rd.catchMouse();
​
        System.out.println("===========");
        //2.创建哈士奇的对象
        Husky h = new Husky();
        h.eat();
        h.drink();
        h.lookHome();
        h.breakHome();
    }
}
​

2.子类能继承父类的内容：

图像:

2.1 构造方法:

• 非私有不能继承、私有不能继承

//a07oopextendsdemo02
package com.yq.a07oopextendsdemo02;
​
public class Test {
    public static void main(String[] args) {
        //利用空参构造创建子类对象
        zi z1 = new zi();
​
        //利用带参构造 创建子类对象
        //zi z2 = new zi("zhangsan", 23);  //无法创建 因为子类没有继承方法
    }
}
​
class Fu {
    String name;
    int age;
​
    public Fu (){}
    public Fu(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
​
class zi extends Fu{
    //如果一个类中没有构造方法，虚拟机会自动创建一个默认的空参构造方法
}

2.2 成员变量:

• 非私有能继承、私有能继承（但是不能直接使用）

2.1.1 成员变量继承的内存图:

非私有的成员方法: 私有的成员方法: 不能直接使用,图中代码会报错

2.3 成员方法:

• 非私有能继承、私有不能继承

• 虚方法表中的能继承、否则不能继承

从顶级类开始，使用虚方法表(非private, 非static, 非final), 往下每一个方法都在上一级类的虚方法基础上再添加自己类中的虚方法 虚方法：

成员方法继承内存图: fushow2不能直接调用

2.4 内存分析工具:

//a08oopextendsdemo03
package com.yq.a08oopextendsdemo03;
​
import java.io.IOException;
import java.util.Scanner;
​
public class Test {
    public static void main(String[] args) throws IOException {
        Zi z = new Zi();
​
        //把对象的地址值 z以16进制的形式打印在控制台中
        //System.out.println(Long.toHexString(VM.current().affressOf(z)));
​
        //键盘录入 ， 因为内存分析工具需要程序不停止， 让程序一直停在键盘录入
        Scanner sc = new Scanner(System.in);
        sc.next();
    }
}
​
​

3.成员变量的访问特点

就近原则: 谁离我近，我就用谁

public class Fu {
    String name = "Fu";
}
​
public class Zi extends Fu{
    String name = "Zi";
    public void ziShow(){
        String name = "ZiShow";
        System.out.println(name);       //Zishow
        System.out.println(this.name);  //Zi
        System.out.println(super.name); //Fu 使用父类的成员变量
    }
}

package com.yq.a09oopextendsdemo04;
​
public class Test {
    public static void main(String[] args){
        Zi z = new Zi();
        z.ziShow();
    }
}
​
class  Ye {
    String name = "Ye";
}
​
class Fu extends Ye{
    String name = "Fu";
}
​
class Zi extends Fu{
    String name = "Zi";
    public void ziShow(){
        String name = "ziShow";
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}
​

package com.yq.a10oopexetndsdemo05;
​
public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}
​
class Fu {
    String name = "Fu";
    String hobby = "喝茶";
}
​
class Zi extends Fu {
    String name = "Zi";
    String game = "吃鸡";
    public void show(){
        //打印Zi
        System.out.println(name);
        System.out.println(this.name);
​
        //打印Fu
        System.out.println(super.name);
​
        //打印喝茶
        System.out.println(hobby);
        System.out.println(this.hobby);
        System.out.println(super.hobby);
​
        //打印吃鸡
        System.out.println(game);
        System.out.println(this.game);
    }
}
​

总结:

1.继承中成员变量访问特点: 就近原则
      现在局部位置找，本类成员位置找，父类成员位置找，逐级往上
2.如果出现重名的成员变量
    System.out.println(name);
    System.out.println(this.name);
    System.out.println(super.name);
​

4.成员方法的访问特点:

直接调用满足就近原则: 谁离我近，我就用谁
super调用，直接访问父类

4.1 方法的重写:

• 当父类的方法不能满足子类现在的需求时，需要进行方法重写

  书写格式:

  在继承体系中，子类出现了和父类中一模一样的方法声明，则这个方法为方法的重写

@Override重写注解
1.@Override是放在重写后的方法上，校验子类重写时语法是否正确
2.加上注解后，如果有红色波浪线，表示语法错误
3.建议重写方法都加上@Override，代码安全，优雅

package com.yq.a11oopextendsdemo06;
​
​
public class Test {
    public static void main(String[] args) {
        OverseasStudent s = new OverseasStudent();
        s.lunch();
​
        System.out.println("=========");
​
        Student stu = new Student();
        stu.lunch();
    }
}
​
class Person {
    //public Cat eat() { //子类返回值类型小于等于父类, 此处有问题，与子类注释的对应
    public void eat() {
        System.out.println("吃米饭，吃菜");
    }
​
    public void drink() {
        System.out.println("喝开水");
    }
}
​
class OverseasStudent extends Person {
    public void lunch() {
        this.eat();  //吃意大利面
        this.drink(); //喝凉水
​
        super.eat(); //吃米饭，吃菜
        super.drink();  //喝开水
    }
​
    //应用场景：当父类中方法，不能满足子类现在的需求时，则进行方法重写
    //注意：子类中方法重写需要加 @Override 注解
    @Override
    //public Animal eat() { //子类返回值类型小于等于父类, 此处有问题，与父类注释的对应
    public void eat() {
        System.out.println("吃意大利面");
    }
​
    @Override
    public void drink() {
        System.out.println("喝凉水");
    }
}
​
class Student extends Person {
    public void lunch() {
        //方法直接调用 先在本类中查看 eat和drink方法
        //就会调用子类的 如果没有，就会调用父类中继承下来的eat和drink方法
        this.eat();
        this.drink();
​
        //直接调用父类中的方法
        super.eat();
        super.drink();
    }
}
​
​
public class Animal {}
​
public class Cat extends Animal {}
​
public class Dog extends Animal {}
​

4.2 方法重写的本质:

• 子类覆盖了虚方法表中的方法

注意事项: 1.重写方法的名称、形参列表必须与父类中完全一致 2.子类重写父类方法时，访问权限 子类必须大于等于父类(暂时了解: 空着不写 < protected < public) 3.子类重写父类方法时，返回值类型必须小于等于父类 4.建议：重写方法尽量和父类保持一致 5.只有被添加到虚方法表中的方法才能被重写(前提: 继承)

4.3 练习：利用方法重写设计继承结构

现在有三种动物：哈士奇、沙皮狗、中华田园犬
暂时不考虑属性，只考虑行为，按照继承的思想特点进行继承体系的设计
​
三种动物分别有以下的行为：
哈士奇：    吃饭（吃狗粮）、        喝水、看家、拆家
沙皮狗：    吃饭（吃狗粮、吃骨头）、喝水、看家
中华田园犬: 吃饭（吃剩饭）、    喝水、看家

package com.yq.a12oopextendsdemo07;
​
public class Test {
    public static void main(String[] args) {
        Husky h = new Husky();
        System.out.println("哈士奇");
        h.eat();
        h.drink();
        h.lookHome();
        h.breakHome();
        System.out.println();
​
        SharPai s = new SharPai();
        System.out.println("沙皮狗");
        s.eat();
        s.drink();
        s.lookHome();
        System.out.println();
​
        ChineseDog c = new ChineseDog();
        System.out.println("中华田园犬");
        c.eat();
        c.drink();
        c.lookHome();
​
    }
}
​
class Dog {
    public void eat() {
        System.out.println("狗在吃狗粮");
    }
​
    public void drink() {
        System.out.println("狗在喝水");
    }
​
    public void lookHome() {
        System.out.println("狗在看家");
    }
}
​
class Husky extends Dog {
    public void breakHome(){
        System.out.println("狗在拆家");
    }
}
​
class SharPai extends Dog {
    @Override
    public void eat(){
        super.eat(); //吃狗粮
        System.out.println("狗啃骨头");
    }
}
​
class ChineseDog extends Dog {
    @Override
    public void eat(){
        System.out.println("狗在吃剩饭");
    }
}

5.构造方法的访问特点

• 父类中的构造方法不会被子类继承,但是可以通过super调用

• 子类构造方法的第一行，有一个默认的super();

• 子类中所有的构造方法，默认先访问父类中的无参构造，再执行自己

• 如果想要调用父类的有参构造，必须手动书写super(); 并传递参数

//Person.java
package com.yq.a13oopextendsedmo08;
​
public class Person {
    String name;
    int age;
​
    public Person() {
        System.out.println("父类的无参构造");
    }
​
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
​

//Student.java
package com.yq.a13oopextendsedmo08;
​
public class Student extends Person{
    public Student(){
        //子类构造方法中，隐藏的super()去访问父类的无参构造
        super();
        System.out.println("子类的无参构造");
    }
​
    public Student (String name, int age){
        super(name,age);
    }
}
​

//Test.java
package com.yq.a13oopextendsedmo08;
​
public class Test {
    public static void main(String[] args) {
        //创建学生对象
        //Student s = new Student();
        Student s = new Student("zhangsan", 23);
        System.out.println(s.name + ", " + s.age);
    }
}
​

6.this super使用总结

this: 理解为一个变量，表示当前方法调用者的地址值
super: 代表父类存储空间

6.1 this本类其他构造

（当需要给一些数据默认值时，可以使用）

//Student.java
package com.yq.a15oopextendsdemo10;
​
public class Student {
    String name;
    int age;
    String school;
​
    //需求: 默认为传智大学
    public  Student(){
        //表示调用本类其他构造方法
        //细节: 虚拟机就不会添加super();
        this(null, 0, "传智大学");
    }
​
    public Student(String name, int age, String school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }
​
}
​
//Test.java
package com.yq.a15oopextendsdemo10;
​
public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.school);
    }
}
​

6.2 练习: 带有继承结构的标准JavaBean类

1.经理
    成员变量: 员工、姓名、工资、管理奖金
    成员方法：工作(管理其他人)、吃饭(吃米饭)
2.厨师
    成员变量: 工号、姓名、工资
    成员方法: 工作(炒菜)、吃饭(吃米饭)

//Employee.java
package com.yq.a16oppextendsdemo11;
​
public class Cook extends Employee{
    public Cook() {
    }
​
    public Cook(String id, String name, double salary) {
        super(id, name, salary);
    }
​
    @Override
    public void work() {
        System.out.println("厨师正在炒菜");
    }
}
​
//Manager.java
package com.yq.a16oppextendsdemo11;
​
public class Manager extends Employee{
    private double bouns;
​
    public  Manager(){}
​
    //带全部参数的构造
    //父类+子类
    public Manager(String id, String name, double salary, double bouns) {
        super(id, name, salary);
        this.bouns = bouns;
    }
​
    public double getBouns() {
        return bouns;
    }
​
    public void setBouns(double bouns) {
        this.bouns = bouns;
    }
​
    @Override
    public void work() {
        System.out.println("管理其他人");
    }
}
​
//Cook.java
package com.yq.a16oppextendsdemo11;
​
public class Cook extends Employee{
    public Cook() {
    }
​
    public Cook(String id, String name, double salary) {
        super(id, name, salary);
    }
​
    @Override
    public void work() {
        System.out.println("厨师正在炒菜");
    }
}
​
//Test.java
package com.yq.a16oppextendsdemo11;
​
public class Test {
    public static void main(String[] args) {
        //创建对象并复制调用
        Manager m = new Manager("heima001", "zhangsan", 15000, 8000);
​
        System.out.println(m.getId() + ", " + m.getName() +
                ", " + m.getSalary() + ", " + m.getBouns());
        m.work();
        m.eat();
​
        Cook c = new Cook();
        c.setId("heima002");
        c.setName("lisi");
        c.setSalary(8000);
        System.out.println(c.getId() + ", " + c.getName() + ", " + c.getSalary());
​
        c.work();
        c.eat();
​
    }
}
​

6.3 练习: 带有继承结构的标准Javabean类

有很多员工(Employee)
按照工作内容不同，分为教研员工(Teacher)和行政员工(AdminStaff)
1.教研部根据教学的方式不同又分为讲师(Lecturer)和助教(Tutor)
2.行政部根据负责事项不同，又分为维护专员(Maintainer),采购员(Buyer)
3.公司的每一个员工都有编号,姓名和其负责的工作
4.每个员工都有工作的功能，但是具体的工作内容又不一样

//Employee.java
package com.yq.a17oopextendsdemo12;
​
public class Employee {
    private String id;
    private String name;
​
    public Employee() {
    }
​
    public Employee(String id, String name) {
        this.id = id;
        this.name = name;
    }
​
    public String getId() {
        return id;
    }
​
    public void setId(String id) {
        this.id = id;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public void work(){
        System.out.println("员工在工作");
    }
}
​
//Teacher.java
package com.yq.a17oopextendsdemo12;
​
public class Teacher extends Employee{
    public Teacher() {
    }
​
    public Teacher(String id, String name) {
        super(id, name);
    }
}
​
//AdminStaff.java
package com.yq.a17oopextendsdemo12;
​
public class AdminStaff extends Employee{
    public AdminStaff() {
    }
​
    public AdminStaff(String id, String name) {
        super(id, name);
    }
}
​
//Lecturer.java
package com.yq.a17oopextendsdemo12;
​
public class Lecturer extends Teacher{
    public Lecturer() {
    }
​
    public Lecturer(String id, String name) {
        super(id, name);
    }
​
    @Override
    public void work() {
        System.out.println("给学生讲课");
    }
}
​
//Tutor.java
package com.yq.a17oopextendsdemo12;
​
public class Tutor extends Teacher{
    public Tutor() {
    }
​
    public Tutor(String id, String name) {
        super(id, name);
    }
​
    @Override
    public void work() {
        System.out.println("辅导学生完成作业");
    }
}
​
//Maintainer.java
package com.yq.a17oopextendsdemo12;
​
public class Maintainer extends AdminStaff{
    public Maintainer() {
    }
​
    public Maintainer(String id, String name) {
        super(id, name);
    }
​
    @Override
    public void work() {
        System.out.println("维护设备安全");
    }
}
​
//Buyer.java
package com.yq.a17oopextendsdemo12;
​
public class Buyer extends AdminStaff{
    public Buyer() {
    }
​
    public Buyer(String id, String name) {
        super(id, name);
    }
​
    @Override
    public void work() {
        System.out.println("采购设备");
    }
}
​
​
//Test.java
package com.yq.a17oopextendsdemo12;
​
public class Test {
    public static void main(String[] args) {
        Lecturer l = new Lecturer("heima001", "zhangsan");
        System.out.println(l.getId() + ", " + l.getName());
        l.work();
        System.out.println("=====");
​
        Tutor t = new Tutor("heima002", "lisi");
        System.out.println(t.getId() + ", " + t.getName());
        t.work();
        System.out.println("=====");
​
        Maintainer m = new Maintainer();
        m.setId("heima003");
        m.setName("wangwu");
        System.out.println(m.getId() + ", " + m.getName());
        m.work();
        System.out.println("=====");
​
        Buyer b = new Buyer();
        b.setId("heima004");
        b.setName("zhaoliu");
        System.out.println(b.getId() + ", " + b.getName());
        b.work();
        System.out.println("=====");
​
    }
}
​