Java类练习一则

新建一个Hello类，代码拷贝进行即可运行...

项目一 1,2

题目：

项目一：
1.设计一个汽车类Auto，
其中包含一个表示速度的double型成员变量speed和表示启动的start()方法、
表示加速的speedUp()方法以及表示停止的stop()方法。方法体内写一个输出语句即可。

2.再设计一个Auto类的子类Bus表示公共汽车，
在Bus类中定义一个int型的表示乘客数的成员变量passenger，
另外定义两个方法getOn()和getOff()表示乘客上乘和下车。
编写一个应用程序BusTest，通过向下转型分别输出子类对象中的各成员变量和方法。

3.改写程序，定义一个接口A包含一个返回值为double类型的抽象方法distance()和一个全局常量HOUR=10,
定义另一个接口B包含一个返回值为double类型的抽象方法cost()，
分别定义三个类Bus、Train、Plane都实现A、B两接口，Bus类包含一个常量SPEED=60，
同时覆写distance()方法，计算距离=时间*速度。
覆写cost()方法，在cost()方法下声明一个double类型的常量COSTOFPERKILOMETER=2.5,通过调用distance()方法乘以常量COSTOFPERKILOMETER作为返回结果；
Train类包含一个常量SPEED=130，同时覆写distance()方法，计算距离=时间*速度。
覆写cost()方法，在cost()方法下编写流程控制结构，如果输入“儿童”，返回值是72.6，如果输入“成人”，返回值是145.2；
Plane类包含一个常量SPEED=315，同时覆写distance()方法，计算距离=时间*速度。
覆写cost()方法，在cost()方法下编写流程控制结构，如果输入“经济舱”，返回值是1123.5，如果输入“商务舱”，返回值是2315.5；
通过测试程序Test类，分别实例化Bus、Train、Plane对象，并调用每个对象的两个方法。

// 汽车类
class Auto {
	
	private double speed = 0.0;  // 速度
	
	// 启动方法
	public void start() {
		System.out.println("汽车正在启动...");
	}
	
	// 加速方法
	public void speedUp() {
		System.out.println("汽车开始加速...");
		this.speed += 1.23;
	}
	
	// 停止方法
	public void stop() {
		System.out.println("汽车即将停止...");
	}
	
}

// Bus类继承汽车类
class Bus extends Auto{
	
	private int passenger = 0;  // 人数
	
	// 上车方法
	public void getOn() {
		System.out.println("上车请往后走...");
		this.passenger += 1;
	}
	
	// 下车方法
	public void getOff() {
		System.out.println("下车请注意安全...");
	}
	
}

// 主类 & 测试类
class Hello {
	public static void main(String[] args) {
		
		// 向上转型
		Auto auto = new Bus();
		// 向下转型
		Bus bus = (Bus)auto;
		// 调用方法
		bus.start();
		bus.getOn();
		bus.speedUp();
		bus.getOff();
		bus.stop();
		
	}
}

运行结果：

项目一 3

import java.util.Scanner;

// 接口A
interface A {
	public static final int HOUR = 10;  // 时间
	double distance();
}

// 接口B
interface B {
	double cost();
}

// 公共汽车类
class Bus implements A, B {
	
	private final int SPEED = 60;  // 速度常量

	@Override
	public double cost() {
		final double COSTOFPERKILOMETER = 2.5;
		double result = distance()*COSTOFPERKILOMETER;
		return result;
	}

	@Override
	public double distance() {
		return HOUR*SPEED;
	}
	
}

// 火车类
class Train implements A, B {
	
	private final int SPEED = 130;  // 速度常量
	Scanner scanner = new Scanner(System.in);

	@Override
	public double cost() {
		while(true) {
			System.out.print("坐火车请输入乘客类型: ");
			String kind = scanner.nextLine();
                        // 下面这种比较，"成人"文字串放到前面更好，也就是："成人".equals(kind)
                        // 因为这样，即使kind是null也不会出错
			if (kind.equals("成人")) {
				return 145.2;
			} else if (kind.equals("儿童")) {
				return 72.6;
			} else {
				System.out.println("输入有误,请重新输入");
			}
		}
	}

	@Override
	public double distance() {
		return HOUR*SPEED;
	}
	
}

// 飞机类
class Plane implements A, B{
	
	private final int SPEED = 315;  // 速度常量
	Scanner scanner = new Scanner(System.in);

	@Override
	public double cost() {
		while(true) {
			System.out.print("坐飞机请输入座席类型: ");
			String kind = scanner.nextLine();
			if (kind.equals("经济仓")) {
				return 1123.5;
			} else if (kind.equals("商务仓")) {
				return 2315.5;
			} else {
				System.out.println("输入有误,请重新输入");
			}
		}
	}

	@Override
	public double distance() {
		return HOUR*SPEED;
	}
	
}

// 主类 & 测试类
class Hello {
	public static void main(String[] args) {
		// 实例化汽车类并测试方法
		Bus bus = new Bus();
		System.out.println("汽车距离: " + bus.distance());
		System.out.println("坐汽车人花费: " + bus.cost());
		System.out.println("--------------------------");
		
		// 实例化火车类并测试方法
		Train train = new Train();
		System.out.println("火车距离: " + train.distance());
		System.out.println("坐火车花费: " + train.cost());
		System.out.println("--------------------------");
		
		// 实例化飞机类并测试方法
		Plane plane = new Plane();
		System.out.println("飞机距离: " + plane.distance());
		System.out.println("坐飞机花费: " + plane.cost());
		System.out.println("--------------------------");
	}
}

运行结果：

项目二 4,5，6，7

题目：

项目二： 
4.定义一个Shape（几何形状）抽象类，在该类中定义一个String类型的成员变量name，对该成员变量进行修改和获取值的方法；
一个抽象方法perimeter()求周长，一个抽象方法area()求面积；
另外定义构造方法Shape(String name)和Shape()；方法 display(){System.out.println(“This is a shape:”+getName)；}。 

5.分别定义Circle（圆形）类，Rectangle（矩形）类，让他们都继承Shape类。在Circle类中包含一个double型变量radius；
在Rectangle类中包含一个double型的变量width和一个一个double型的变量length；实现对成员变量进行修改和获取值的方法；
实现带参和无参构造方法；实现抽象方法；重载display()方法。 

6.编写一个ShapeTest类，用Math.random()实现随机生成圆形或矩形；用静态方法show(Shape s)调用display()方法显示。 

7.改写程序，定义一个接口A，将display()方法的定义放入A接口中，让ShapeTest类实现该接口。

// 几何形状抽象类
abstract class Shape {
	
	// 形状名
	private String name;
	
	// 构造方法
	Shape(){};
	Shape(String name) {
		this.name = name;
	}
		
	// 求周长
	abstract void perimeter();
	
	// 求面积
	abstract void area();
	
	// 信息输出函数
	public void display() {
		System.out.println("This is a shape: " + getName());
	}
	
	// Getter & Setter
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return this.name;
	}
}

// 圆类
class Circle extends Shape {
	
	private double radius;

	public Circle() {};
	public Circle(double radius) {
		super();
		this.radius = radius;
	}

	@Override
	void perimeter() {
		// TODO Auto-generated method stub
		
	}

	@Override
	void area() {
		// TODO Auto-generated method stub
		
	}
	
	@Override
	public void display() {
		super.display();
		System.out.println("And Radius is: " + getRadius());
	}

	// Setter & Getter
	public double getRadius() {
		return this.radius;
	}

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

	
}

// 矩形类
class Rectangle extends Shape {
	
	private double width;
	private double length;

	public Rectangle() {};
	public Rectangle(double width, double length) {
		super();
		this.width = width;
		this.length = length;
	}

	@Override
	void perimeter() {
		// TODO Auto-generated method stub
		
	}

	@Override
	void area() {
		// TODO Auto-generated method stub
		
	}
	
	
	@Override
	public void display() {
		super.display();
		System.out.println("Width is: " + getWidth());
		System.out.println("Length is: " + getLength());
	}
	
	// Setter & Getter
	public double getWidth() {
		return this.width;
	}

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

	public double getLength() {
		return this.length;
	}

	public void setLength(double length) {
		this.length = length;
	}
	
}

// 独立测试类
class ShapeTest {
			
	public static void show(Shape shape) {
		shape.display();
	}
	
		Circle circle = new Circle(radius);
		Rectangle rectangle = new Rectangle(length=length, width=width);
		circle.setName("圆圆圆");
//		show(circle);
		circle.display();
		rectangle.setName("方方方");
//		show(rectangle);
		rectangle.display();
	}

	@Override
	public void display(Shape shape) {
		shape.display();
	}
	
}

// 主类 & 测试类
class Hello {
	public static void main(String[] args) {
		ShapeTest.main(args);
	}
}

运行结果：

项目三、8

题目：

项目三：
8.设计一个根据雇员类型利用abstract方法和多态性完成工资单计算的程序。
Employee是抽象类；Employee的子类有Boss(每星期发给他固定工资，而不计工作时间)、CommissionWorker(除基本工资外还根据销售额发放浮动工资)、
PieceWorker(按其生产的产品数发放工资)、HourlyWorker(根据工作时间长短发放工资)。

该例的Employee的每个子类都声明为final，因为不需要再继承它们生成子类。
在父类中声明earnings()为抽象方法，并且对于每个子类都提供恰当的earnings()实现方法。
对所有雇员类型都使用earnings()方法，但每个人挣的工资按他所属的雇员类计算，所有雇员类都是从父类Employee派生出的。

为了计算雇员的工资，程序仅仅使用雇员对象的一个父类引用并调用earnings()方法。
一个实际的工资系统中，各种Employee对象的引用可以通过一个Employee引用数组来实现。
程序依次使用数组的每个元素（Employee引用）调用每个对象的employee()方法。

// 抽象雇员类
abstract class Employee {

	// 声明薪水变量和挣钱方法
	private double salary = 0;
	abstract void earnings();
	
	// Setter & Getter
	public double getSalary() {
		return salary;
	}
	
	public void setSalary(double salary) {
		this.salary = salary;
	}
		
}

// 老板不干活还领固定工资没办法
final class Boss extends Employee {

	private int Day = 0;
	private static final double MONTHLY_PAY = 8040;  // 老板的月薪
	
	public Boss() {
		super();
	}
	
	// 用于初始化一个干了Day天活的老板
	public Boss(int Day) {
		super();
		this.Day = Day;
	}

	@Override
	void earnings() {
		setSalary(MONTHLY_PAY * Day);
		System.out.println("这个老板可以领:" + getSalary() + "元工资。");
	}
	
}

// 正式工有底薪还有补助你说气不气
final class CommissionWorker extends Employee {

	private int Day = 0;
	private double DayPay = 60.4;  // 每天加薪
	private static final double MONTHLY_PAY = 2000;  // 正式工的月薪
	
	
	public CommissionWorker() {
		super();
	}
	
	// 用于初始化一个干了Day天活的正式工
	public CommissionWorker(int Day) {
		super();
		this.Day = Day;
	}


	@Override
	void earnings() {
		setSalary(MONTHLY_PAY + Day*DayPay);
		System.out.println("这个正式工的工资是: " + getSalary() + "元人民币。");
	}
	
}

// 计件工多劳多得，适合能力强的
final class PieceWorker extends Employee {

	private int pieces = 0;  // 亻牛数
	private final double PIECES_PRICE = 96.4;  // 件工资
	
	public PieceWorker() {
		super();
	}
	
	// 初始化一个干了pieces件的计件工
	public PieceWorker(int pieces) {
		super();
		this.pieces = pieces;
	}

	@Override
	void earnings() {
		setSalary(pieces*PIECES_PRICE);
		System.out.println("这个计件工的工资是: " + getSalary() + "元人民币。");
	}
	
}

// 小时工就按时间算了，钱少不过偶尔可以偷个懒不是
final class HourlyWorker extends Employee {

	private int hour = 0;  // 小时
	private final double HOUR_PRICE = 78.9;  // 小时工资
	
	
	public HourlyWorker() {
		super();
	}
	
	public HourlyWorker(int hour) {
		super();
		this.hour = hour;
	}

	@Override
	void earnings() {
		setSalary(hour*HOUR_PRICE);
		System.out.println("这个小时工的工资是: " + getSalary() + "元人民币。");
	}
	
}


// 主类 & 测试类
class Hello {
	
	public static void main(String[] args) {
		
		// 初始化一个雇员数组
		Employee employee[] = new Employee[4];
		employee[0] = new Boss(23);
		employee[1] = new CommissionWorker(33); 
		employee[2] = new PieceWorker(44);
		employee[3] = new HourlyWorker(55);
		
		// 循环调用方法
		for (Employee worker:employee) {
			worker.earnings();
		}
	}
}

上面这个代码的主类还可以这样写：

// 主类 & 测试类
class Hello {
	
	public static void main(String[] args) {

		// 初始化一个雇员数组
		ArrayList<Employee> employee = new ArrayList<>();
		employee.add(new Boss(23));
		employee.add(new CommissionWorker(33));
		employee.add(new PieceWorker(44));
		employee.add(new HourlyWorker(55));
		
		// 循环调用方法
		for (Employee worker:employee) {
			worker.earnings();
		}
	}
}

运行结果：