• 面向对象基础案例(2)

    📋 个人简介
    💖 作者简介：大家好，我是W_chuanqi，一个编程爱好者
    📙 个人主页：W_chaunqi
    😀 支持我：点赞👍+收藏⭐️+留言📝
    💬 愿你我共勉：“没有什么比勇气更温文尔雅，没有什么比怯懦更冷酷无情!”✨✨✨

    文章目录

    面型对象基础案例(2)

    1.打印水果类价格

    重写toString方法，将如下信息输出在控制台上：红色的苹果被称为“糖心富士”, 每500克4.98元，买了2500克，需支付多少元。

    🎇代码实现

    /**
 * @desc HongxinFSApple
 * @author 007
 * @date 2022/8/20
 */


class Apple {
	String color;
	String name;
	double weight;
	double price;
	
	public Apple(String color, String name, double price, double weight) {
		this.color = color;
		this.name = name;
		this.weight = weight;
		this.price = price;
	}
	
	@Override
	public String toString() {//重写Object类的toString方法
		return this.color + "的苹果被称为“" + this.name + "”, 每500克" + this.price + "元RMB，买了" + this.weight + "克，需支付" + (float)(this.price * (this.weight / 500)) + "元RMB。";
	}
}
public class HongxinFSApple {
	public static void main(String[] args) {
		Apple apple = new Apple("红色", "糖心富士", 4.98, 2500);
		System.out.println(apple.toString());
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    🎇运行结果

    image-20220820213333677

    2.购物车

    某商品单价 580 元，购买两件或多于两件的该商品享 8 折优惠。在控制台上输入购买商品的数量，编写两个同名的 pay()方法，一个方法用于输出购买一件商品的应付金额；另一个方法用于输出购买两件或多于两件商品的应付金额。

    🎇代码实现

    /**
 * @desc Shopping
 * @author 007
 * @date 2022/8/20
 */

import java.util.Scanner;

public class Shopping {
	public static void main(String[] args) {
		double price = 580;
		double discount = 0.8;
		Scanner sc = new Scanner(System.in);
		System.out.print("输入要购买商品的数量：");
		int number = sc.nextInt();
		sc.close();
		Shopping shopping = new Shopping();
		if (number == 1) {
			shopping.pay(number, price);
		} else {
			shopping.pay(number, price, discount);
		}
	}

	public void pay(int account, double price) {
		System.out.println("应付金额：" + price + "元。");
	}

	public void pay(int account, double price, double discount) {
		System.out.println("应付金额：" + (account * price * discount) + "元。");
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    运行结果

    image-20220821084539215

    3.大写转小写

    定义一个值为 66 的整数，编写两个同名的 print()方法，一个方法用于输出在 ASCII 表中这个整数对应的大写字母，另一个方法用于输出这个大写字母对应的小写字母。运行结果如下：

    在 ASCII 表中，66 对应的大写字母是 B。
B 的小写字母是b。

    • 1
    • 2

    🎇代码实现

    /**
 * @desc DaXiaoXie
 * @author 007
 * @date 2022/8/21
 */


public class DaXiaoXie {
	public static void main(String[] args) {
		int i = 66;
		DaXiaoXie dxx = new DaXiaoXie();
		dxx.print(i, (char)i);
		dxx.print((char)i, i);
	}
	
	public void print(int i, char c) {
		System.out.println("在ASCII表中，" + i + "对应的大写字母是" + c + "。");
	}
	
	public void print(char c, int i) {
		System.out.println(c + "的小写字母是" + (char) (i + 32) + "。");
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    🎇运行结果

    image-20220821085019495

    4.教师与学生

    使用多态编写一个程序，控制台输出如下内容。其中，人类（People）既是教师类（Teacher）的父类，也是学生类（Student）的父类。

    每个人都要工作
教师要认真授课
学生要好好学习

    • 1
    • 2
    • 3

    🎇代码实现

    /**
 * @desc Demo
 * @author 007
 * @date 2022/8/21
 */

class People {
	public void work() {
		System.out.println("每个人都要工作");
	}
}

class Teacher extends People {
	@Override
	public void work() {//重写父类方法
		System.out.println("教师要认真授课");
	}
}

class Student extends People {
	@Override
	public void work() {//重写父类方法
		System.out.println("学生要好好学习");
	}
}

public class Demo {
	public static void main(String[] args) {
		People people = new People();
		people.work();
		People teacher = new Teacher();
		teacher.work();
		People student = new Student();
		student.work();
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    🎇运行结果

    image-20220821094423989

    5.交通灯亮几秒？

    使用 instanceof 关键字模拟交通红绿灯的点亮时间，控制台输出如下内容：

    红灯亮45秒
黄灯亮 5秒
绿灯亮 30秒

    • 1
    • 2
    • 3

    🎇代码实现

    package chapt00;

//定义父类交通信号灯
class TrafficLights {
	
}
//定义红灯类继承父类
class RedLight extends TrafficLights {
	
}
//定义黄灯类继承父类
class YellowLight extends TrafficLights {
	
}
//定义绿灯类继承父类
class GreenLight extends TrafficLights {
	
}

public class Lights {
	public static void main(String[] args) {
		TrafficLights red = new RedLight();
		lighten(red);
		TrafficLights yellow = new YellowLight();
		lighten(yellow);
		TrafficLights green = new GreenLight();
		lighten(green);
	}
	
	public static void lighten(TrafficLights light) {
		if(light instanceof RedLight) 
			System.out.println("红灯亮45秒");
		if(light instanceof YellowLight) 
			System.out.println("黄灯亮5秒");
		if(light instanceof GreenLight) 
			System.out.println("绿灯亮30秒");
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    🎇运行结果

    image-20220821091113596

    6.打印不同的图形

    🎇案例描述

    本案例要求编写一个程序，可以根据用户要求在控制台打印出不同的图形。例如，用户自定义半径的圆形和用户自定义边长的正方形。

    🎇案例分析

    （1）创建父类MyPrint类，包含show()方法，用于输出图形的形状。

    （2）创建子类MyPrintSquare类，重写show ()方法，用“*”打印出边长为5的正方形。

    （3）创建子类MyPrintCircle类，重写show ()方法, 用“*”打印出半径为5的圆。

    （4）创建测试类，设计一个myshow(MyPrint a)方法，实现输出的功能：如果为MyPrintSquare, 输出边长为5的正方形，如果为MyPrintCircle对象，输出半径为5的圆；主函数中创建MyPrintSquare、MyPrintCircle的对象，分别调用myshow，检查输出结果。

    🎇案例实现

    MyPrintTest.java

    abstract class MyPrint {
    public abstract void show();
}

// 打印正方形
class MyPrintSquare extends MyPrint {
    @Override
    public void show() {
        for (int i = 0; i < 5; ++i) {
            for (int j = 0; j < 5; ++j) {
                if (j == 0 || j == 4)
                    System.out.print('*');
                else if (i == 0 || i == 4)
                    System.out.print('*');
                else
                    System.out.print(' ');
            }
            System.out.println();
        }
    }
}

// 打印圆形
class MyPrintCircle extends MyPrint {
    @Override
    public void show() {
        for (int y = 0; y <= 2 * 5; y += 2) {
            int x = (int) Math.round(5 - Math.sqrt(2 * 5 * y - y * y));
            int len = 2 * (5 - x);
            for (int i = 0; i <= x; i++) {
                System.out.print(' ');
            }
            System.out.print('*');
            for (int j = 0; j <= len; j++) {
                System.out.print(' ');
            }
            System.out.println('*');
        }
    }
}

public class MyPrintTest {
    public static void myShow(MyPrint a) {
        a.show();
    }

    public static void main(String[] args) {
        MyPrint mp1 = new MyPrintSquare();
        MyPrint mp2 = new MyPrintCircle();
        myShow(mp1);
        myShow(mp2);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    在上述代码中，第1~3行代码创建了一个抽象类MyPrint类，在MyPrint类中创建了一个show()方法用于输出图形的形状。然后第 6~40行代码分别创建了MyPrintSquare和MyPrintCircle类，并重写了MyPrint类的show()方法，分别用于打印正方形和圆形，最后再测试类中分别调用了MyPrintSquare和MyPrintCircle类的show()方法,打印正方形和圆形。

    🎇运行结果

    image-20220804130204403

    7.饲养员喂养动物

    🎇案例描述

    饲养员在给动物喂食时，给不同的动物喂不同的食物，而且在每次喂食时，动物都会发出欢快的叫声。例如，给小狗喂骨头，小狗会汪汪叫；给小猫喂食，小猫会喵喵叫。

    本案例要求编写一个程序模拟饲养员喂食动物的过程，案例要求如下：

    • （1） 饲养员给小狗喂骨头，小狗汪汪叫。
    • （2）饲养员给小猫喂小鱼，小猫喵喵叫。

    🎇案例分析

    在这个动物园里，涉及的对象有饲养员，各种不同动物以及各种不同的食物。这样很容易抽象出3个类Feeder、Animal和Food。假设只考虑猫类和狗类动物，则由Animal类派生出Cat类、Dog类、同样由Food类可以进一步派生出其子类Bone、Fish。因为他们之间存在这明显的is-a关系。

    同样的，鱼是一种食物，但实际上，鱼也是一种动物，Cat类和Dog类继承了Animal的很多属性和方法，如果将Animal定义为接口，Animal中是不能定义成员变量和成员方法的，Food类中虽然也有变量但是数量比Animal少，所以我们考虑将Food定义为接口，此时可以说“鱼是一种动物，同时也是一种食物”。

    🎇案例实现

    Animal.java

    public abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public abstract void shout();

    public abstract void eat(Food food);

    public String getName() {
        return name;
    }

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    上述代码中，定义了抽象类Animal，第4行代码声明了动物名称name，第8~18行代码提供了name的getter和setter方法。同时，编写了动物发声的抽象方法shout()和动物吃饭的抽象方法eat()。

    Dog.java

    public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void shout() {
        System.out.print("汪汪汪~~~");
    }

    @Override
    public void eat(Food food) {
        System.out.println(getName() + "正在啃着香喷喷的" + food.getName());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    上述代码中，定义了Dog类，并继承了Animal类，第 2~4行代码是在Dog类中定义类构造方法并在构造方法中调用了父类的构造方法。第6~14行代码重写了父类Animal动物发声的抽象方法shout()和动物吃饭的抽象方法eat()。

    public class Cat extends Animal {

    public Cat(String name) {
        super(name);
    }

    public void shout() {
        System.out.print("喵喵喵~~~");
    }

    public void eat(Food food) {
        System.out.println(getName() + "正在吃着香喷喷的" + food.getName());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    上述代码中，定义了Cat类，并继承了Animal类，第3~5行代码是在Cat类中定义类构造方法并在构造方法中调用了父类的构造方法。第7~13行代码重写了父类Animal动物发声的抽象方法shout()和动物吃饭的抽象方法eat()。

    Food.java

    public interface Food {
    public abstract String getName();
}

    • 1
    • 2
    • 3

    上述代码中，定义了一个Food接口，在接口中编写了一个抽象方法getName()。

    Bone.java

    public class Bone implements Food {

    @Override
    public String getName() {
        return "骨头";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    上述代码中，定义了一个Bone类并实现了Food接口，在Bone类中实现了Food接口的getName()方法。

    Fish.java

    public class Fish extends Animal implements Food {
    public Fish(String name) {
        super(name);
    }

    @Override
    public void shout() {
    }

    @Override
    public void eat(Food food) {
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    上述代码中，定义了一个Fish类，Fish类继承了Animal类并实现了Food接口，第2~4行代码是在Fish类中定义了构造方法并在构造方法中调用了父类Food的构造方法；第6~12行代码是继承了Animal类的shout()方法和eat()方法。

    Feeder.java

    public class Feeder {
    private String name;

    public Feeder(String name) {
        this.name = name;
    }

    public void speak() {
        System.out.println("欢迎来到动物园！");
        System.out.println("我是饲养员 " + getName());
    }

    public void feed(Animal a, Food food) {
        a.eat(food);
    }

    public String getName() {
        return name;
    }

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    上述代码中，定义了一个Feader类，Feader类中声明了饲养员名称name并提供了name属性的getter和setter方法；定义了构造方法；同时，第8~15行代码编写了饲养员说话的speak()方法和饲养动物的feed()方法。

    ZooTest.java

    public class ZooTest {
    public static void main(String[] args) {
        Feeder feeder = new Feeder("小华");
        feeder.speak();
        Dog dog = new Dog("小狗");
        dog.shout();
        Food food = new Bone();
        feeder.feed(dog, food);
        Cat cat = new Cat("小猫");
        cat.shout();
        food = new Fish("黄花鱼");
        feeder.feed(cat, food);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    上述代码中，定义了一个测试类ZooTest，第3~4行代码是在ZooTest类中创建了一个feeder对象，并调用了饲养员说话的方法speak()；然后，第7~12行代码是创建了food对象、dog对象和cat对象，并在创建dog和cat对象时传入动物的名称，最后通过feeder对象调用feed()方法模拟饲养员喂养动物，分别通过dog和cat对象调用shout()方法模拟动物发声。

    🎇运行结果

    image-20220804162824285

    8.学生和老师(2)

    🎇案例描述

    在班级中上课时，老师在讲台上讲课，偶有提问，会点名学生回答问题。虽然老师和学生都在讲话，但讲话的具体内容却不相同。本案例要求使用抽象类的知识编写一个程序实现老师上课的情景。

    🎇案例分析

    （1）定义一个抽象类Person，在Person类中声明两个属性：name和age，并设置其对应的getter方法，用于获取人的姓名和年龄；在Person类中声明一个有参构造方法，用于对Person类中的属性进行初始化；在Person类中声明一个say()方法和一个getContent()方法，在say()方法中调用getContent()方法。

    （2）定义类 Student，并继承Person类。在Student类中声明一个属性score；声明Student类的构造方法并重写Person类的getContent()方法。

    （3）定义类 Worker，并继承Person类。在Worker类中声明一个属性salary；声明Worker类的构造方法并重写Person类的getContent()方法。

    （4）在main() 方法中使用父类引用指向子类对象的方式（向上转型），分别使用Person类和Worker类实例化两个Person对象per1和per2，并分别使用per1和per2调用say()方法。

    🎇代码实现

    /**
 * @desc AbstractDemo
 * @author 007
 * @date 2022/8/4
 */
//定义抽象类Person
abstract class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void say(){
        System.out.println(this.getContent());
    }
    public abstract String getContent();
}
//定义Student类
class Student extends Person{
    private float score;
    public Student(String name, int age,float score) {
        super(name, age);
        this.score = score;
    }
    @Override
    public String getContent() {
        return "学生信息--》姓名："+super.getName()+"；年龄："+super.getAge()+"；成绩："+this.score;
    }
}
//定义Woker类
class Worker extends Person{
    private float salary;
    public Worker(String name, int age,float salary) {
        super(name, age);
        this.salary = salary;
    }
    @Override
    public String getContent() {
        return "工人信息--》姓名："+super.getName()+"；年龄："+super.getAge()+"；工资："+this.salary;
    }
}
public class AbstractDemo{
    public static void main(String[] args){
        Person per1 = null;
        Person per2 = null;
        per1 = new Student("张三",20,99.0f);
        per2 = new Worker("李四",30,3000.0f);
        per1.say();
        per2.say();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59

    上述代码中，第7~24行代码定义了一个抽象类Person，在Person类中声明了name和age属性和其对应的getter方法，并声明了say()方法和getContent()方法，在say()方法中调用了getContent()方法；第26~36行代码定义了一个Student类并继承Person类，在Student类中声明了score属性，声明了Student类的构造方法并重写Person类的getContent()方法；第38~48行代码定义了一个Worker类并继承Person类，在Worker类中声明了salary属性，声明了Worker类的构造方法并重写Person类的getContent()方法；第53~56行代码分别使用向上转型的方式实例化了两个Person对象per1和per2，并分别使用per1和per2调用say()方法。

    🎇运行结果

    image-20220804162926812

    9.研究生薪资管理系统

    🎇案例描述

    在学校中，学生每个月需要交相应的生活费，老师每个月有相应的工资，而在职研究生既是老师又是学生，所以在职研究生既需要交学费又会有工资。下面要求编写一个程序来统计在职研究生的收入与学费，如果收入减去学费不足2000 元，则输出“provide a loan”(需要贷款)信息,。

    本案例要求使用接口实现该程序。

    🎇案例分析

    （1）定义两个接口：

    • 在StudentManageInterface接口中声明两个方法：getFee()和setFee()，用于设置和获取学生的学费;
    • 在TeacherManageInterface类中声明两个方法：gePay()和setPaye()，用于设置和获取教师的工资。

    （2）定义主类 Graduate，分别实现StudentManageInterface和TeacherManageInterface接口。

    （3）定义Graduate类的成员变量，和构造方法。

    （4）给出四个接口方法的实现。

    （5）给出一个计算是否需要贷款的方法，在里面统计年收入和学费，并输出是否需要贷款的信息。

    （6）在main() 方法中创建一个姓名为“zhangsan”的研究生，调用计算是否需要贷款的方法。

    🎇案例实现

    /**
 * @desc StudentManagerInterface
 * @author 007
 * @date 2022/8/4
 */
public interface StudentManagerInterface {//interface接口名
	 public abstract void setFree(double fee);  //抽象方法
	 public abstract double getFree();
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    上述代码中，创建了一个StudentManagerInterface接口，定义了setFee()和getFee ()方法，用于设置和获取学生学费。

    /**
 * @desc TeacherManagerInterface
 * @author 007
 * @date 2022/8/4
 */
public interface TeacherManagerInterface {
	public abstract double getPay();
	public abstract void setPay(double pay);
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    上述代码中，创建了一个TeacherManagerInterface接口，定义了setPay()和getPay()方法，用于设置和获取教师工资。

    /**
 * @desc 实现StudentManagerInterface和TeacherManagerInterface接口，重写了两个接口中的方法。
 * @author 007
 * @date 2022/8/4
 */
 class Graduate implements StudentManagerInterface, TeacherManagerInterface {
	private String name, sex;
	private int age;
	private double fee, pay;

	Graduate() {
	}

	Graduate(String name, String sex, int age, double fee, double pay) {
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.fee = fee;
		this.pay = pay;
	}

	public String getName() {
		return name;
	}

	public String getSex() {
		return sex;
	}

	public int getAge() {
		return age;
	}

	public void setFree(double fee) {
		this.fee = fee;
	}

	public double getFree() {
		return fee;
	}

	public void setPay(double pay) {
		this.pay = pay;
	}

	public double getPay() {// 对接口的抽象方法必须重写
		return pay;
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    上述代码中，Graduate类实现了StudentManagerInterface和TeacherManagerInterface接口，并重写了两个接口中的方法。

    /**
 * @desc 测试
 * @author 007
 * @date 2022/8/4
 */
public class TestDemo {

	public static void main(String[] args) {
		Graduate gr = new Graduate("zhangsan", "男", 5, 8000, 3000);
		judgeLoan(gr);
	}

	public static void judgeLoan(Graduate gr) {// 对象作形参
		if (gr.getPay() * 12 - gr.getFree() * 2 < 2000) {
			System.out.println("provide a loan");
		} else
			System.out.println("don't need a loan");
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    在main()方法中，计算了名为“zhangsan”的研究生是否需要贷款。

    🎇运行结果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rdSkM1MV-1661046483088)(C:\Users\THUNOEROBOT\AppData\Roaming\Typora\typora-user-images\image-20220804201708839.png)]

    10.经理与员工工资案例（多态实现）

    🎇案例描述

    某公司的人员分为员工和经理两种，但经理也属于员工中的一种，公司的人员都有自己的姓名和地址，员工和经理都有自己的工号、工资、工龄等属性，但经理不同员工的是，经理有自己在公司对应的级别。假设每次给员工涨工资一次能涨10%，经理能涨20%。本案例要求利用多态实现给员工和经理涨工资。

    🎇案例分析

    （1）创建父类Person类，在Person类中定义name和address属性，并定义该类的构造方法。

    （2）创建抽象类Employee类并继承Person类，创建构造方法，在构造方法中调用父类的构造方法。在Employee类中定义员工的ID、工资wage、年龄age等属性；在类中定义涨工资的抽象方法add()，通过对职位的判断来给员工或经理涨工资。

    （3）创建子类Manager类并继承Employee类；创建构造方法，在构造方法中调用父类的构造方法；由于经理有两种身份，既是Employee又是Manager，所以Manager类继承Employee类，在Manager类中定义等级属性level，并给出level的getter和setter方法；实现Employee类的add()抽象方法。

    （4）创建测试类，对Manager进行实例化，传入参数，调用涨薪方法，传入级别level参数，根据级别level输出涨薪工资。

    🎇案例实现

    /**
 * @desc 定义Person类
 * @author 007
 * @date 2022/8/4
 */
public class Person {
	private String name = "";
	private String address = "";

	// 定义构造方法
	public Person(String name, String address) {
		this.name = name;
		this.address = address;
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    上述代码中，创建了一个父类Person类，在Person类中定义了name和address属性以及Person类的构造方法。

    /**
 * @desc 创建一个Employee类并继承了Person类
 * @author 007
 * @date 2022/8/4
 */
public abstract class Employee extends Person {
	private String ID = "";
	private double wage = 0;
	private int age = 0;

	public Employee(String name, String address, String ID, double wage, int age) {
		super(name, address);
		this.ID = ID;
		this.wage = wage;
		this.age = age;
	}

	// 定义抽象方法
	public abstract void add(String position);

	// 设置get/set方法
	public double getWage() {
		return wage;
	}

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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    上述代码中，创建了一个Employee类并继承了Person类，在Employee类中，定义了Employee类的构造方法，并在构造方法中调用了父类Person的构造方法；定义了员工的name和wage和age属性并提供了setter和getter方法；定义了抽象方法add()。

    package chapt4;
/**
 * @desc 创建了一个Manager类并继承了Employee类
 * @author 007
 * @date 2022/8/4
 */
public class Manager extends Employee {
	private String level = "";

	public Manager(String name, String address, String ID, double wage, int age, String level) {
		super(name, address, ID, wage, age);
		this.level = level;
	}

	// 实现抽象方法
	public void add() {
		double wage = super.getWage();
		super.setWage(wage * 1.1);
	}

	public void add(String position) {
		double wage = super.getWage();
		super.setWage(wage * 1.2);
	}

	public String getLevel() {
		return level;
	}

	public void setLevel(String level) {
		this.level = level;
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    上述代码中，创建了一个Manager类并继承了Employee类，在Manager类中，定义了Manager类的构造方法，并在构造方法中调用了父类Employee的构造方法；定义了员工的级别level属性并提供了setter和getter方法；实现了Employee类的抽象方法add()，并对add()方法进行了重载。

    /**
 * @desc 测试类Test类
 * @author 007
 * @date 2022/8/4
 */
public class Test {
	public static void main(String[] args) {
		Manager normal = new Manager("wsl", "jit", "12", 1000, 2, "1");
		Manager manager = new Manager("ctl", "jitt", "123", 10000, 10, "0");
		normal.add();
		manager.add(manager.getLevel());
		System.out.println("normal wage is:" + normal.getWage());
		System.out.println("manager wage is:" + manager.getWage());
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    上述代码中，创建了一个测试类Test类，在类中对Manager进行了实例化并传参。类中通过调用无参的add()方法来获取普通员工的涨薪，调用有参的add(manager.getLevel())方法来获取经理的涨薪。

    🎇运行结果

    image-20220804215902207

    11.图形的面积与周长计算程序

    🎇案例描述

    长方形和圆形都属于几何图形，都有周长和面积，并且它们都有自己的周长和面积计算公式。使用抽象类的知识设计一个程序，可以计算不同图形的面积和周长。

    🎇案例分析

    （1）定义父类Shape作为抽象类，并在类中定义抽象方法求周长和面积。

    （2）定义Shape子类圆形(circle)，具有半径属性和常量PI，同时必须实现父类中的抽象方法。

    （3）定义Shape子类长方形(rectangle)，具有长和宽的属性，同时必须实现父类的抽象方法。

    （4）创建图形面积周长计算器(ShapeCalculate)，具有计算不同图形面积和周长的方法。

    （5）创建测试类TestShape类，在其main()方法中对ShapeCalculate计算面积和周长方法进行测试。

    🎇案例实现

    /**
 * @desc 定义抽象类Shape
 * @author 007
 * @date 2022/8/4
 */
public abstract class Shape {
	// 抽象方法： 获取面积
	public abstract double getArea();

	// 抽象方法：获取周长
	public abstract double getPerimeter();
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    上述代码中，在Shape类中定义了面积和周长的抽象方法。

    /**
 * @desc 定义了圆形Circle类并继承了Shape类
 * @author 007
 * @date 2022/8/4
 */
public class Circle extends Shape {
	private double radius = 0; // 圆的半径
	private final static double PI = 3.14; // 常量，圆周率
	
    // 有参构造，初始化圆半径
	public Circle(double radius) {
		this.radius = radius;
	}

	// 求圆面积
	public double getArea() {
		return PI * radius * radius;
	}

	// 求圆周长
	public double getPerimeter() {
		return 2 * radius * PI;
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    上述代码中，定义了圆形Circle类并继承了Shape类，再Circle类中重写了Shape中的getArea()和getPerimeter()方法，分别计算圆的面积和周长。

    /**
 * @desc 定义了长方形Rectangle类并继承了Shape类
 * @author 007
 * @date 2022/8/4
 */
public class Rectangle extends Shape {
	private double length = 0; // 长方形的长
	private double width = 0; // 长方形的宽
	
	// 有参构造，初始化长方形的长和宽
	public Rectangle(double length, double width) {
		super();
		this.length = length;
		this.width = width;
	}

	public double getArea() {
		return this.length * this.width;
	}

	public double getPerimeter() {
		return 2 * (this.length + this.width);
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    上述代码中，定义了长方形Rectangle类并继承了Shape类，再Circle类中重写了Shape中的getArea()和getPerimeter()方法，分别计算长方形的面积和周长。

    /**
 * @desc 创建图形面积周长计算器ShapeCalculate类
 * @author 007
 * @date 2022/8/5
 */
 public class ShapeCaculate {
     // 可以计算任意shape子类的面积
     public void calArea (Shape shape) {
         System.out.println(shape.getArea());
     }
     // 可以计算任意shape子类的周长
     public void calPerimeter(Shape shape) {
         System.out.println(shape.getPerimeter());
     }
 }


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    创建了图形面积周长计算器ShapeCalculate类，calArea ()方法用来计算不同图形面积，calPerimeter()方法用来计算不同图形的周长。

    /**
 * @desc 创建圆形circle对象和长方形rectangle对象，分别计算圆形和长方形的面积和周长。
 * @author 007
 * @date 2022/8/5
 */
public class TestShape {
	public static void main(String[] args) {
		// 创建图形计算器
		ShapeCaculate sc = new ShapeCaculate();
		// 创建长方形和圆形对象
		Shape rectangle = new Rectangle(3, 4); // <-------多态
		Circle circle = new Circle(3);
		// 求长方形和圆形的面积
		System.out.println("长方形的面积：");
		sc.calArea(rectangle);
		System.out.println("圆形的面积：");
		sc.calArea(circle);
		// 求长方形和圆形的周长
		System.out.println("长方形的周长：");
		sc.calPerimeter(rectangle);
		System.out.println("圆形的周长：");
		sc.calPerimeter(circle);
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    在上述代码中，分别创建了一个圆形circle对象和一个长方形rectangle对象，然后分别计算了圆形和长方形的面积和周长。

    🎇运行结果

    image-20220805131444374

    12.模拟物流快递系统程序设计

    🎇案例描述

    网购已成为人们生活的重要组成部分，当人们在购物网站中下订单后，订单中的货物就会在经过一系列的流程后，送到客户的手中。而在送货期间，物流管理人员可以在系统中查看所有物品的物流信息。编写一个模拟物流快递系统的程序，模拟后台系统处理货物的过程。

    🎇案例分析

    （1）运输货物首先需要有交通工具，所以需要定义一个交通工具类。由于交通工具可能有很多，所以可以将该交通工具类定义成一个抽象类，类中需要包含该交通工具的编号，型号以及运货负责人等属性，还需要定义一个抽象的运输方法。

    （2）当运输完成后，需要对交通工具进行保养，所以需要定义保养接口，具备交通工具的保养功能。

    （3）交通工具可能有很多种，这里可以定义一个专用运输车类，该类需要继承交通工具类，并实现保养接口。

    （4）有了运输的交通工具后，就可以开始运送货物了。货物在运输前，运输时和运输后，都需要检查和记录，并且每一个快递都有快递单号，这时可以定义一个快递任务类包含快递单号和货物重量的属性，以及送前、发送货物途中和送后的方法。

    （5）在货物运输过程中，需要对运输车辆定位，以便随时跟踪货物的位置信息。定位功能可以使用GPS，而考虑到能够实现定位功能的设备可能有很多（如手机、专用定位仪器等），这时可以定义一个包含定位功能的GPS接口，以及实现了该接口的仪器类（如Phone等）。

    （6）编写测试类，运行查看结果。

    🎇案例实现

    定义交通工具类Transportation，该类是一个抽象类，包含交通工具信息和运输货物方法，其代码如下所示。

    /**
 * @desc 交通工具类Transportation
 * @author 007
 * @date 2022/8/5
 */
public abstract class Transportation {
	private String number; // 编号
	private String model; // 型号
	private String admin; // 运货负责人

	public Transportation() {
		super();// 可省略
	}

	public Transportation(String number, String model, String admin) {
		this.number = number;
		this.model = model;
		this.admin = admin;
	}

	// 运输方法
	public abstract void transport();

	// 编号
	public void setNumber(String number) {
		this.number = number;
	}

	public String getNumber() {
		return number;
	}

	// 型号
	public void setModel(String model) {
		this.model = model;
	}

	public String getModel() {
		return model;
	}

	// 负责人
	public void setAdmin(String admin) {
		this.admin = admin;
	}

	public String getAdmin() {
		return admin;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    在上述代码中，分别定义了车辆编号、车辆型号和车辆负责人的属性，以及其各自的getter和setter方法，同时还定义了一个抽象的运输方法transport()。

    定义交通工具保养接口Careable，该接口中包含车辆保养的方法，其实现代码如下所示。

    /**
 * @desc 定义保养接口Careable，具备保养功能。
 * @author 007
 * @date 2022/8/5
 */
public interface Careable {
	// 保养方法
	public abstract void upKeep();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    定义专用运输车类ZTransportation，该类继承了交通工具类，并实现了保养接口，其实现代码如下所示。

    /**
 * @desc 专用运输车类ZTransportation
 * @author 007
 * @date 2022/8/5
 */
public class ZTransportation extends Transportation implements Careable {
	// 无参构造
	public ZTransportation() {
		super();
	}

	// 有参构造：车辆编号、型号、负责人
	public ZTransportation(String number, String model, String admin) {
		super(number, model, admin);
	}

	// 运输方法
	public void transport() {
		System.out.println("运输进行中。。。");
	}

	// 重写车辆保养方法
	public void upKeep() {
		System.out.println("货物运输车辆保养完毕!");
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    定义快递任务类SendTask，该类的具体实现代码如下所示。

    /**
 * @desc 快递任务类SendTask
 * @author 007
 * @date 2022/8/5
 */

public class SendTask {
	private String number; // 快递单号
	private double goodsWeight; // 货物重量

	public SendTask() {
		super(); // 可省略
	}

	public SendTask(String number, double goodsWeight) {
		this.number = number;
		this.goodsWeight = goodsWeight;
	}

	// 送前准备
	public void sendBefore() {
		System.out.println("订单开始处理，仓库验货中。。。");
		System.out.println("货物重量：" + this.getGoodsWeight() + "kg");
		System.out.println("货物检验完毕!");
		System.out.println("货物填装完毕!");
		System.out.println("运货人已通知!");
		System.out.println("快递单号：" + this.getNumber());
	}

	// 发送货物
	public void send(Transportation t, GPS tool) {
		System.out.println("运货人" + t.getAdmin() + "正在驾驶编号为" + t.getNumber() + "的" + t.getModel() + "发送货物！");
		t.transport();
		String showCoordinate = tool.showCoordinate();
		System.out.println("货物当前的坐标为：" + showCoordinate);
	}

	// 送后操作
	public void sendAfter(Transportation t) {
		System.out.println("货物运输任务已完成！");
		System.out.println("运货人" + t.getAdmin() + "所驾驶的编号为" + t.getNumber() + "的" + t.getModel() + "已归还！");
	}

	public String getNumber() {
		return number;
	}

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

	public double getGoodsWeight() {
		return goodsWeight;
	}

	public void setGoodsWeight(double goodsWeight) {
		this.goodsWeight = goodsWeight;
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60

    定义包含显示位置功能的GPS接口和实现类Phone，其实现代码如GPS.java和Phone.java所示。

    /**
 * @desc 定义GPS接口，具备GPS定位功能。
 * @author 007
 * @date 2022/8/5
 */
public interface GPS{
	//显示坐标的方法
	public String showCoordinate();
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    /**
 * @desc 定义一个手机类，实现GPS接口，拥有定位功能。
 * @author 007
 * @date 2022/8/5
 */
class Phone implements GPS {
	public Phone() { // 空参构造
		super();
	}

	// 定位方法
	public String showCoordinate() {
		String location = "193,485";
		return location;
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    定义测试类，实例化对象并传入数据，测试运行结果，其代码如下所示。

    /**
 * @desc 定义测试类
 * @author 007
 * @date 2022/8/5
 */
public class Task02Test {
	public static void main(String[] args) {
		// 快递任务类对象
		SendTask task = new SendTask("HYX600235", 76.34);
		// 调用送前准备方法
		task.sendBefore();
		System.out.println("======================");
		// 创建交通工具对象
		ZTransportation t = new ZTransportation("Z025", "大奔", "小韩");
		// 创建GPS工具对象
		Phone p = new Phone();
		// 将交通工具与GPS工具传入送货方法
		task.send(t, p);
		System.out.println("======================");
		// 调用送后操作方法
		task.sendAfter(t);
		t.upKeep();
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    🎇运行结果

    umber;
    }

    public double getGoodsWeight() {
	return goodsWeight;
}

public void setGoodsWeight(double goodsWeight) {
	this.goodsWeight = goodsWeight;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    }

    
定义包含显示位置功能的GPS接口和实现类Phone，其实现代码如GPS.java和Phone.java所示。

```java
/**
 * @desc 定义GPS接口，具备GPS定位功能。
 * @author 007
 * @date 2022/8/5
 */
public interface GPS{
	//显示坐标的方法
	public String showCoordinate();
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    /**
 * @desc 定义一个手机类，实现GPS接口，拥有定位功能。
 * @author 007
 * @date 2022/8/5
 */
class Phone implements GPS {
	public Phone() { // 空参构造
		super();
	}

	// 定位方法
	public String showCoordinate() {
		String location = "193,485";
		return location;
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    定义测试类，实例化对象并传入数据，测试运行结果，其代码如下所示。

    /**
 * @desc 定义测试类
 * @author 007
 * @date 2022/8/5
 */
public class Task02Test {
	public static void main(String[] args) {
		// 快递任务类对象
		SendTask task = new SendTask("HYX600235", 76.34);
		// 调用送前准备方法
		task.sendBefore();
		System.out.println("======================");
		// 创建交通工具对象
		ZTransportation t = new ZTransportation("Z025", "大奔", "小韩");
		// 创建GPS工具对象
		Phone p = new Phone();
		// 将交通工具与GPS工具传入送货方法
		task.send(t, p);
		System.out.println("======================");
		// 调用送后操作方法
		task.sendAfter(t);
		t.upKeep();
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    🎇运行结果

    image-20220805154630212

  • 相关阅读:
    【Vue】vuex mapActions和mapMutations
    QT中窗口自绘制效果展示
    【JavaScript复习十八】预解析
    springboot基于SpringBoot的冬奥会科普平台springboot21
    Java文件流练习
    西瓜书笔记
    JavaBean的Scope属性
    洛谷P1057 [NOIP2008 普及组] 传球游戏
    创建型设计模式之原型模式
    【Boost C++ 库】托管共享内存详解
  • 原文地址：https://blog.csdn.net/W_chuanqi/article/details/126447723