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 }

备注:起步小白,请多指教!

Java实验项目三——简单工厂模式的更多相关文章

  1. Java设计模式学习记录-简单工厂模式、工厂方法模式

    前言 之前介绍了设计模式的原则和分类等概述.今天开启设计模式的学习,首先要介绍的就是工厂模式,在介绍工厂模式前会先介绍一下简单工厂模式,这样由浅入深来介绍. 简单工厂模式 做法:创建一个工厂(方法或类 ...

  2. Java设计模式2:简单工厂模式

    简单工厂模式 简单工厂模式是类的创建模式,又叫做静态工厂方法模式.简单工厂模式由一个工厂对象决定生产出哪一种产品类的实例. 为什么要使用简单工厂模式 原因很简单:解耦. A对象如果要调用B对象,最简单 ...

  3. (转)java反射机制及简单工厂模式

    第一步,定义一个接口类 package factory.face; /** * 接口,为了保证返回的对象可以统一用 Product接受 * @author Administrator */ publi ...

  4. JAVA基础——设计模式之简单工厂模式

    在阎宏博士的<JAVA与模式>一书中开头是这样描述简单工厂模式的:简单工厂模式是类的创建模式,又叫做静态工厂方法(Static Factory Method)模式.简单工厂模式是由一个工厂 ...

  5. java设计模式-----1、简单工厂模式

    简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例,简单来说 ...

  6. Java实验项目三——职工类对象数组按照职工生日排序

    Program: 修改项目三(1)中的第3题,实现比较方法,将对象数组的数据按照生日的大小给职工排序. Description:令日期类MyDate和员工类Worker类实现接口Comparable, ...

  7. Java实验项目六——使用DAO模式实现对职工表的操作

    Program: 利用JDBC访问职工信息表,实现对职工信息的添加.更新.删除.按照职工号查找.查找全部职工的功能. Description:在这里我采用了DAO设计模式完成对职工表的操作,下面介绍一 ...

  8. Java实验项目三——编程实现Person类,学生类的设计及其继承关系

    Program: 编程实现Person类,学生类的设计及其继承关系 代码如下: 定义抽象类Person 1 /* 2 * Description:建立抽象类 3 * 4 * Written By:Ca ...

  9. JAVA设计模式之【简单工厂模式】

    1.创建抽象类User public abstract class User // 抽象类 { public void sameOperation() { System.out.println(&qu ...

随机推荐

  1. HTML的一些标签以及表单

    HTML的一些标签以及表单 图片标签 属性 说明 src 图像的路径 alt 图像不能显示时的替换文字 title 鼠标悬停时显示的内容 border 设置图像边框的宽度 align 对齐方式 相对路 ...

  2. 对标 Spring Boot & Cloud ,轻量框架 Solon 1.4.8 发布

    Solon 是一个轻量的Java基础开发框架.强调,克制 + 简洁 + 开放的原则:力求,更小.更快.更自由的体验.支持:RPC.REST API.MVC.Job.Micro service.WebS ...

  3. volatile 关键字笔记

    你应该知道的 volatile 关键字 当一个变量被 volatile 修饰时,任何线程对它的写操作都会立即刷新到主内存中,并且会强制让缓存了该变量的线程中的数据清空,必须从主内存重新读取最新数据. ...

  4. jquery 改变标签样式

    jQuery改变标签的样式一般有3种 预置好class,然后通过jQuery改变元素的class名,使用的是addClass.removeClass 直接改变元素的css属性值,这种是通过添加styl ...

  5. TensorRT IRNNv2Layer

    TensorRT IRNNv2Layer IRNNv2Layer层实现递归层,如递归神经网络(RNN).门控递归单元(GRU)和长短期记忆(LSTM).支持的类型有RNN.GRU和LSTM.它执行一个 ...

  6. ASIC设计-终极指南

    ASIC设计-终极指南 ASIC Design – The Ultimate Guide ASIC设计-终极指南 ASICs代表特定于应用的集成电路,指的是针对特定应用而设计的半导体解决方案,与其他解 ...

  7. FreeSql使用WithSql+ ToSQL 查询数据

    FreeSql是一个支持.NET Core 2.1+..NET Framework 4.0+ 以及 Xamarin的ORM(Object Relational Mapping)对象关系映射的组件 支持 ...

  8. java后端知识点梳理——java基础

    面向对象 java三大特性 封装: 将事务封装成一个类,达到解耦,隐藏细节的效果.通过get/set等方法,封装了内部逻辑,并保留了特定的接口与外界联系. 继承: 从一个已知的类中派生出一个新的类,新 ...

  9. jd一面面经

    1.讲一下hashmap原理. 2.concurrentHashMap的原理.concurrentHashMap和hashmap有什么不同? 3.synchnized底层实现?讲讲AQS 4.sync ...

  10. 【NX二次开发】拉伸的偏置方向猜想与验证

    结论:偏置的方向为曲线方向与拉伸方向的向量叉乘. 在UF_MODL_create_extrusion帮助中有这么一句话:Note that the offset direction is determ ...