Java面向对象（高级）-- 抽象类与抽象方法(或abstract关键字)

文章目录

一、抽象类的由来
- （1）举例1
- （2）举例2
二、案例引入
- （1）抽象类
- （2）抽象方法
- （3）补充1
- （4）补充2
- （5）举例
- - 1. 举例1
  - 2. 举例2
三、抽象类与抽象方法
- （1）语法格式
- （2）使用说明
- （3）注意事项
- - 1. abstract不能使用的场景
- （4）应用举例
- - 1. 举例1 航运
  - 2. 举例2 模板方法设计模式
  - - 2.1 描述
    - 2.2 案例1
    - 2.3 案例2
    - 2.4 案例3
    - 2.5 案例4
四、练习
- （1）练习1
- （2）练习2

一、抽象类的由来

（1）举例1

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。

类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

将父类加上abstract标识之后，就不用用它造对象。

💬既然父类抽象了，功能也并不具体，子类也需要重写它的方法才好具体使用。那为啥还需要父类呢？

1、父类中的一些方法，子类确实会重写，但也会存在一些方法子类直接拿去用。若没有父类，每个子类就都需要自己写。

2、父类的属性子类可以直接拿来用，若没有父类，子类还需要自己去声明。

3、多态的使用前提，基于继承性，比如一个方法的形参就是Person类型的，真正调用方法的时候，传进来的却是具体子类的对象。不管传什么子类对象，都赋给了Person。若是没有父类，那就麻烦了，一堆方法需要一个个写，不靠谱。

所以继承关系还是需要的，在继承的前提下，这个抽象类只是表明父类不想实例化了。

（2）举例2

我们声明一些几何图形类：圆、矩形、三角形类等，发现这些类都有共同特征：求面积、求周长。

那么这些共同特征应该抽取到一个共同父类：几何图形类中。

但是这些方法在父类中又无法给出具体的实现（因为不知道具体什么图形），而是应该交给子类各自具体实现。

那么父类在声明这些方法时，就只有方法签名，没有方法体（具体的需要子类去重写），我们把没有方法体的方法称为抽象方法。

Java语法规定，包含抽象方法的类必须是抽象类。

二、案例引入

（1）抽象类

先将继承关系表示出来：

【Person.java】

package yuyi08;

/**
 * ClassName: Person
 * Package: yuyi08
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/23 0023 13:13
 */
public class Person {
    String name;
    int age;

    //构造器
    public Person(){

    }

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

    //方法
    public void eat(){
        System.out.println("人吃饭");
    }

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

}

【Student.java】

package yuyi08;

/**
 * ClassName: Student
 * Package: yuyi08
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/23 0023 13:15
 */
public class Student extends Person{
    String school;

    public Student() {

    }

    public Student(String name, int age, String school) {
        super(name, age);
        this.school = school;
    }

    public void eat(){
        System.out.println("学生多吃有营养的食物");
    }

    public void sleep(){
        System.out.println("学生不要熬夜");
    }
}

【AbstractTest.java】

package yuyi08;

/**
 * ClassName: AbstractTest
 * Package: yuyi08
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/23 0023 13:17
 */
public class AbstractTest {
    public static void main(String[] args) {
        Person p1=new Person();
        p1.eat();

        Student s1=new Student();
        s1.eat();
    }
}

输出结果：

现在在现有的class Person前面加上abstract。

Person类就叫做抽象类。意味着它不能够实例化了。

上一节说了final，final也可以用来修饰Person，表示不能有子类。

现在这个可以有子类的，只是不能造对象了。

可以看到，这里就报错了：

既然不能造方法，那么此时方法也自然不能调用了。

单例模式只造一次对象，抽象类是禁止造对象。

（2）抽象方法

随着Person提供的子类越来越丰富，Person里面的eat()方法都不用指明具体怎么吃了，具体的子类会指明。

所以在Person里面，只需要声明了就行。

表示有这个功能，具体怎么吃不确定，需要子类重写它。

比如，现在在eat()方法前面加上abstract，如下：

此时会报错，因为抽象方法不能有方法体。（代码连着花括号一块都不能要）

这样即可：（表明此方法是抽象方法）

既然这个抽象方法没有方法体了，那么它也就不应该被调用了。

在子类Student中将父类Person中的eat()方法重写了，可以发现这里的符号变了，抽象方法的重写换了一个词儿，叫Implements（实现），而之前的重写叫Overrides（重写）。

这里就不讲究那么多了，都叫重写也没什么毛病。

所以，在子类中，将父类的抽象方法给重写了，不耽误后面子类正常调用。

Java语法规定，包含抽象方法的类必须是抽象类。

刚才我们先说的是抽象类，表示该类不能被实例化了。然后说的是抽象方法，不能有方法体。没有任何问题。

但现在方法是抽象的，若是该类不是抽象的，就会报错，如下:

什么原因呢？

抽象方法没有方法体，那么这个方法就不应该被调用。

现在的方法是非静态方法，按道理说拿对象是可以调用它的。

现在既然不给调用抽象方法，那么就别有对象了。

如何保证这个类没有对象？删掉构造器？不行，就算没有写构造器，也会有默认的空参构造器，没有意义。那就限制该类呗，那就抽象，抽象类没有对象。

所以，抽象方法所属的类也是抽象类，因为这样就不能造对象了。

抽象方法存在的原因，主要是在多态应用中，对象只能调用父类中已有的方法，子类自己写的方法不能调用，所以要在抽象父类中声明抽象方法。

（3）补充1

若此时，我们将sleep()方法也抽象化：

重新建一个Worker类，继承于Person类，会发现报错，如下：

以前是构造器的问题，但现在构造器没有问题。（有空参构造器）

看报错信息可知，要么将Worker类声明为抽象类，要么实现Person中的抽象方法eat()。

因为子类Worker将父类中的两个抽象方法继承过来了。

所以，

第一种解决方法：将Worker类声明为抽象类

public abstract class Worker extends Person{

}

第二种解决方法：实现Person中的抽象方法eat()

public  class Worker extends Person{
    @Override
    public void eat() {

    }

    @Override
    public void sleep() {
        
    }

}

【小Tips】

将光标放在Worker上，Alter+Enter，然后点击“实现方法”：

将两个都选中，点击“确定”：

然后就可以自动生成啦：

当然，只重写了一个方法也会报错，如下：

（4）补充2

现在【Worker.java】代码写成这样的：

package yuyi08;

public  abstract class Worker extends Person{   //只重写了一个父类抽象方法，还是抽象类

    @Override
    public void eat() {
        System.out.println("工人很辛苦，多吃饭");
    }

    /*@Override
    public void sleep() {

    }*/

}

再写一个Creature类：

package yuyi08;

public abstract class Creature { //生物类
    public abstract void breath();  //呼吸

}

现在将Person类继承于Creature，此时Person里面就包含Creature的抽象方法breath()。

此时会报错！

//报错了
public abstract class Person extends Creature {  //抽象类
    String name;
    int age;

    //构造器
    public Person(){

    }

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

    //方法
    public abstract void eat(); //抽象方法

    public abstract void sleep();

}

学生类Student继承于Person的，除了将Person类中的抽象方法重写了，要想实例化，此时必须将breath()也给重写一下才不会报错。

如下：

现在Student类中，将直接父类Person和间接父类Creature的抽象方法都做了重写，如下：

package yuyi08;

public class Student extends Person{
    String school;

    public Student() {

    }

    public Student(String name, int age, String school) {
        super(name, age);
        this.school = school;
    }

    public void eat(){
        System.out.println("学生多吃有营养的食物");
    }

    public void sleep(){
        System.out.println("学生不要熬夜");
    }

    @Override
    public void breath() {
        System.out.println("学生要多呼吸新鲜空气");
    }
}

那么就可以用Student类去造对象了。

当然，若是父类Person已经将breath()方法重写了，在Student类中不重写breath()也可以（不会报错）。

对于Worker类来说，它有三个方法，从Person类中继承来的（Person两个，Creature一个）。此时只重写了一个，剩下两个还是抽象的，所以Worker还只能是抽象类。

【Worker.java】

package yuyi08;

public  abstract class Worker extends Person{   //只重写了一个父类抽象方法，还是抽象类

    @Override
    public void eat() {
        System.out.println("工人很辛苦，多吃饭");
    }

}

既然Worker类是抽象类，那么就不能去造对象。如下：

（5）举例

抽象类需要有子类，自己不能造对象，写了一些方法（抽象方法和非抽象方法），这些抽象方法想要用就需要造对象，自己造不了对象了，就只能造子类对象啦。言外之意就是抽象类必须有子类。

1. 举例1

举例1：GeometricObject-Circle-Rectangle

父类【GeometricObject.java】

abstract class GeometricObject{  //几何图形
    //求面积 （只能考虑提供方法的声明，而没有办法提供方法体。所以，此方法适合声明为抽象方法）
    
    //求周长（只能考虑提供方法的声明，而没有办法提供方法体。所以，此方法适合声明为抽象方法）
}

子类1【Circle.java】

class Circle extends GeometricObject{
    //求面积 （必须重写（或实现）父类中的抽象方法）
    
    //求周长（必须重写（或实现）父类中的抽象方法）
}

子类2【Rectangle.java】

子类要么是抽象类，要么就需要重写父类中的抽象方法。

class Rectangle extends GeometricObject{
    //求面积 （必须重写（或实现）父类中的抽象方法）
    
    //求周长（必须重写（或实现）父类中的抽象方法）
}

2. 举例2

举例2：Account-SavingAccount-CheckAcount

父类【Account.java】

abstract class Account{

    double balance;//余额

    //取钱 （声明为抽象方法）

    //存钱 （声明为抽象方法）

}

子类1【SavingAccount.java】

class SavingAccount extends Account{ //储蓄卡
    //取钱 （需要重写父类中的抽象方法）

    //存钱（需要重写父类中的抽象方法）
}

子类2【CheckAccount.java】

class CheckAccount extends Account{ //信用卡
    //取钱（需要重写父类中的抽象方法）

    //存钱（需要重写父类中的抽象方法）
}
//....

三、抽象类与抽象方法

（1）语法格式

abstract的概念：抽象的

abstract可以用来修饰：类、方法

抽象类：被abstract修饰的类。
抽象方法：被abstract修饰没有方法体的方法。

①抽象类的语法格式

[权限修饰符] abstract class 类名{
    
}
[权限修饰符] abstract class 类名 extends 父类{
    
}

abstract修饰类：
> 此类称为抽象类。
> 抽象类不能实例化（不能造对象）。
> 抽象类中是包含构造器的，因为子类对象实例化时，需要直接或间接的调用到父类的构造器。
> 抽象类中可以没有抽象方法（仅仅表明抽象类不能造对象）。反之，抽象方法所在的类，一定是抽象类。

构造器是用来对对象进行初始化的，即为实例变量初始化，赋初值，而不是用来创建对象的，创建对象用new关键字。（子类在造对象的时候，还是要加载父类的结构–调用构造器的时候加载）

②抽象方法的语法格式

[其他修饰符] abstract 返回值类型 方法名([形参列表]);

abstract修饰方法：
> 此方法即为抽象方法。
> 抽象方法只有方法的声明，没有方法体。
> 抽象方法其功能是确定的（通过方法的声明即可确定），只是不知道如何具体实现（体现为没有方法体）。
> 子类必须重写父类中的所有的抽象方法之后，方可实例化。否则，此子类仍然是一个抽象类。

注意：抽象方法没有方法体。

抽象方法虽然没有声明，但是这个方法的功能已经确定了，只不过没有方法体（不知道功能该如何实现）而已。

代码举例：

public abstract class Animal {
    public abstract void eat();
}

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

public class CatTest {
 	 public static void main(String[] args) {
        // 创建子类对象
        Cat c = new Cat(); 
       
        // 调用eat方法
        c.eat();
  	}
}

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

基于继承以后，将代码改造了一下，父类不能实例化，里面有抽象方法。将造对象的事情交给子类，让子类继承父类之后，要是没有将父类中的抽象方法都给重写，就会报错。（要么全部重写了，要么也变成抽象类）

（2）使用说明

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

抽象类中，也有构造方法，是供子类创建对象时，初始化父类成员变量使用的。

理解：子类的构造方法中，有默认的super()或手动的super(实参列表)，需要访问父类构造方法。

抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

（3）注意事项

1. abstract不能使用的场景

<1> abstract 不能修饰哪些结构？

属性、构造器、代码块等。

<2> abstract 不能与哪些关键字共用？（自洽）

不能用abstract修饰私有方法、静态方法、final的方法、final的类。

①私有方法不能重写

若abstract修饰了一个方法，这个方法一定要让子类去重写的，否则就造不了对象了。

②静态方法不能重写

避免静态方法使用类进行调用

一般我们是这样来写的，如下：

此时将method()方法私有化是不可以的，如下：

那用static修饰呢？

静态方法（static）本来就可以通过类来调；而抽象方法（abstract）没有方法体，这个方法就不能被调。

所以不能用static和abstract组合。

抽象方法只有声明，没有方法体，这个方法不能被调。

调用方法的有“类.”和“对象.”两种方法。若此时不让调方法，那就让这两件事做不了。

不让对象去调用，就让类为抽象类，它就没有对象了，自然就不能用对象去调用什么方法；不让类去调用，这个方法就不要是静态方法，就不能拿类去调用了。

所以刚才就不能静态，因为静态（用static修饰）了，它就可以被类调用，而此时此方法又被abstract修饰，意味着它是抽象类不能被调用。矛盾呐。

静态方法可以直接用类名调用，抽象方法不能调用。

③final的方法不能被重写

abstract修饰的方法一定要被重写，否则就不能造对象。

所以final与abstract水火不容。

④final修饰的类不能有子类

abstract修饰的类一定要有子类，否则也造不了对象，而且自己也造不了，那有何用呢？

（4）应用举例

1. 举例1 航运

在航运公司系统中，Vehicle类需要定义两个方法分别计算运输工具的燃料效率和行驶距离。

问题：卡车(Truck)和驳船(RiverBarge)的燃料效率和行驶距离的计算方法完全不同。Vehicle类不能提供计算方法，但子类可以。

解决方案：Java允许类设计者指定：超类声明一个方法但不提供实现，该方法的实现由子类提供。这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。

//Vehicle是一个抽象类，有两个抽象方法。
public abstract class Vehicle{
	public abstract double calcFuelEfficiency();	//计算燃料效率的抽象方法
    
	public abstract double calcTripDistance();	//计算行驶距离的抽象方法
}

public class Truck extends Vehicle{
	public double calcFuelEfficiency( )   { //写出计算卡车的燃料效率的具体方法   }
        
	public double calcTripDistance( )    {  //写出计算卡车行驶距离的具体方法   }
}
        
public class RiverBarge extends Vehicle{
	 public double calcFuelEfficiency( ) { //写出计算驳船的燃料效率的具体方法  }
         
	 public double calcTripDistance( )  {  //写出计算驳船行驶距离的具体方法}
}

2. 举例2 模板方法设计模式

2.1 描述

应用举例2：模板方法设计模式(TemplateMethod)

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

解决的问题：

当功能内部一部分实现是确定的（非抽象），另一部分实现是不确定的（抽象化）。这时可以把不确定的部分暴露出去，让子类去实现。（父类中有方法体的都是确定的，没有方法体的都是不确定的）
换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

类比举例：英语六级模板

制作月饼的模板：

2.2 案例1

🌱计算代码运行时间

package yuyi09;

/**
 * ClassName: TemplateTest
 * Package: yuyi09
 * Description:
 *      抽象应用案例：模板方法的设计模式
 * @Author 雨翼轻尘
 * @Create 2023/11/24 0024 10:03
 */
public class TemplateTest {
    public static void main(String[] args) {
        PrintPrimeNumber p=new PrintPrimeNumber();
        p.spendTime();  //现在想算一下代码花费了多长时间，调用spendTime()是父类中的方法，在执行code()时是子类重写的方法（已经将原来父类中的覆盖了）
    }
}

//父类
abstract class Template{
    //计算某段代码的执行，需要花费的时间
    public void spendTime(){    //花费的时间
        long start= System.currentTimeMillis(); //记录开始时间

        code(); //代码执行完

        long end=System.currentTimeMillis();    //记录结束时间

        System.out.println("花费时间为："+(end-start));
    }

    //代码不确定，不妨将它写到方法中
    public abstract void code();
}

//子类
class PrintPrimeNumber extends Template{
    //输出质数
    @Override
    public void code() {
        for (int i = 2; i <=100000 ; i++) {
            boolean isFlag=true;
            for (int j = 2; j <=Math.sqrt(i) ; j++) {
                if(i%j==0){
                    isFlag=false;
                    break;
                }
            }
            if(isFlag){
                System.out.println(i);
            }
        }
    }
}

👻输出结果（部分）

2.3 案例2

🌱银行相关模板

package yuyi09;
//抽象类的应用：模板方法的设计模式


//测试类
public class TemplateMethodTest {

	public static void main(String[] args) {
		BankTemplateMethod btm = new DrawMoney();	//若想取钱，就new一个抽象类的子类，可以赋给父类（也可以不赋）
		btm.process();	//new的子类也继承了父类的process()方法，其中办理业务的transact()方法是子类重写的方法，其他的继承父类中的

		System.out.println();	//换个行喽

		BankTemplateMethod btm2 = new ManageMoney();
		btm2.process();
	}
}

//父类--模板
abstract class BankTemplateMethod {
	// 具体方法
	public void takeNumber() {
		System.out.println("取号排队");
	}

	public abstract void transact(); // 办理具体的业务，不确定每个人所办理的业务，将它抽象化

	public void evaluate() {
		System.out.println("反馈评分");
	}

	// 模板方法，把基本操作组合到一起，子类一般不能重写
	public final void process() {	//流程   加了final，不要重写了
		this.takeNumber();	//取号

		this.transact();// 办理业务，每个人不一样（像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码）

		this.evaluate();	//反馈评分
	}
}

//取钱--子类
class DrawMoney extends BankTemplateMethod {
	//将父类中的抽象方法重写
	public void transact() {
		System.out.println("我要取款！！！");
	}
}

//理财--子类
class ManageMoney extends BankTemplateMethod {
	//将父类中的抽象方法重写
	public void transact() {
		System.out.println("我要理财！我这里有2000万美元!!");
	}
}

👻输出结果

2.4 案例3

abstract class Template {
    public final void getTime() {
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        System.out.println("执行时间是：" + (end - start));
    }

    public abstract void code();
}

class SubTemplate extends Template {
    public void code() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
    }
}

2.5 案例4

package com.atguigu.java;
//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {

	public static void main(String[] args) {
		BankTemplateMethod btm = new DrawMoney();
		btm.process();

		BankTemplateMethod btm2 = new ManageMoney();
		btm2.process();
	}
}
abstract class BankTemplateMethod {
	// 具体方法
	public void takeNumber() {
		System.out.println("取号排队");
	}

	public abstract void transact(); // 办理具体的业务 //钩子方法

	public void evaluate() {
		System.out.println("反馈评分");
	}

	// 模板方法，把基本操作组合到一起，子类一般不能重写
	public final void process() {
		this.takeNumber();

		this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码

		this.evaluate();
	}
}

class DrawMoney extends BankTemplateMethod {
	public void transact() {
		System.out.println("我要取款！！！");
	}
}

class ManageMoney extends BankTemplateMethod {
	public void transact() {
		System.out.println("我要理财！我这里有2000万美元!!");
	}
}

模板方法设计模式是编程中经常用得到的模式。各个框架、类库中都有他的影子，比如常见的有：

数据库访问的封装
Junit单元测试
JavaWeb的Servlet中关于doGet/doPost方法调用
Hibernate中模板程序
Spring中JDBCTemlate、HibernateTemplate等

四、练习

（1）练习1

🌋题目描述

针对多态性的练习题1：GeometricObject等类进行升级，体现抽象的使用。

【Circle.java】

package yuyi10;

/**
 * ClassName: Circle
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 8:51
 * @Version 1.0
 */
public class Circle extends GeometricObject {

    private double radius;//半径

    public Circle(String color, double weight, double radius) {
        super(color, weight);
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public double findArea() {
        return 3.14 * radius * radius;
    }
}

【GeometricObject.java】

package yuyi10;

/**
 * ClassName: GeometricObject
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 8:47
 * @Version 1.0
 */
public class GeometricObject {
    protected String color;
    protected double weight;

    protected GeometricObject(String color, double weight) {
        this.color = color;
        this.weight = weight;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public double findArea(){
        return 0.0;
    }
}

【MyRectangle.java】

package yuyi10;

/**
 * ClassName: MyRectangle
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 8:53
 * @Version 1.0
 */
public class MyRectangle extends GeometricObject {

    private double width;//宽
    private double height;//高

    public MyRectangle(String color, double weight, double width, double height) {
        super(color, weight);
        this.width = width;
        this.height = height;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public double findArea() {

        return width * height;
    }
}

【GeometricTest.java】

package yuyi10;

/**
 * ClassName: GeometricTest
 * Description:
 *      编写equalsArea方法测试两个对象的面积是否相等（注意方法的参数类型），
 *      编写displayGeometricObject方法显示对象的面积（注意方法的参数类型）。
 * @Author 雨翼轻尘
 * @Create 8:55
 * @Version 1.0
 */
public class GeometricTest {

    public static void main(String[] args) {
        GeometricTest test = new GeometricTest();

        Circle c1 = new Circle("red",1.0,2.3);
        Circle c2 = new Circle("red",1.0,3.3);

        test.displayGeometricObject(c1);
        test.displayGeometricObject(c2);

        boolean isEquals = test.equalsArea(c1,c2);
        if(isEquals){
            System.out.println("面积相等");
        }else{
            System.out.println("面积不相等");
        }

        //使用匿名对象
        test.displayGeometricObject(new MyRectangle("blue",1.0,2.3,4.5));

    }

    /**
     * 比较两个几何图形的面积是否相等
     * @param g1
     * @param g2
     * @return true:表示面积相等   false:面积不相等
     */
    public boolean equalsArea(GeometricObject g1, GeometricObject g2){
        return g1.findArea() == g2.findArea();
    }

    /**
     * 显示几何图形的面积
     * @param g
     */
    public void displayGeometricObject(GeometricObject g){ //GeometricObject g = new Circle("red",1.0,2.3);
        System.out.println("几何图形的面积为：" + g.findArea()); //动态绑定  <---> 静态绑定
    }
}

🌴分析

当初在写几何图形GeometricObject的时候，其中有一个求面积的方法findArea()，当时还纠结返回什么，现在来看根本不需要提供它的方法体。因为不确定，所以可以抽象化。同样，当前类也是抽象类了。

【GeometricObject.java】

public abstract class GeometricObject {
    protected String color;
    protected double weight;

    protected GeometricObject(String color, double weight) {
        this.color = color;
        this.weight = weight;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public abstract double findArea();
}

因为之前子类都重写过findArea()方法了，所以后续不用改了。

在抽象这块，一定要用多态。

🍺输出结果

（2）练习2

🌋题目描述

编写工资系统，实现不同类型员工(多态)的按月发放工资。如果当月出现某个Employee对象的生日，则将该雇员的工资增加100元。

实验说明：

（1）定义一个Employee类，该类包含：

private成员变量name,number,birthday，其中birthday 为MyDate类的对象；

abstract方法earnings()；

toString()方法输出对象的name,number和birthday。

（2）MyDate类包含:

private成员变量year,month,day ；

toDateString()方法返回日期对应的字符串：xxxx年xx月xx日

（3）定义SalariedEmployee类继承Employee类，实现按月计算工资的员工处理。

该类包括：private成员变量monthlySalary；

实现父类的抽象方法earnings(),该方法返回monthlySalary值；

toString()方法输出员工类型信息及员工的name，number,birthday。

（4）参照SalariedEmployee类定义HourlyEmployee类，实现按小时计算工资的员工处理。该类包括：

private成员变量wage和hour；

实现父类的抽象方法earnings(),该方法返回wage*hour值；

toString()方法输出员工类型信息及员工的name，number,birthday。

（5）定义PayrollSystem类，创建Employee变量数组并初始化，该数组存放各类雇员对象的引用。

利用循环结构遍历数组元素，输出各个对象的类型,name,number,birthday,以及该对象生日。

当键盘输入本月月份值时，如果本月是某个Employee对象的生日，还要输出增加工资信息。

//提示：
//定义People类型的数组People c1[]=new People[10];
//数组元素赋值
c1[0]=new People("John","0001",20);
c1[1]=new People("Bob","0002",19);
//若People有两个子类Student和Officer，则数组元素赋值时，可以使父类类型的数组元素指向子类。
c1[0]=new Student("John","0001",20,85.0);
c1[1]=new Officer("Bob","0002",19,90.5);

🌱代码

【Employee.java】

package yuyi11;

/**
 * ClassName: Employee
 * Package: yuyi11
 * Description:
 *      private成员变量name,number,birthday，其中birthday 为MyDate类的对象；
 *      提供必要的构造器；
 *      abstract方法earnings(),返回工资数额；
 *      toString()方法输出对象的name,number和birthday。
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/24 0024 16:21
 */
public abstract class Employee {
    private String name;
    private int number;
    private MyDate birthday;

    public Employee() {

    }

    public Employee(String name, int number, MyDate birthday) {
        this.name = name;
        this.number = number;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    public abstract double earnings();

    public String toString(){
        return "name= "+name +",number= "+number
        +",birthday= "+birthday.toDateString(); //注意birthday的调用
    }

}

【MyDate.java】

package yuyi11;

/**
 * ClassName: MyDate
 * Package: yuyi11
 * Description:
 *      private成员变量year,month,day；
 *      提供必要的构造器；
 *      toDateString()方法返回日期对应的字符串：xxxx年xx月xx日
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/24 0024 16:22
 */
public class MyDate {
    private int year;
    private int month;
    private int day;

    public MyDate() {

    }

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public String toDateString(){
        return year +"年" +month +"月"+day+"日";
    }
}

【SalariedEmployee.java】

package yuyi11;

/**
 * ClassName: SalariedEmployee
 * Package: yuyi11
 * Description:
 *      定义SalariedEmployee类继承Employee类，实现按月计算工资的员工处理。
 *      该类包括：private成员变量monthlySalary；
 *      提供必要的构造器；
 *      实现父类的抽象方法earnings(),该方法返回monthlySalary值；
 *      toString()方法输出员工类型信息及员工的name，number,birthday。
 *      比如：SalariedEmployee[name = '',number = ,birthday=xxxx年xx月xx日]
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/25 0025 8:34
 */
public class SalariedEmployee extends Employee{
    private double monthlySalary;   //月工资

    public SalariedEmployee(){

    }

    @Override
    public double earnings() {
        return monthlySalary;
    }

    public SalariedEmployee(String name,int number,MyDate birthday,double monthlySalary){
        super(name,number,birthday);
        this.monthlySalary=monthlySalary;
    }

    public void setMonthlySalary(double monthlySalary){
        this.monthlySalary=monthlySalary;
    }

    /*public double getMonthlySalary(){
        return monthlySalary;
    }*/

    public String toString(){
        return "SalariedEmployee[" + super.toString() +"]"; //注意这里要加super
    }

}

【HourlyEmployee.java】

package yuyi11;

/**
 * ClassName: HourlyEmployee
 * Package: yuyi11
 * Description:
 *      参照SalariedEmployee类定义HourlyEmployee类，实现按小时计算工资的员工处理。该类包括：
 *      private成员变量wage和hour；
 *      提供必要的构造器；
 *      实现父类的抽象方法earnings(),该方法返回wage*hour值；
 *      toString()方法输出员工类型信息及员工的name，number,birthday。
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/25 0025 8:45
 */
public class HourlyEmployee extends Employee{
    private double wage;    //单位小时工资
    private int hour;    //月工作的小时数

    public HourlyEmployee() {

    }

    public HourlyEmployee(String name, int number, MyDate birthday, double wage, int hour) {
        super(name, number, birthday);
        this.wage = wage;
        this.hour = hour;
    }

    public double getWage() {
        return wage;
    }

    public void setWage(double wage) {
        this.wage = wage;
    }

    public int getHour() {
        return hour;
    }

    public void setHour(int hour) {
        this.hour = hour;
    }

    @Override
    public double earnings() {
        return wage * hour;
    }

    public String toString(){
        return "HourlyEmployee[" + super.toString() +"]"; //注意这里要加super
    }
}

【PayrollSystem.java】

package yuyi11;

import java.util.Scanner;

/**
 * ClassName: PayrollSystem
 * Package: yuyi11
 * Description:
 *      定义PayrollSystem类，创建Employee变量数组并初始化，该数组存放各类雇员对象的引用。
 *      利用循环结构遍历数组元素，输出各个对象的类型,name,number,birthday,以及该对象生日。
 *      当键盘输入本月月份值时，如果本月是某个Employee对象的生日，还要输出增加工资信息。
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/25 0025 8:51
 */
public class PayrollSystem {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);


        //abstract类型的不能创建对象，但是可以创建抽象类数组，然后将子类实例化对象放进去
        Employee[] emps=new Employee[2];    //这里并没有实例化，只是在堆内存开辟了数组空间emps，用来加载Employee类

        emps[0]=new SalariedEmployee("张三",1001,
                                     new MyDate(2002,9,1),15000); //new的是子类对象--多态

        emps[1]=new HourlyEmployee("李四",1002,
                                   new MyDate(2001,10,5),240,100);

        System.out.println("请输入当前的月份：");
        int month=scan.nextInt();

        for (int i = 0; i < emps.length; i++) {
            System.out.println(emps[i].toString());
            System.out.println("工资为： "+emps[i].earnings());

            if(month==emps[i].getBirthday().getMonth()){
                System.out.println("生日快乐！加薪100");
            }
        }

        scan.close();
    }
}