CH4-面向对象下 (8个案例实现)

【案例4-1】打印不同的图形

【案例介绍】

1. 案例描述

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

2. 运行结果

CH4-面向对象下 (8个案例实现)_第1张图片

【案例目标】

  • 学会“抽象类实现不同图形的打印程序设计”的实现思路。

  • 独立完成“抽象类实现不同图形的打印程序设计”的源代码编写、编译及运行。

  • 掌握抽象类的应用。

  • 掌握方法的重写。

  • 掌握继承的概念及其应用。

【案例分析】

​ (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. 运行结果

CH4-面向对象下 (8个案例实现)_第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】多彩的声音

【案例介绍】

  1. 案例描述
    设计和实现一个Soundable发声接口,该接口具有发声功能,同时还能调节声音大小。
    Soundable接口的这些功能将由有3种声音设备来实现,他们分别是收音机Radio、随身听Walkman、手机MobilePhone。

    ​ 最后还需设计一个应用程序类来使用这些实现Soundable接口的声音设备。程序运行时,先询问用户想哪个设备,用户选择设备后,程序按照该设备的工作方式打印发出的发音。本案例要求使用抽象类实现。

  2. 运行结果

CH4-面向对象下 (8个案例实现)_第3张图片

【案例目标】

  • 学会分析“发声接口程序设计”实现的逻辑思路。
  • 能够独立完成“发声接口程序设计”的源代码编写、编译及运行。
  • 掌握接口的实现方式。

【案例分析】

​ 通过任务的描述可知,此程序包含了一个发声接口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.运行结果CH4-面向对象下 (8个案例实现)_第4张图片

【案例目标】

  • 学会“学生和老师”的实现思路。

  • 独立完成“学生和老师”的源代码编写、编译及运行。

  • 掌握方法的重写。

  • 掌握抽象类的应用。

【案例分析】

​ (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. 运行结果

CH4-面向对象下 (8个案例实现)_第5张图片

【案例目标】

  • 学会“抽象类实现不同图形的打印程序设计”的实现思路。

  • 独立完成“抽象类实现不同图形的打印程序设计”的源代码编写、编译及运行。

  • 掌握方法的重写。

  • 掌握接口的应用。

【案例分析】

​ (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. 运行结果

CH4-面向对象下 (8个案例实现)_第6张图片

【案例目标】

  • 学会利用继承特性实现“经理与员工工资案例”的实现思路。

  • 独立完成“经理与员工工资案例”的源代码编写、编译及运行。

  • 掌握多态的概念及其应用。

  • 掌握方法的重载的概念及其应用。

【案例分析】

​ (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. 运行结果

CH4-面向对象下 (8个案例实现)_第7张图片

【案例目标】

  • 学会“图形的面积与周长计算程序设计”的实现思路。

  • 独立完成“图形的面积与周长计算程序设计”的源代码编写、编译及运行。

  • 理解和掌握面向对象的设计过程。

  • 掌握抽象类及抽象方法的使用。

【案例分析】

​ (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. 运行结果

CH4-面向对象下 (8个案例实现)_第8张图片

【案例目标】

  • 学会分析“模拟物流快递系统程序设计”任务实现的逻辑思路。

  • 能够独立完成“模拟物流快递系统程序设计”的源代码编写、编译及运行。

  • 掌握面向对象封装、继承和多态的概念和使用。

  • 掌握抽象类和接口的使用。

【案例分析】

​ (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();		
    }
}

你可能感兴趣的:(java)