本文目录一览:
java工厂模式,懂的人进
举两个例子以快速明白Java中的简单工厂模式:
女娲抟土造人
话说:“天地开辟,未有人民,女娲抟土为人。”女娲需要用土造出一个个的人,但在女娲造出人之前,人的概念只存在于女娲的思想里面。
女娲造人,这就是简单工厂模式的应用。
首先,在这个造人的思想里面,有几个重要的角色:女娲本身、抽象的人的概念和女娲所造出的一个个具体的人。
1.)女娲是一个工厂类,也就是简单工厂模式的核心角色。
2.)具休的一个个的人,包括张三,李四等。这些人便是简单工厂模式里面的具体产品角色
3.)抽象的人是最早只存在于女娲的头脑里的一个想法,女娲按照这个想法造出的一个个具体的人,便都符合这个抽象的人的定义。换言之,这个抽象的想法规定了所有具体的人必须都有的接口(特征或者功能)
其UML类图出下所示:
理解了上面的这些东西,再来理解下面的例子,对照理解,相信看完这篇文章,便对java简单工厂模式有一个很好的理解:
有一个农场公司,专门向市场销售各类水果,在这个系统里需要描述下列水果:
葡萄 Grape
草莓 Stuawberry
苹果 Apple
水果与其他植物不同,最终可以采摘食用,那么一个自然的做法是建立一个各种水果都适用的接口,以便与其他农场里的植物区分开来,
此时,则是为水果类声明了一个接口,表现在代码上:
1 public interface Fruit {
2 // 生长
3 void grow();
4 // 收获
5 void harvest();
6 // 种植
7 void plant();
8 }
9
10
水果接口规定出所有的水果必须实现的接口,包括任何水果类必须具备的方法plant(),grow(),和harvest();
Apple类是水果类的一种,因此它实现了水果接口所声明的所有方法。另处,由于苹果是多年生植物,因此多出一个treeAge性质,描述苹果的树龄。代码如下所示:
package fac;
public class Apple implements Fruit { // 通过implements实现接口Fruit
private int treeAge;
public void grow() {
log( " Apple is growing " );
}
public void harvest() {
log( " Apple has been harvested " );
}
public void plant() {
log( " Apple ha been planted " );
}
public static void log(String msg) {
System.out.println(msg);
}
public int getTreeAge() {
return treeAge;
}
public void setTreeAge( int treeAge) {
this .treeAge = treeAge;
}
}
同理,葡萄 Grape:
package fac;
public class Grape implements Fruit{
private boolean seedless;
public void grow(){
log("Grape is growing.");
}
public void harvest(){
log("Grape has been harvested");
}
public void plant(){
log("Grape ha been planted");
}
public static void log(String msg){
System.out.println(msg);
}
public boolean isSeedless() {
return seedless;
}
public void setSeedless(boolean seedless) {
this.seedless = seedless;
}
}
草莓 Stuawberry:
package fac;
public class Strawberry implements Fruit{
public void grow(){
log("Strawberry is growing");
}
public void harvest(){
log("Strawberry has been harvested");
}
public void plant(){
log("Strawberry has been planted");
}
public static void log(String msg){
System.out.println(msg);
}
}
农场园丁也是系统的一部分,由一个类来代表,FruitGardener类,代码如下:
package fac;
public class FruitGardener{
public static Fruit factory(String which)throws Exception{
if(which.equalsIgnoreCase("apple")){
return new Apple();
}else if(which.equalsIgnoreCase("strawberry")){
return new Strawberry();
}else if (which.equalsIgnoreCase("grape")){
return new Grape();
}else{
throw new Exception("Bad fruit request");
}
}
}
这时有人来果园玩,和园丁说,给我们介绍下你的水果吧。于是园丁:
package fac;
public class People {
public static void main(String[] args) throws Exception {
FruitGardener fg=new FruitGardener();
Fruit ap=fg.factory("Apple");
ap.grow();
Fruit gp=fg.factory("Grape");
gp.plant();
Fruit dd=fg.factory("ddd");//抛出Bad fruit request异常
}
}
(注:以上代码在JDK5.0,Myeclise3.2下编译通过)
类比两个例子,园丁就相当于女娲,而水果就相当于具体的人,接口水果类就相当于存在于类女娲思想里的人的抽象概念。
由以上两个例子可得出,简单工厂模式需要由以下角色组成:
接口
接口的实现类(简单工厂模式里面的具体产品角色)
工厂
理解了以下两个例子,再来看第三个例子:
注意对比以下三个实例的不同
实例1:
package org.jzkangta.factorydemo01;
//定义接口
interface Car{
public void run();
public void stop();
}
//具体实现类
class Benz implements Car{
public void run(){
System.out.println("Benz开始启动了。。。。。");
}
public void stop(){
System.out.println("Benz停车了。。。。。");
}
}
//具体实现类
class Ford implements Car{
public void run(){
System.out.println("Ford开始启动了。。。");
}
public void stop(){
System.out.println("Ford停车了。。。。");
}
}
//工厂
class Factory{
public static Car getCarInstance(){
return new Ford();
}
}
public class FactoryDemo01 {
public static void main(String[] args) {
Car c=Factory.getCarInstance();
c.run();
c.stop();
}
}
实例二:
package fac;
//定义接口
interface Car{
public void run();
public void stop();
}
//具体实现类
class Benz implements Car{
public void run(){
System.out.println("Benz开始启动了。。。。。");
}
public void stop(){
System.out.println("Benz停车了。。。。。");
}
}
class Ford implements Car{
public void run(){
System.out.println("Ford开始启动了。。。");
}
public void stop(){
System.out.println("Ford停车了。。。。");
}
}
//工厂
class Factory{
public static Car getCarInstance(String type){
Car c=null;
if("Benz".equals(type)){
c=new Benz();
}
if("Ford".equals(type)){
c=new Ford();
}
return c;
}
}
public class FactoryDemo02 {
public static void main(String[] args) {
Car c=Factory.getCarInstance("Benz");
if(c!=null){
c.run();
c.stop();
}else{
System.out.println("造不了这种汽车。。。");
}
}
}
实例三:
interface Car{
public void run();
public void stop();
}
class Benz implements Car{
public void run(){
System.out.println("Benz开始启动了。。。。。");
}
public void stop(){
System.out.println("Benz停车了。。。。。");
}
}
class Ford implements Car{
public void run(){
System.out.println("Ford开始启动了。。。");
}
public void stop(){
System.out.println("Ford停车了。。。。");
}
}
class Toyota implements Car{
public void run(){
System.out.println("Toyota开始启动了。。。");
}
public void stop(){
System.out.println("Toyota停车了。。。。");
}
}
class Factory{
public static Car getCarInstance(String type){
Car c=null;
try {
c=(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();//利用反射得到汽车类型
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return c;
}
}
public class FactoryDemo03 {
public static void main(String[] args) {
Car c=Factory.getCarInstance("Toyota");
if(c!=null){
c.run();
c.stop();
}else{
System.out.println("造不了这种汽车。。。");
}
}
}
对比三个实例:
实例一,虽然实现了简单工厂,但每次只能得到一种汽车,如果我们想换一种,就得修改工厂,太不方便,而实例二则改变了这种情况,便得我们可以按照我们的需要更换汽车,但我们所更换的汽车必须是实现类中有的,如果我们想要增加一种汽车的时候,我们还是得更改工厂,通过改进,实例三利用反射机制,得到汽车类型,这样当我们需要增加一种新的汽车时,就无需要再修改工厂,而只需要增加要实现的类即可。也就是说要增加什么样的汽车直接增加这个汽车的类即可,而无需改变工厂。从而达到了工厂分离的效果。
java工厂类怎么实现
工厂方法模式分为三种:
1、普通工厂模式,就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建
2、多个工厂方法模式,是对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象。
3、静态工厂方法模式,将上面的多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可。
具体代码请参考:java设计模式 第三大节
如果对您有帮助,请及时采纳谢谢
用java 编写程序写出简单的工厂模式?
java中工厂模式分为:
简单工厂模式(Simple Factory)
2. 工厂方法模式(Factory Method)
3. 抽象工厂模式(Abstract Factory)
每种方法的实现不同
提供一个简单工厂模式的案例:
public abstract class Woman {
private String mySkill;
public String getMySkill() {
return mySkill;
}
public Woman() {
//System.out.println("我是女人");
}
public void setMySkill(String mySkill) {
this.mySkill = mySkill;
}
}
----------------------------
public class LovelinessWoman extends Woman{
/*
* 可爱型女人
*/
public LovelinessWoman()
{
String mySkill="撒过娇、出过轨、勾引领导下过水";
this.setMySkill(mySkill);
}
}
-----------------------------
public class SteelinessWoman extends Woman{
/*
* 冷酷型女人
*/
public SteelinessWoman()
{
String mySkill="装过神、弄过鬼,跟别人老公亲过嘴";
this.setMySkill(mySkill);
}
}
--------------------------------------
public class WomanMakeFactory {
public Woman findWoman(int typeID) {
switch (typeID) {
case 1:
return new LovelinessWoman();
case 2:
return new VirtuousWoman();
case 3:
return new SteelinessWoman();
default:
return null;
}
}
public Woman findWoman(String type) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
/*
* Type t = Type.GetType("SimpleFactory." + type);
* Woman wm =
* (Woman)Activator.CreateInstance(t); return wm;
*/
String string="cn.jbit.design.simplefactory."+type;
Class c = Class.forName(string);
Woman wm = (Woman) c.newInstance();
return wm;
}
}
-------------------------
调用
public class Test2 {
/**
* @param args
* @throws IllegalAccessException
* @throws InstantiationException
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Scanner input=new Scanner(System.in);
boolean sel=false;
do {
System.out.println("请选择你要找的女人的类型");
System.out.println("LovelinessWoman:可爱型女人 VirtuousWoman:善良型女人 SteelinessWoman:冷酷型女人");
String typeid=input.next();
WomanMakeFactory factory = new WomanMakeFactory();
Woman wm=factory.findWoman(typeid);
System.out.println("该类型女人的新标准:");
System.out.println(wm.getMySkill());
System.out.println("还想看看别的类型吗?y代表想,n代表再也不想了");
sel=input.next().equals("y");
} while (sel);
}
}
java中的factory是啥意思,怎么用能达到那种效果
factory应该说的是java的工厂设计模式,在创建这个类的实例时,不手动new出来,而是交给工厂类来创建,在java开发中很多地方都用到了这种设计模式。要达到这种效果很简单啊,在工厂类中写一个方法,让这个方法返回该类或该类子类的实例即可。
Java的几个工厂方法解析
Java工厂模式可分为三种:
1.静态工厂模式
2.工厂方法模式
3.抽象工厂模式
一、静态工厂模式:用静态的方法实现,其创建的对象具有一定的特性
举例如下:
Vehicle类:
public abstract class Vehicle
{
private String name;
public Vehicle (){
super();
}
public Vehicle (String name){
super();
this.name=name;
}
public abstract void run();
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
}
Bus类:
public class Bus extends Vehicle
{
private String name;
public Bus(){}
public Bus(String name){
super(name);
}
@Override
public abstract void run(){
System.out.println("Bus is running");
}
}
Car类:
public class Car extends Vehicle
{
private String name;
public Car(){}
public Car(String name){
super(name);
}
@Override
public abstract void run(){
System.out.println("Car is running");
}
}
静态工厂类:
(静态工厂创建一个对象,
静态工厂创建的对象一般都有一个共同的特性,
继承自某一个类,
或者引用一个接口)
public class StaticFactory{
public static Object getInstance(String className){
Object instance=null;
try{
Class c=Class.forName(className);
instance=c.newInstance();
}catch(Exception e){}
return instance;
}
public static Object getInstance(String className,Object ...args){
Class c=null;
try{
c=Class.forName(className);
}catch(Exception e){}
Constructor[] cons=c.getConstructors();
Object instance=null;
for(Constructor con:cons){
Class?[] cs=con.getParmeterTypes();
if(cs.length0){
boolean isConstructor=true;
for(int i=0;ics.length;i++){
Class t=cs[i];
if(!t.isInstance(args[i])){
isConstructor=false;
}
}
if(isConstructor){
try{
instance=con.newInstance(args);
break;
}catch(Exception e){}
}else{
continue;
}
}
}
return instance;
}
}
二、工厂方法模式:主要是对各类东西分类生产,但分类生产的对象仍然具有某一特性。
如果说静态工厂是一个综合的交通工具建造工厂,
那么工厂方法模式就是具体分工,分成Bus与Car的工厂,
各自生产各自的产品,但是造出来的还是交通工具。
交通工具制造接口:
public interface VehicleMake{
/**制造交通工具**/
public Vehicle make();
}
Bus制造类:
public class BusMake implements VehicleMake{
@Override
public Vehicle make(){
Vehicle bus=new Bus();
System.out.println("Bus工厂制造了一辆Bus");
return bus;
}
}
Car制造类:
public class CarMake implements VehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car();
System.out.println("Car工厂制造了一辆Car");
return car;
}
}
三、抽象工厂模式:抽象工厂生产的对象可能是没有共同特性的。比如,一个制造工厂BusMake不仅能制造Bus还能生产轮胎wheel等配件,Bus是交通工具,wheel是配件(代码中有部分类没具体写出来只给了类名)
总工厂(抽象工厂总接口):
public interface WheelVehicleMake extends VehicleMake{
/**制造轮胎**/
public Wheel makeWheel();
}
轮子BusMake:
public class WheelBusMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle bus=new Bus();
System.out.println("WheelBusMake生产了一辆Bus");
return bus;
}
@Override
public Wheel makeWheel(){
Wheel busWheel=new BusWheel();
System.out.println("WheelBusMake生产了一个Bus轮子");
return busWheel;
}
}
轮子CarMake:
public class WheelCarMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car();
System.out.println("WheelCarMake生产了一辆Car");
return car;
}
@Override
public Wheel makeWheel(){
Wheel carWheel=new CarWheel();
System.out.println("WheelCarMake生产了一个Car轮子");
return carWheel;
}
}