一、对类进行动态实例化 Class.forName()
为某机构编写一个通用程序,用来计算每一种交通工具运行 1000 公里所需的时间,已知每种交通工具的参数都是 3 个浮点数 A、B、C 的表达式。现有两种工具:Car 和 Plane,其中 Car 的速度运算公式为:A*B/C,Plane 的速度运算公式为:A+B+C;需要编写三个类:ComputeTime、Plane、Car 和接口 Common,要求在未来如果增加第 3 种交通工具的时候,不必修改以前的任何程序,只需要编写新的交通工具的程序。
要求:绘制类图并编程实现。
提示:动态实例化代码: Class.forName(args[0]).newInstance();
注意事项:
参数 args[0]应该为完整的类名;如果对类进行动态实例化,则该类可以不定义构造方法,或者是无参的。
实验过程:
1、构建实现场景,画出UML类图
*commmon : common
实现代码
import org.w3c.dom.;
import javax.xml.parsers.;
import java.io.*;
public class XMLUtilCommon {
//该方法从xml配置文件中提取交通工具,并返回该名称
public static String gettypeName() {
try {
//创建文档对象
DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dFactory.newDocumentBuilder();
Document doc;
doc = builder.parse(new File(“configCommon.xml”));
//获取保护文本名称的文本节点
NodeList nl = doc.getElementsByTagName(“typeName”);
Node classNode = nl.item(0).getFirstChild();
String typeName = classNode.getNodeValue().trim();
return typeName;
}
catch (Exception e)
{
e.printStackTrace();
return null;
}
}
public class Common{
public static Common produceCommon(String type) throws Exception
{
if(common.equalsIgnoreCase(“Car”))
{
System.out.println(“车子的速度计算”);
return new Car();
}
else if(common.equalsIgnoreCase(“Plane”))
{
System.out.println(“飞机的速度计算”);
return new Plane();
}
else
{
throw new Exception(“没”);
}
}
}
public interface Common {
public void computetime();
}
public class Car implements car{
public void computetime()
{
System.out.println(“车子的速度计算公式A*B/C”);
}
}
public class Plane implements Common{
public void computetime()
{
System.out.println(“飞机的速度计算公式A+B+C”);
}
}
public class Client {
public static void main(String args[])
{
try
{
Common common;//抽象类型定义
String typeName = XMLUtilCommon.gettypeName();
common = Common.produceCommon(TypeName);
common.computetime();
}
catch (Exception e)
{
System.out.println(e.getMessage());
}
}
}
二、使用简单工厂模式设计一个可以创建不同几何形状(shape)的绘图工具类,如何创建(circle)、矩形(Rectangel)和三角形(Triangel)对象,每个几何图形都有draw方法和擦除方法(erase),要求在绘制不支持的几何图形时,抛出一个UnsupportedShapException异常,绘制类图并编程实现。
实验过程:
1、构建实现场景,画出UML类图
2、实现代码
public class ShapeFactory {
public Shape createShape(String type) throws
UnsupportedSgapeException {
if(type.equals(“Circle”))
return new Circle();
else if(type.equals(“Rectangle”))
return new Rectangle();
else if(type.equals(“Triangle”))
return new Triangle();
else{
throw new UnsupportedShapeException(“该系统不会画这个”);
}
}
public static void main(String[] args) throws
UnsupportedShapeException {
ShapeFactory shapeFactory = new ShapeFactory();
shapeFactory.createShape(“Circle”).draw();
shapeFactory.createShape(“Circle”).erase();
shapeFactory.createShape(“Rectangle”).draw();
shapeFactory.createShape(“Rectangle”).erase();
shapeFactory.createShape("Triangle").draw();
shapeFactory.createShape("Triangle").erase();
shapeFactory.createShape("Square").draw();
}
}
public class UnsupportedShapeException extends Exception{
private String message;
public UnsupportedShapeException(String message) {
System.out.println(message);
}
}
public interface Shape {
public void draw();
public void erase();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println(“画个矩形”);
}
@Override
public void erase() {
System.out.println("擦除");
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println(“画个圆形”);
}
@Override
public void erase() {
System.out.println("擦除");
}
public class Triangle implements Shape {
@Override
public void draw() {
System.out.println(“画个三角形”);
}
@Override
public void erase() {
System.out.println("擦除");
}
}
三、某系统提供一个简单计算器,具有简单的加法与减法功能,系统可以根据用户的选择实例化相应的操作类,现使用简单工厂设计该系统,
1、类图如下:
*Substract : Subtraction
2、请编程实现。
public interface Calculator {
public void compute();
}
public class CalculatorFactory {
public Calculator createCalculator(String type)throws
UnsupportException{
if (type.equals(“Addition”))
return new Addition();
else if (type.equals(“Subtraction”))
return new Subtraction();
else{
throw new UnsupportException(“无”);
}
}
public static void main(String[] args) throws
UnsupportException {
CalculatorFactory calculatorFactory = new CalculatorFactory();
calculatorFactory.createCalculator(“Addition”).compute();
calculatorFactory.createCalculator(“Subtraction”).compute();
}
}
public class Addition implements Calculator {
public void compute() {
System.out.println(“加法”);
}
}
public class Subtraction implements Calculator{
public void compute() {
System.out.println(“减法”);
}
}
public class UnsupportException extends Exception{
private String message;
public UnsupportException(String message) {
System.out.println(message);
}
}