CH4-面向对象下 (8个案例实现)
【案例4-1】打印不同的图形
【案例介绍】
1. 案例描述
本案例要求编写一个程序，可以根据用户要求在控制台打印出不同的图形。例如，用户自定义半径的圆形和用户自定义边长的正方形。
2. 运行结果
【案例目标】
-
学会“抽象类实现不同图形的打印程序设计”的实现思路。
-
独立完成“抽象类实现不同图形的打印程序设计”的源代码编写、编译及运行。
-
掌握抽象类的应用。
-
掌握方法的重写。
-
掌握继承的概念及其应用。
【案例分析】
（1）创建父类MyPrint类，包含show()方法，用于输出图形的形状。
（2）创建子类MyPrintSquare类，重写show ()方法，用“*”打印出边长为5的正方形。
（3）创建子类MyPrintCircle类，重写show ()方法, 用“*”打印出半径为5的圆。
（4）创建测试类，设计一个myshow(MyPrint a)方法，实现输出的功能：如果为MyPrintSquare, 输出边长为5的正方形，如果为MyPrintCircle对象，输出半径为5的圆；主函数中创建MyPrintSquare、MyPrintCircle的对象，分别调用myshow，检查输出结果。
【案例实现】
MypointTest.java
abstract class MyPoint {
public abstract void show();
}
//打印正方形
class MyPrintSquare extends MyPoint {
@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 MyPoint{
@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 MyPointTest {
public static void myShow(MyPoint a){
a.show();
}
public static void main(String[] args){
MyPoint mp1 = new MyPrintSquare();
MyPoint mp2 = new MyPrintCircle();
myShow(mp1);
myShow(mp2);
}
}
在上述代码中，第1~3行代码创建了一个抽象类MyPrint类，在MyPrint类中创建了一个show()方法用于输出图形的形状。
然后第 21~49行代码分别创建了MyPrintSquare和MyPrintCircle类，并重写了MyPrint类的show()方法，分别用于打印正方形和圆形，最后再测试类中分别调用了MyPrintSquare和MyPrintCircle类的show()方法,打印正方形和圆形。
【案例4-2】饲养员喂养动物
【案例目标】
1. 案例描述
饲养员在给动物喂食时，给不同的动物喂不同的食物，而且在每次喂食时，动物都会发出欢快的叫声。例如，给小狗喂骨头，小狗会汪汪叫；给小猫喂食，小猫会喵喵叫。
本案例要求编写一个程序模拟饲养员喂食动物的过程，案例要求如下：
（1） 饲养员给小狗喂骨头，小狗汪汪叫。
（2） 饲养员给小猫喂小鱼，小猫喵喵叫。
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 Anima* {
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;
}
}
上述代码中，定义了抽象类Animal，第4行代码声明了动物名称name，第7~13行代码提供了name的getter和setter方法。同时，编写了动物发声的抽象方法shout()和动物吃饭的抽象方法eat()。
Dog.java
public class Dog extends Anima* {
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());
}
}
上述代码中，定义了Dog类，并继承了Animal类，第 2~4行代码是在Dog类中定义类构造方法并在构造方法中调用了父类的构造方法。第6~12行代码重写了父类Animal动物发声的抽象方法shout()和动物吃饭的抽象方法eat()。
Cat.java
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());
}
}
上述代码中，定义了Cat类，并继承了Animal类，第2~4行代码是在Cat类中定义类构造方法并在构造方法中调用了父类的构造方法。第5~10行代码重写了父类Animal动物发声的抽象方法shout()和动物吃饭的抽象方法eat()。
Food.java
public interface Food {
public abstract String getName();
}
上述代码中，定义了一个Food接口，在接口中编写了一个抽象方法getName()。
Bone.java
public class Bone implements Food{
@Override
public String getName() {
return "骨头";
}
}
上述代码中，定义了一个Bone类并实现了Food接口，在Bone类中实现了Food接口的getName()方法。
Fish.java
public class Fish extends Anima* implements Food{
public Fish(String name) {
super(name);
}
@Override
public void shout() {
}
@Override
public void eat(Food food) {
}
}
上述代码中，定义了一个Fish类，Fish类继承了Animal类并实现了Food接口，第2~4行代码是在Fish类中定义了构造方法并在构造方法中调用了父类Food的构造方法；第5~10行代码是继承了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(Anima* a, Food food) {
a.eat(food);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
上述代码中，定义了一个Feader类，Feader类中声明了饲养员名称name并提供了name属性的getter和setter方法；定义了构造方法；同时，第6~12行代码编写了饲养员说话的speak()方法和饲养动物的feed()方法。
DongWuTest.java
public class DongWuTest {
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);
}
}
上述代码中，定义了一个测试类DongWuTest，第3~4行代码是在DongWuTest类中创建了一个feeder对象，并调用了饲养员说话的方法speak()；
然后，第7~12行代码是创建了food对象、dog对象和cat对象，并在创建dog和cat对象时传入动物的名称，最后通过feeder对象调用feed()方法模拟饲养员喂养动物，分别通过dog和cat对象调用shout()方法模拟动物发声。
【案例4-3】多彩的声音
【案例介绍】
-
案例描述
设计和实现一个Soundable发声接口，该接口具有发声功能，同时还能调节声音大小。
Soundable接口的这些功能将由有3种声音设备来实现，他们分别是收音机Radio、随身听Walkman、手机MobilePhone。 最后还需设计一个应用程序类来使用这些实现Soundable接口的声音设备。程序运行时，先询问用户想哪个设备，用户选择设备后，程序按照该设备的工作方式打印发出的发音。本案例要求使用抽象类实现。
-
运行结果
【案例目标】
- 学会分析“发声接口程序设计”实现的逻辑思路。
- 能够独立完成“发声接口程序设计”的源代码编写、编译及运行。
- 掌握接口的实现方式。
【案例分析】
通过任务的描述可知，此程序包含了一个发声接口Soundable，Soundable接口的有三个声音设备实现类实现了Soundable接口，分别是收音机类Radio，随身听类Walkman和手机类Mobilephon。
Radio、Walkman和MobilePhon这三个声音设备实现类需要分别实现Soundable接口接口的相关功能。
然后，还需设计一个应用程序类来使用这些实现Soundable接口的声音设备。
最后编写测试类，在main()方法中，编写程序，使用户可以自主选择要使用的设备；创建使用设备的对象，根据用户选择的声音设备，调用相关方法，模拟使用声音设备对应的功能。
【案例实现】
Soundable.java
public interface Soundable {
// 发出声音
public void playSound() ;
// 降低声音
public void decreaseVolume();
// 停止声音
public void stopSound();
}
上述代码中，创建了一个Soundable接口，在接口中定义了三个方法playSound()、decreaseVolume()、stopSound()。
SampleDisplay.java
import java.util.Scanner;
public class SampleDisplay {
public void display(Soundable soundable) {
soundable.playSound();
System.out.println("您是否要降低音量？");
System.out.println("1-是 2-否");
Scanner in = new Scanner(System.in);
if(in.nextLine().equals("1")) {
soundable.decreaseVolume();
}
System.out.println("您是否要关机？");
System.out.println("1-是 2-否");
Scanner ins = new Scanner(System.in);
if(in.nextLine().equals("1")) {
soundable.stopSound();
}
}
}
上述代码中，创建了一个SampleDisplay类，在SampleDisplay类中编写了display(Soundable soundable)方法，根据传入的声音设备的对象，调用相关方法，模拟使用声音设备对应的功能。
Radio.java
public class Radio implements Soundable{
@Override
public void playSound() {
System.out.println("收音机播放广播：第八套小学生广播体操");
}
@Override
public void decreaseVolume() {
System.out.println("已降低收音机音量。");
}
@Override
public void stopSound() {
System.out.println("已关闭收音机。");
}
}
上述代码中，创建了一个Radio类并实现了Soundable接口，同时，实现了Soundable接口的三个方法：playSound()、decreaseVolume()、stopSound()。
Walkman.java
public class Walkman implements Soundable{
@Override
public void playSound() {
System.out.println("正在播放歌曲：七里香");
}
@Override
public void decreaseVolume() {
System.out.println("已降低随身听音量");
}
@Override
public void stopSound() {
System.out.println("已关闭随身听");
}
}
上述代码中，创建了一个Walkman类并实现了Soundable接口，同时，实现了Soundable接口的三个方法：playSound()、decreaseVolume()、stopSound()。
MobilePhone.java
public class MobilePhone implements Soundable{
@Override
public void playSound() {
System.out.println("手机发出来电铃声：叮当 、 叮当");
}
@Override
public void decreaseVolume() {
System.out.println("已降低手机音量");
}
@Override
public void stopSound() {
System.out.println("已关闭手机");
}
}
上述代码中，创建了一个MobilePhone类并实现了Soundable接口，同时，实现了Soundable接口的三个方法：playSound()、decreaseVolume()、stopSound()。
TestDemo.java
import java.util.Scanner;
public class TestDemo {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("你想听什么？请输入：");
System.out.println("0-收音机 1-随身听 2-手机");
int choice;
choice = in.nextInt();
SampleDisplay sampledisplay = new SampleDisplay();
if (choice == 0)
sampledisplay.display(new Radio());
else if(choice == 1)
sampledisplay.display(new Walkman());
else if(choice == 2)
sampledisplay.display(new MobilePhone());
Else
System.out.println("您的输入有误，请重新输入！");
in.close();
}
}
上述代码中，首先创建了一个sampledisplay对象，然后，根据用户选择使用的声音设备，通过sampledisplay对象调用display()方法并传入声音设备对象，模拟使用声音设备相关的功能。
【案例4-4】学生和老师
【案例介绍】
1.案例描述
在班级中上课时，老师在讲台上讲课，偶有提问，会点名学生回答问题。虽然老师和学生都在讲话，但讲话的具体内容却不相同。
本案例要求使用抽象类的知识编写一个程序实现老师上课的情景。
2.运行结果
【案例目标】
-
学会“学生和老师”的实现思路。
-
独立完成“学生和老师”的源代码编写、编译及运行。
-
掌握方法的重写。
-
掌握抽象类的应用。
【案例分析】
（1）定义一个抽象类Person，在Person类中声明两个属性：name和age，并设置其对应的getter方法，用于获取人的姓名和年龄；在Person类中声明一个有参构造方法，用于对Person类中的属性进行初始化；在Person类中声明一个say()方法。
（2）定义类 Student，并继承Person类。声明Student类的构造方法并重写Person类的say()方法。
（3）定义类 Teacher，并继承Person类。声明Teacher类的构造方法并重写Person类的say()方法。
（4）定义测试类，在测试类中分别使用向上转型的方式实例化两个Person对象per1和per2，并分别使用per1和per2调用say()方法。
【案例实现】
AbstractDemo.java
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 abstract void say();
}
class Student extends Person{
public Student(String name, int age) {
super(name, age);
}
public void say() {
System.out.println("学生姓名："+this.getName()+",年龄：
"+this.getAge()+",负责回答问题。");
}
}
class Teacher extends Person{
public Teacher(String name, int age) {
super(name, age);
}
public void say() {
System.out.println("老师姓名："+this.getName()+",年龄：
"+this.getAge()+",负责提出问题。");
}
}
public class AbstractDemo{
public static void main(String[] args){
Person per1 = new Student("张三",18);
Person per2 = new Teacher("李四",30);
per1.say();
per2.say();
}
}
上述代码中，第1~15行代码定义了一个抽象类Person，在Person类中声明了name和age属性和其对应的getter方法和构造方法，并声明了say()方法；
第16~24行代码定义了一个Student类并继承Person类，在Student类中声明了Student类的构造方法并重写Person类的say()方法；
第25~33行代码定义了一个Teacher类并继承Person类，在Teacher类中声明了Teacher类的构造方法并重写Person类的say()方法；第34~41行代码分别使用向上转型的方式实例化了两个Person对象per1和per2，并分别使用per1和per2调用say()方法。
【案例4-5】研究生薪资管理系统
【案例介绍】
1. 案例描述
在学校中，学生每个月需要交相应的生活费，老师每个月有相应的工资，而在职研究生既是老师又是学生，所以在职研究生既需要交学费又会有工资。
下面要求编写一个程序来统计在职研究生的收入与学费，如果收入减去学费不足2000 元，则输出“provide a loan”(需要贷款)信息,。
本案例要求使用接口实现该程序。
2. 运行结果
【案例目标】
-
学会“抽象类实现不同图形的打印程序设计”的实现思路。
-
独立完成“抽象类实现不同图形的打印程序设计”的源代码编写、编译及运行。
-
掌握方法的重写。
-
掌握接口的应用。
【案例分析】
（1）定义两个接口，在StudentManageInterface接口中声明两个方法：getFree()和setFree()，用于设置和获取学生的学费;在TeacherManageInterface类中声明两个方法：gePay()和setPaye()，用于设置和获取教师的工资。
（2）定义主类 Graduate，分别实现StudentManageInterface和TeacherManageInterface接口。
（3）定义Graduate类的成员变量，和构造方法。
（4）给出四个接口方法的实现。
（5）给出一个计算是否需要贷款的方法，在里面统计年收入和学费，并输出是否需要贷款的信息。
（6）在main() 方法中创建一个姓名为“zhangsan”的研究生，调用计算是否需要贷款的方法。
【案例实现】
Graduate.java
class Graduate implements StudentManageInterface,
TeacherManageInterface {
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;
}
}
上述代码中，Graduate类实现了StudentManagerInterface和TeacherManagerInterface接口，并重写了两个接口中的方法。在main()方法中，计算了名为“zhangsan”的研究生是否需要贷款。
StudentManagerInterface.java
interface StudentManageInterface{ //interface 接口名
public abstract void setFree(double fee); //抽象方法
public abstract double getFree();
}
上述代码中，创建了一个StudentManagerInterface接口，定义了setFree()和get Free ()方法，用于设置和获取学生学费。
TeacherManagerInterface.java
interface TeacherManageInterface{
public abstract double getPay();
public abstract void setPay(double pay);
}
上述代码中，创建了一个TeacherManagerInterface接口，定义了setPay()和getPay()方法，用于设置和获取教师工资。
TestDemo.java
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");
}
}
【案例4-6】经理与员工工资案例（利用多态实现）
【案例介绍】
1. 案例描述
某公司的人员分为员工和经理两种，但经理也属于员工中的一种，公司的人员都有自己的姓名和地址，员工和经理都有自己的工号、工资、工龄等属性，但经理不同员工的是，经理有自己在公司对应的级别。假设每次给员工涨工资一次能涨10，经理能涨20%。
本案例要求利用多态实现给员工和经理涨工资。
2. 运行结果
【案例目标】
-
学会利用继承特性实现“经理与员工工资案例”的实现思路。
-
独立完成“经理与员工工资案例”的源代码编写、编译及运行。
-
掌握多态的概念及其应用。
-
掌握方法的重载的概念及其应用。
【案例分析】
（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输出涨薪工资。
【案例实现】
Person.java
public class Person {
private String name = "";
private String address = "";
//定义构造方法
public Person(String name, String address){
this.name = name;
this.address = address;
}
}
上述代码中，创建了一个父类Person类，在Person类中定义了name和address属性以及Person类的构造方法。
Employee.java
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;
}
}
上述代码中，创建了一个Employee类并继承了Person类，在Employee类中，定义了Employee类的构造方法，并在构造方法中调用了父类Person的构造方法；定义了员工的name和wage和age属性并提供了setter和getter方法；定义了抽象方法add()。
Manager.java
public class Manager extends Employee{
private String leve* = "";
public Manager(String name, String address, String ID, double wage,
int age, String level){
super(name, address, ID, wage, age);
this.leve* = 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.leve* = level;
}
}
上述代码中，创建了一个Manager类并继承了Employee类，在Manager类中，定义了Manager类的构造方法，并在构造方法中调用了父类Employee的构造方法；定义了员工的级别level属性并提供了setter和getter方法；实现了Employee类的抽象方法add()，并对add()方法进行了重载。
Test.java
public class Test {
public static void main(String[] args) {
Manager norma* = 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("norma* wage is:"+normal.getWage());
System.out.println("manager wage is:"+manager.getWage());
}
}
上述代码中，创建了一个测试类Test类，在类中对Manager进行了实例化并传参。类中通过调用无参的add()方法来获取普通员工的涨薪，调用有参的add(manager.getLevel())方法来获取经理的涨薪
【案例4-7】图形的面积与周长计算程序
【案例介绍】
1. 案例描述
长方形和圆形都属于几何图形，都有周长和面积，并且它们都有自己的周长和面积计算公式。使用抽象类的知识设计一个程序，可以计算不同图形的面积和周长。
2. 运行结果
【案例目标】
-
学会“图形的面积与周长计算程序设计”的实现思路。
-
独立完成“图形的面积与周长计算程序设计”的源代码编写、编译及运行。
-
理解和掌握面向对象的设计过程。
-
掌握抽象类及抽象方法的使用。
【案例分析】
（1）定义父类Shape作为抽象类，并在类中定义抽象方法求周长和面积。
（2）定义Shape子类圆形(circle)，具有半径属性和常量PI，同时必须实现父类中的抽象方法。
（3）定义Shape子类长方形(rectangle)，具有长和宽的属性，同时必须实现父类的抽象方法。
（4）创建图形面积周长计算器(ShapeCalculate)，具有计算不同图形面积和周长的方法。
（5）创建测试类TestShape类，在其main()方法中对ShapeCalculate计算面积和周长方法进行测试。
【案例实现】
Shape.java
public abstract class Shape {
// 抽象方法： 获取面积
public abstract double getArea();
// 抽象方法：获取周长
public abstract double getPerimeter();
}
上述代码中，在Shape类中定义了面积和周长的抽象方法。
Cirle.java
public class Circle extends Shape {
private double radius = 0; // 圆的半径
private fina* 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;
}
}
上述代码中，定义了圆形Circle类并继承了Shape类，再Circle类中重写了Shape中的getArea()和getPerimeter()方法，分别计算圆的面积和周长。
Rectangle.java
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);
}
}
上述代码中，定义了长方形Rectangle类并继承了Shape类，再Circle类中重写了Shape中的getArea()和getPerimeter()方法，分别计算长方形的面积和周长。
ShapeCaculate.java
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());
}
}
创建了图形面积周长计算器ShapeCalculate类，calArea ()方法用来计算不同图形面积，calPerimeter()方法用来计算不同图形的周长。
TestShape.java
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);
}
}
在上述代码中，分别创建了一个圆形circle对象和一个长方形rectangle对象，然后分别计算了圆形和长方形的面积和周长。
【案例4-8】模拟物流快递系统程序设计
【案例介绍】
1. 案例描述
网购已成为人们生活的重要组成部分，当人们在购物网站中下订单后，订单中的货物就会在经过一系列的流程后，送到客户的手中。而在送货期间，物流管理人员可以在系统中查看所有物品的物流信息。编写一个模拟物流快递系统的程序，模拟后台系统处理货物的过程。
2. 运行结果
【案例目标】
-
学会分析“模拟物流快递系统程序设计”任务实现的逻辑思路。
-
能够独立完成“模拟物流快递系统程序设计”的源代码编写、编译及运行。
-
掌握面向对象封装、继承和多态的概念和使用。
-
掌握抽象类和接口的使用。
【案例分析】
（1）运输货物首先需要有交通工具，所以需要定义一个交通工具类。由于交通工具可能有很多，所以可以将该交通工具类定义成一个抽象类，类中需要包含该交通工具的编号，型号以及运货负责人等属性，还需要定义一个抽象的运输方法。
（2）当运输完成后，需要对交通工具进行保养，所以需要定义保养接口，具备交通工具的保养功能。
（3）交通工具可能有很多种，这里可以定义一个专用运输车类，该类需要继承交通工具类，并实现保养接口。
（4）有了运输的交通工具后，就可以开始运送货物了。货物在运输前，运输时和运输后，都需要检查和记录，并且每一个快递都有快递单号，这时可以定义一个快递任务类包含快递单号和货物重量的属性，以及送前、发送货物途中和送后的方法。
（5）在货物运输过程中，需要对运输车辆定位，以便随时跟踪货物的位置信息。定位功能可以使用GPS，而考虑到能够实现定位功能的设备可能有很多（如手机、专用定位仪器等），这时可以定义一个包含定位功能的GPS接口，以及实现了该接口的仪器类（如Phone等）。
（6）编写测试类，运行查看结果。
【案例实现】
定义交通工具类Transportation，该类是一个抽象类，包含交通工具信息和运输货物方法，其代码如文件4-26所示。
Transportation.java
/*
* 交通工具类
*/
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;
}
}
在上述代码中，分别定义了车辆编号、车辆型号和车辆负责人的属性，以及其各自的getter和setter方法，同时还定义了一个抽象的运输方法transport()。
定义交通工具保养接口Careable，该接口中包含车辆保养的方法，其实现代码如下所示。
Careable.java
/*
*定义保养接口，具备保养功能。
*/
public interface Careable{
//保养方法
public abstract void upKeep();
}
定义专用运输车类Ztransportation，该类继承了交通工具类，并实现了保养接口，其实现代码如下所示。
Ztransportation.java
/*
* 专用运输车类
*/
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("货物运输车辆保养完毕!");
}
}
定义快递任务类SendTask，该类的具体实现代码如下所示。
SendTask.java
/*
*快递任务类
*/
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;
}
}
定义包含显示位置功能的GPS接口和实现类Phone，其实现代码如GPS.java和Phone.java所示。
GPS.java
/*
*定义GPS接口，具备GPS定位功能。
*/
public interface GPS{
//显示坐标的方法
public String showCoordinate();
}
Phone.java
/*
*定义一个手机类，实现GPS接口，拥有定位功能。
*/
class Phone implements GPS{
public Phone() { //空参构造
super();
}
//定位方法
public String showCoordinate() {
String location = "193,485";
return location;
}
}
定义测试类，实例化对象并传入数据，测试运行结果，其代码如下所示。
Task02Test.java
/*
*定义测试类
*/
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();
}
}