java 立方米转立方毫米 java计算立方体体积

子类与继承(一)

[实验任务1]抽象类图形类

[任务介绍]

        1. 任务描述

        编写一个抽象类图形类，该类具有长和高等属性，具有求面积的抽象方法。

        编写图形类的子类矩形类，该类重写了求面积的方法，可以求矩形的面积。编写图形类的子类三角形类，该类重写了计算面积的方法。定义柱状体类，该类中定义了图形类和柱状体的高，并编写了求柱状体体积的方法,如果柱状体的底面为三角形，则计算三棱柱的体积，如果柱状体的底面为矩形，则该计算长方体或正方体的体积。编写带有主方法的测试类，在主方法中创建柱体的对象，并根据柱体的不同的底面分别求该柱体的体积。

       备往:

        (1)类的命名:图形类(Shape)、 矩形类(Rec)、 子类三角形类(Tri)、柱状体类(Cx);

        (2)测试类的主函数内容如下:

public static void main(String[] args) {
                // TODO 自动生成的方法存根
                Rec rec = new Rec(5,6);
                cy1 c1=new cy1(8,rec);
                Tri tri = new Tri(5,6);
                cy1 c2=new cy1(8,tri);
                System.out . print1n("三楼柱的体积。+c1.getvo1());
                System. out . print1n("长方体或正方体的体职，"+c2. getVol()); 
        }

        2. 运行结果

[任务目标]

1. 学会分析“抽象类图形类”程序的实现思路；
2. 根据思路独立完成“抽象类图形类”的源代码编写、编译和运行；
3. 掌握重写的目的以及super关键字的使用；
4. 掌握子类与父类的关系，抽象类概念；
5. 上转型对象的概念及应用。

[实现思路]

1. 建立5个类，其中Shape为Tri、Rec的父类。
2. 在父类Shape中抽象一个求面积的area()的抽象函数。
3. Tri、Rec重载抽象函数area()；分别计算三角形、矩形的面积。
4. 类Cx进行体积的计算，运用到上转型概念。

UML图如下： 

[实现代码及运行结果] 

 Shape

package b;
public abstract class Shape {
	int length,height;
	abstract double area();
}

 Rec

package b;
public class Rec extends Shape{
	int length,height;
	public Rec(int length, int height) {
		super();
		this.length = length;
		this.height = height;
	}
	@Override
	double area() {
		// TODO 自动生成的方法存根
		return length*height;
	}
}

 Tri

package b;
public class Tri extends Shape{
	int length,height;
	public Tri(int length, int height) {
		super();
		this.length = length;
		this.height = height;
	}
	@Override
	double area() {
		// TODO 自动生成的方法存根
		return length*height/2;
	}
}

 Cx

package b;
public class Cx {
	double height;
	Shape shape;
	public Cx(double height, Shape shape) {
		super();
		this.height = height;
		this.shape = shape;
	}
	double getvol(){
		return shape.area()*height;
	}
}

 Test

package b;
public class Test {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Rec rec=new Rec(5,6);
		Cx c1=new Cx(8,rec);
		Tri tri=new Tri(5,6);
		Cx c2=new Cx(8,tri);
		System.out.println("三棱柱的体积："+c1.getvol());
		System.out.println("长方体或正方体的体积："+c2.getvol());
	}
}

[实验任务2]银行计算利息

[任务介绍]

        1. 任务描述

        假设银行Bank已经有了按整年year计算利息的一般方法，其中year只能取正整数。比如按整年计算的方法：

double computerInterest() {
                interest=year*0.35*savedMoney;
                return interest; 
        }

         建设银行ConstructionBank 是Bank 的子类，准备隐藏继承的成员变量year，并重写计算利息的方法，即自己声明一个double 型的year变量，比如，当year 取值是5.216 时，表示要计算5 年零216 天的利息，但希望首先按银行Bank的方法computerInterest()计算出5 整年的利息，然后再自己计算216 天的利息。那么，建设银行就必须把5.216 的整数部分赋给隐藏的year，并让super 调用隐藏的、按整年计算利息的方法。

        要求ConstructionBank 和BankOfDalian 类是Bank 类的子类，ConstructionBank 和BankOfDalian 都使用super 调用隐藏的成员变量和方法。

        ConstructionBank、BankOfDalian 和Bank 类的UML 图如下图所示。

        备注：

                1. 输入的利率均为年利率，天利率为年利率/365；

                2. 上面的UML图中Bank类少写“利率”成员变量。

        2. 运行结果 

[任务目标]

1. 学会分析“银行计算利息”程序的实现思路；
2. 根据思路独立完成“银行计算利息”的源代码编写、编译和运行；
3. 掌握重写的目的以及super关键字的使用；
4. 掌握子类与父类的关系。

[实现思路]

1. 建立4个类，分别为父类Bank、子类ConstructionBank和BankOfDalian，以及测试类Test。
2. 父类Bank用computerInterest();函数计算整年的利息。
3. 子类ConstructionBank和BankOfDalian重载computerInteres();函数，计算不够整年的利息。然后用super关键字调用父类中的隐藏函数和对象。
4. 测试类Test中，建设银行和大连银行的对象savedMoney、year是一样的，需要在输入数据后将其值赋为一样。

UML图如下： 

[实现代码及运行结果] 

实现代码如下：

Bank 

package a;
public class Bank {
	int savedMoney,year;
	double interest;
	double rate;
	double computerInterest(){
		interest=year*rate*savedMoney;
		return interest;
	}
}

ConstructionBank 

package a;
public class ConstructionBank extends Bank{
	double year;
	double computerInterest(){
		super.year=(int)year;
		super.computerInterest();
		int day;
		day=(int)((year-super.year)*1000);
		return interest+day*rate/365*savedMoney;
	}
}

BankOfDalian 

package a;
public class BankOfDalian extends Bank{
	double year;
	double computerInterest(){
		super.year=(int)year;
		super.computerInterest();
		int day;
		day=(int)((year-super.year)*1000);
		return interest+day*rate/365*savedMoney;
	}
}

Test 

package a;
import java.util.Scanner;
public class Test {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner reader=new Scanner(System.in);
		ConstructionBank a=new ConstructionBank();
		BankOfDalian b=new BankOfDalian();
		System.out.print("存款金额（元）：");
		a.savedMoney=reader.nextInt();
		System.out.print("建设银行存款利率：");
		a.rate=reader.nextDouble();
		System.out.print("存款时长：");
		a.year=reader.nextDouble();
		System.out.println(a.savedMoney+"元在建设银行"+(int)a.year+"零"+(int)((a.year-(int)a.year)*1000)+"天利息："+a.computerInterest()+"元");
		b.savedMoney=a.savedMoney;
		b.year=a.year;
		System.out.print("大连银行存款利率：");
		b.rate=reader.nextDouble();
		System.out.println(b.savedMoney+"元在大连银行"+(int)b.year+"零"+(int)((b.year-(int)b.year)*1000)+"天的利息："+b.computerInterest()+"元");
		double c;
		c=a.computerInterest()-b.computerInterest();
		System.out.println("两家银行利息相差   "+c+" 元");
	}
}

 运行结果如下：

总结：

1. 此次实验涉及到抽象函数、上转型对象的应用以及super关键字的使用。
2. 对于abstract方法，只允许声明，不允许声明，不允许使用final和abstract同时修饰一个方法或类，也不允许使用static修饰abstract方法。
3. 当子类隐藏了继承的方法，那么子类创建的对象就不能调用被隐藏的方法，想使用被子类隐藏的成员变量或方法，就需要使用关键字super。