Program:
请采用采用简单工厂设计模式，为某个汽车销售店设计汽车销售系统，接口car至少有方法print（），
三个汽车类：宝马、奥迪、大众 （属性：品牌，价格），在测试类中根据客户要求购买的汽车品牌，
通过接口car为客户提供相应的汽车对象。
Description：通过java反射机制和Properties类的结合使用，实现工厂模式。代码如下：
1、首先是entity包中的一个接口和三个实体类
汽车接口：
1 /*
2 *Description:定义汽车接口
3 * */
4
5
6 package entity;
7
8 public interface Car {
9
10 public void printInfo(); //打印汽车信息
11 }
三个实体类：
1 /*
2 * Description:定义奥迪类，并实现接口
3 *
4 * */
5
6 package entity;
7
8 public class AoDi implements Car{
9
10 private String brand = "奥迪"; //品牌
11 private double price = 10000000; //价格
12
13
14 public AoDi(){}
15
16 public AoDi(String brand,double price) {
17
18 this.brand = brand;
19 this.price = price;
20 }
21
22 public String getBrand() {
23 return brand;
24 }
25
26 public void setBrand(String brand) {
27 this.brand = brand;
28 }
29
30 public double getPrice() {
31 return price;
32 }
33
34 public void setPrice(double price) {
35 this.price = price;
36 }
37
38 @Override
39 public String toString() {
40 return "AoDi [brand=" + brand + ", price=" + price + "]";
41 }
42
43 public void printInfo() { //实现接口方法
44
45 System.out.println( "我是奥迪:" );
46 System.out.println( this.toString() );
47 }
48
49
50 }
1 /*
2 * Description:定义宝马类，实现接口
3 *
4 * */
5
6 package entity;
7
8 public class BaoMa implements Car{
9
10 private String brand = "宝马"; //品牌
11 private double price = 1000000; //价格
12
13 public BaoMa(){}
14
15 public BaoMa(String brand,double price) {
16
17 this.brand = brand;
18 this.price = price;
19 }
20
21 public String getBrand() {
22 return brand;
23 }
24
25 public void setBrand(String brand) {
26 this.brand = brand;
27 }
28
29 public double getPrice() {
30 return price;
31 }
32
33 public void setPrice(double price) {
34 this.price = price;
35 }
36
37 @Override
38 public String toString() {
39 return "Baoma [brand=" + brand + ", price=" + price + "]";
40 }
41
42 public void printInfo() { //实现接口方法
43
44 System.out.println( "我是宝马:" );
45 System.out.println( this.toString() );
46 }
47
48
49 }
1 /*
2 * Description:定义大众类，并实现接口
3 *
4 * */
5
6
7 package entity;
8
9 public class DaZhong implements Car{
10
11 private String brand = "大众"; //品牌
12 private double price = 100000; //价格
13
14
15 public DaZhong(){}
16
17 public DaZhong(String brand,double price) {
18
19 this.brand = brand;
20 this.price = price;
21 }
22
23 public String getBrand() {
24 return brand;
25 }
26
27 public void setBrand(String brand) {
28 this.brand = brand;
29 }
30
31 public double getPrice() {
32 return price;
33 }
34
35 public void setPrice(double price) {
36 this.price = price;
37 }
38
39 @Override
40 public String toString() {
41 return "DaZhong [brand=" + brand + ", price=" + price + "]";
42 }
43
44 public void printInfo() { //实现接口方法
45
46 System.out.println( "我是大众:" );
47 System.out.println( this.toString() );
48 }
49
50
51 }
2、以下是工具包tools中的类
初始化Properties类型文件
1 /*
2 * Description:该类完成属性文件的初始化
3 *
4 *
5 * */
6
7 package tools;
8 import java.io.File;
9 import java.io.FileInputStream;
10 import java.io.FileOutputStream;
11 import java.util.Properties;
12
13 public class Init {
14
15 public static Properties getProperty() {
16
17 Properties pro = new Properties(); //声明对象
18
19 //实例化File类对象
20 File file = new File( "D:" + File.separator + "init.properties" );
21
22 try {
23 if( file.exists() ) { //属性文件存在
24 pro.load( new FileInputStream(file) ); //加载文件
25 }else {
26
27 //文件不存在，编辑文件内容
28 pro.setProperty("大众","entity.DaZhong" );
29 pro.setProperty("宝马", "entity.BaoMa");
30 pro.setProperty("奥迪", "entity.AoDi");
31
32 //进行存储
33 pro.store(new FileOutputStream(file), "The information of the car");
34 }
35 }catch(Exception e) {
36
37 e.printStackTrace();
38 }
39
40 return pro;
41 }
42
43 }
定义工厂类
1 /*
2 * Description:定义工厂类，通过工厂模式，和反射机制的应用，取得实例化对象，并实例化接口对象，返回接口类型
3 *
4 *
5 * */
6
7
8 package tools;
9
10 import entity.Car;
11
12 public class Factory {
13
14 public static Car getInstance(String carName) { //此处传递过来的参数是 包.类名
15
16 Car car = null;
17
18 try {
19 car = (Car)Class.forName(carName).newInstance(); //实例化对象
20
21 }catch(Exception e) {
22
23 e.printStackTrace();
24 }
25 return car;
26 }
27 }
定义操作类，接收用户输入
1 /*
2 * Description:定义Operator类，取得用户的输入值
3 *
4 * */
5
6 package tools;
7 import java.util.Scanner;
8
9 public class Operate {
10
11 public static String getInput() {
12
13 Scanner scan = new Scanner(System.in);
14 String carName = "";
15 System.out.println( "用户输入车的名称：" );
16 carName = scan.next();
17 return carName; //返回用户的输入值
18 }
19
20 }
main方法，测试整个工程
1 /*
2 * Description:类的接口的运用
3 *
4 * Written By:Cai
5 *
6 * Date Writen:2017-09-25
7 *
8 *
9 * */
10 /*
11 * Description:java反射机制，属性文件，实现工厂模式
12 *
13 * Written By:Cai
14 *
15 * Date Written:2017-09-24
16 *
17 *
18 * */
19
20
21 package main;
22
23 import java.util.Properties; //引入属性文件
24 import tools.Factory; //引入自定义的类
25 import tools.Operate;
26 import entity.Car;
27 import tools.Init;
28
29 public class DemoThree4 {
30
31 public static void main(String args[]) {
32
33 Car car = null;
34 String carName = Operate.getInput(); //取得用户的输入内容（此处没有加数据的合法验证）
35 Properties pro = Init.getProperty(); //数理化Properties对象
36
37 car = Factory.getInstance( pro.getProperty(carName) ); //通过属性文件取得实例化对象，并实例化Car对象
38 car.printInfo(); //调用被实例对象覆写的方法
39
40 }
41 }
备注：起步小白，请多指教！