Educoder-Java程序开发基础-继承与多态（二）

第1关：继承-1

​ 本关任务：定义一个表示“雇员”(Employee)的类。定义一个表示“经理”（Manager）的类继承Employee，经理每月获得一份固定的工资。定义一个表示“工人”（Worker）的类继承Employee，工人按每月工作的天数计算工资。

	package test_extend;

/**
 * @author pengzheng
 */

class Employee { // 定义员工类
    String name;
    int age;
    double salary; // 定义 double类型的成员变量salary，表示工资

    Employee(String name, int age) {
        this.name = name;
        this.age = age; // 初始化成员变量age
    }

    void showInfo() {
        System.out.println("姓名是：" + this.name);
        System.out.println("年龄是：" + this.age);
        System.out.println("工资是：" + this.salary);// 显示工资的信息，格式为“工资是：***”
    }
}

class Manager extends Employee { // 定义Manager类，继承Employee类
    Manager(String name, int age, double salary) {
        super(name, age); // 调用父类构造方法，以初始化成员变量name和age
        this.salary = salary;
    }
}

class Worker extends Employee { // 定义“工人”类Worker，继承“员工”类Employee
    int workingDays; // 成员变量workingDays，表示工作天数
    double dailyWage; // 定义 double类型的成员变量 dailyWage，表示日薪

    void setSalary(int workingDays, double dailyWage) {
        this.workingDays = workingDays;
        this.dailyWage = dailyWage;
        this.salary = workingDays * dailyWage; // 工资=工作天数*日薪
    }

    Worker(String name, int age, int workingDays, double dailyWage) {
        super(name,age); // 调用父类构造方法，以初始化name和age

        setSalary(workingDays,dailyWage); // 调用成员方法setSalary，以初始化工作天数、日薪和月薪
    }

    void showInfo() { // 覆盖override父类的showInfo()方法
        super.showInfo(); // 调用父类被覆盖的showInfo()，以显示姓名、年龄、工资的信息
        System.out.println("工作天数是：" + this.workingDays);
        System.out.println("日薪是：" + this.dailyWage);
    }
}

public class TestExtend {

    public static void main(String[] args) {
        Manager manager = new Manager("张三",40,10000); // 创建一个经理对象：张三、40岁、10000元月薪
        manager.showInfo(); // 调用manager的showInfo()方法，显示该经理的信息。
        Worker worker = new Worker("李四",20,22,200); // 创建Worker对象：李四、20岁、月工作22天、日薪200
        worker.showInfo();
    }

}

第2关：继承-2

​ 本关任务：定义一个表示“汽车”的类Vehicle。定义了属性：车轮数wheels和车重weight；构造方法用以初始化对象属性；show方法用以输出相关属性。定义Vehicle类的子类Trunk，表示“卡车”，新增属性load，表示载重量；定义Vehicle类的子类Minibus，表示“面包车”，新增属性passenger，表示载客数。为这两个类定义合适的构造方法用以初始化对象属性，需要显示调用父类构造方法。为这两个类定义show方法用以输出相关属性，需要覆盖Override父类的show方法。

package test_vehicle;

/**
 * @author pengzheng
 */

class Vehicle {
    int wheels; // 车轮数
    float weight; // 车重

    Vehicle(int wheels, float weight) {
        this.wheels = wheels;
        this.weight = weight;
    }

    void show() {
        System.out.print("车轮:" + this.wheels);
        System.out.print(", 车重:" + this.weight);
    }
}

//定义Vehicle类的子类Trunk，表示“卡车”，新增float类型的属性load，表示载重量
/********* begin *********/
class Trunk extends Vehicle{
    float load;
    public Trunk(int wheels, float weight,float load){
        super(wheels,weight);
        this.load=load;
    }
    /********* begin *********/

    /********* end *********/

    void show() {
        System.out.println("车型:卡车");
        super.show();
        System.out.println(", 载重量:" + this.load);
    }
}

// 定义Vehicle类的子类Minibus，表示“面包车”，新增int类型的属性passenger，表示载客数。
// 定义合适的构造方法用以初始化对象属性，需要显示调用父类构造方法。
/********* begin *********/
class Minibus extends Vehicle{
    int passenger;
    public Minibus(int wheels, float weight,int passenger){
        super(wheels,weight);
        this.passenger=passenger;
    }
    /********* end *********/

    // 覆盖Override父类的show方法。
    void show() {
        System.out.println("车型:面包车");
        /********* begin *********/
        super.show();
        /********* end *********/
        System.out.println(", 载人:" + this.passenger);
    }
}

public class TestVehicle {
    public static void main(String[] args) {
        Vehicle trunk = new Trunk(6, 7500, 80);
        trunk.show();
        Vehicle minibus = new Minibus(4, 3000, 12);
        minibus.show();
    }
}

第3关：访问控制

​ 本关任务：请用注释的方式指出代码中的语法错误，并修改使其能通过编译、正确运行，请参考预期输出

package access_control;

class SupClass {
    //public final int CONST = 1;
    int i;
    protected int j;
    public SupClass(int i, int j) {
        //	CONST = 2;
        this.i = i;
        this.j = j;
    }
    //final void m1() {
    //	System.out.println("SupClass m1()");
    //}
    void m2() {
        System.out.println("SuperClass m2()");
    }
}

class SubClass extends SupClass {
    public int k;
    public SubClass(int i, int j, int k) {
        super(i,j);
        this.i = i;
        this.j = j;
        this.k = k;
    }
    void m1() {
        System.out.println("SubClass m1()");
        System.out.println("SubClass m1()");
    }
    void m2() {
        System.out.println("SubClass m2()");
    }
}

public class FindWrong {
    public static void main(String[] args) {
        SubClass sub = new SubClass(1,2, 3);
        //System.out.println(sub.i);
        System.out.println(sub.j);
        System.out.println(sub.k);
        sub.m1();
        sub.m2();
    }
}

第4关：抽象类

​ 本关任务：定义了一个表示“形状”(Shape)的抽象类，定义Shape类的子类：长方形类(Rectangle)、圆形类(Circle)，在主类的main方法中创建了两个形状对象，并打印出这两个形状的面积

package test_abstract;

abstract class Shape  { // 定义一个抽象类Shape，表示形状
	public double area; // 面积

	abstract double getArea(); // 声明一个抽象方法 getArea()，方法的返回值类型是double
}

class Rectangle extends Shape { // 定义一个表示矩形的类Rectangle，继承Shape
	public double length; // 长
	public double width; // 宽

	public Rectangle(double length, double width) { // 构造方法
		this.length = length; // 初始化成员变量length
		this.width = width;
	}

	public double getArea() { // 实现父类的抽象方法 getArea()
		return length*width;  // 返回矩形的面积
	}
}

class Circle extends Shape { // 定义一个表示圆形的类Circle，继承Shape
	public double radius; // 半径

	public Circle(double radius){ // 定义Circle类的构造方法
		this.radius=radius;
	}
	public double getArea() {
		return radius * radius * Math.PI;
	}
}

public class TestAbstract {
	public static void main(String[] args) {
		Shape s1 = new Rectangle(4,5); // 创建一个长为4，宽为5的矩形对象。
		System.out.println(s1.getArea());
		Shape s2 = new Circle(3);
		System.out.println(s2.getArea()); // 打印出形状s2的面积
	}
}

第5关：接口

​ 1、所有的门（Door）都具有开（open）和关（close）的功能，但是不同类型的门，它们开和关的方式可能是不一样的，所以可以把“门”定义为一个抽象类Door。 2、有些门具有报警（alarm）的功能，但不是所有类型的门都具有报警的功能，所以可以把“能报警”的行为特征定义为一个接口Alarmable。 3、“安全门”是一种具体类型的门，它除了具有一般“门”的特性之外，还具有“能报警”的功能，所以可以把“安全门”定义为一个继承抽象类“门”并实现接口“能报警”的具体类SafetyDoor。

package test_interface;

/**
 * @author pengzheng
 */

//定义一个抽象类Door，声明抽象方法open和close
/********* begin *********/
abstract class Door{
    abstract void open();
    abstract void close();
}
/********* end *********/

//定义一个接口Alarmable，声明方法alarm
/********* begin *********/
interface Alarmable{
    public void alarm();
}
/********* end *********/

//定义一个类SafetyDoor，使其继承Door，并实现接口Alarmable
/********* begin *********/
class SafetyDoor extends Door implements Alarmable{


    /********* end *********/

    @Override
    public void alarm() {
        System.out.println("alarm");
    }

    //实现open方法，方法体内打印出"open"
    /********* begin *********/
    public void open(){
        System.out.println("open");
    }
    /********* end *********/

    //实现close方法，方法体内打印出"close"
    /********* begin *********/
    public void close(){
        System.out.println("close");
    }
    /********* end *********/
}

public class TestInterface {
    public static void main(String[] args) {
        SafetyDoor safetyDoor = new SafetyDoor();
        safetyDoor.open();
        safetyDoor.close();
        safetyDoor.alarm();
    }
}