java工厂模式实例

① java中常用的设计模式有哪些请详细说明一下工厂模式。

1.单例模式（有的书上说叫单态模式其实都一样）
该模式主要目的是使内存中保持1个对象
2.工厂模式
该模式主要功能是统一提供实例对象的引用。看下面的例子：
public class Factory{
public ClassesDao getClassesDao(){
ClassesDao cd = new ClassesDaoImpl();
return cd;
}
}
interface ClassesDao{
public String getClassesName();
}
class ClassesDaoImpl implements ClassesDao {
public String getClassesName(){
System.out.println("A班");
}
}
class test
{
public static void main(String[] args){
Factory f = new Factory();
f.getClassesDao().getClassesName();
}
}
这个是最简单的例子了，就是通过工厂方法通过接口获取对象的引用
3.建造模式
该模式其实就是说，一个对象的组成可能有很多其他的对象一起组成的，比如说，一个对象的实现非常复杂，有很多的属性，而这些属性又是其他对象的引用，可能这些对象的引用又包括很多的对象引用。封装这些复杂性，就可以使用建造模式。
4.门面模式
这个模式个人感觉像是Service层的一个翻版。比如Dao我们定义了很多持久化方法，我们通过Service层将Dao的原子方法组成业务逻辑，再通过方法向上层提供服务。门面模式道理其实是一样的。
5.策略模式
这个模式是将行为的抽象，即当有几个类有相似的方法，将其中通用的部分都提取出来，从而使扩展更容易。

② Java的工厂模式有哪一些，分别有什么作用，一般用在哪些地方

我简单的说下，举个例子，当我们的程序结构比较繁杂时，比如有100个类，而类中又有很多方法，这些方法之间都互相有依赖关系，也就是一个方法之间的某段逻辑处理需要用到另一个类中的代码逻辑，这种时候对于整个程序而言是非常不利于开发的（我们需要考虑到很多类、方法之间的耦合问题），那么就有一个概念了，也就是面对接口编程。通俗的说就是把类中的方法封装起来，外部调用的人完全不需要考虑方法是如何实现的，但是这样做也有一个不好的地方，我们的接口是不提供方法实现的，而需要在类中实现接口的方法。那么问题产生了，我们在new接口对象的时候需要明确的知道他的实例类。
想象一下，如果程序在继续庞大，接口非常多，接口实例类非常多，这样又会产生我们之前的问题（我们需要考虑到很多类、方法之间的耦合问题）那么这个时候就产生了一中设计思想，也就是工厂模式，这种模式的核心思想就是管理接口的实例对象，把接口和实例对象之间的关系封装起来处理，外部需要用到某个接口的实例时，由工厂进行分配，而不需要关注具体是哪个实例。
如果你做到比较复杂的程序时你应该就能体会到了。

③ java 工厂模式 单例模式

工厂模式分简单工厂、工厂方法、抽象工厂 三类。
很复杂。
看这本电子书： Java与模式(清晰书签版).pdf
下载不到的话加QQ：844576121
传给你

④ 用java 编写程序写出简单的工厂模式

java中工厂模式分为:

1. 简单工厂模式(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中的工厂模式是什么，请举例说明

工厂模式在Java程序系统可以说是随处可见。 为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。 说白了就是在一个类里写别的类 让外部好调用啊

⑥ java工厂模式例子

产品
public interface Work {

void doWork();
}
ConcreteProct
public class StudentWork implements Work {

public void doWork() {
System.out.println("学生做作业!");
}

}
public class TeacherWork implements Work {

public void doWork() {
System.out.println("老师审批作业!");
}

}
生产者
public interface IWorkFactory {

Work getWork();
}
ConcreteCreator
public class StudentWorkFactory implements IWorkFactory {

public Work getWork() {
return new StudentWork();
}

}
public class TeacherWorkFactory implements IWorkFactory {

public Work getWork() {
return new TeacherWork();
}

}
Test
public class Test {

public static void main(String[] args) {
IWorkFactory studentWorkFactory = new StudentWorkFactory();
studentWorkFactory.getWork().doWork();

IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
teacherWorkFactory.getWork().doWork();
}

}

⑦ 写一个抽象工厂模式 java实例 出来

1. 工厂模式java实例如下：
   

   public interface Work {
   
   void doWork();
   }
   ConcreteProct
   public class StudentWork implements Work {
   
   public void doWork() {
   System.out.println("学生做作业!");
   }
   
   }
   public class TeacherWork implements Work {
   
   public void doWork() {
   System.out.println("老师审批作业!");
   }
   
   }
   生产者
   public interface IWorkFactory {
   
   Work getWork();
   }
   ConcreteCreator
   public class StudentWorkFactory implements IWorkFactory {
   
   public Work getWork() {
   return new StudentWork();
   }
   
   }
   public class TeacherWorkFactory implements IWorkFactory {
   
   public Work getWork() {
   return new TeacherWork();
   }
   
   }
   Test
   public class Test {
   
   public static void main(String[] args) {
   IWorkFactory studentWorkFactory = new StudentWorkFactory();
   studentWorkFactory.getWork().doWork();
   
   IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
   teacherWorkFactory.getWork().doWork();
   }
   
   }

2. 字符串反转如下：

   public String getReverseStr(String str)

   {

   String reverseStr = "";

   if (null != str && !str.equals(""))

   {

   for (int i = 1 ; i < =str.length(); i++){

   reverseStr += str.charAt(str.length() - i);

   // 依次按与原字符串相反的顺序拼装字符串，内部会自动进行类型转换

   //str.length() - i刚好是str的下标，因为i是从1开始

   }
   

   }

   return reverseStr;

   }

3. 冒泡排序算法，从小到大

   public int[] sortArr(int[] targetArr){

   //小到大的排序
   int temp = 0;
   for(int i = 0;i<targetArr.length;i++){
   for(int j = i;j<targetArr.length;j++){
   if(targetArr[i]>targetArr[j]){
   temp = targetArr[i];
   targetArr[i] = targetArr[j];
   targetArr[j] = temp;
   }
   }
   }

   returntargetArr;

   }

⑧ 求java工厂模式的一个简单代码例子，尽量简单

这个应该比较简单一点。

某系统日志记录器要求支持多种日志记录方式，如文件记录、数据库记录等，且用户可以根据要求动态选择日志记录方式。现使用工厂方法模式设计该系统,并写出相应Java代码。

interface Log{

public void writeLog();

}

class FileLog implements Log{

public void writeLog(){

System.out.println("文件记录");

}

}

class DatabaseLog implements Log{

public void writeLog(){

System.out.println("数据库记录");

}

}

interface LogFactory{

public Log createLog();

}

class FileLogFactory implements LogFactory{

public Log createLog(){

return new FileLog();

}

}

class DatabaseLogFactory implements LogFactory{

public Log createLog(){

return new DatabaseLog();

}

}

public class Client{

public static void main(String[] args) {

try{

Log log;

LogFactory factory;

//这里可以改成使用DOM和Java反射机制读取XML文件，获取工厂类名

factory=new DatabaseLogFactory ();

log=factory.createLog();

log.writeLog();

}

catch(Exception e){

System.out.println(e.getMessage());

}

}

}

⑨ java简单工厂模式是什么

就是专门写一个类，他有一个方法根据传入的参数不同，返回不同的对象。
比如有一台自动售货机AutoSeller， 然后它卖很多饮料Drink, 有茶Tea， 有可乐Cola, 当你去买的时候，你可能是通过按不同的按钮，但对AutoSeller的实现来说，他可能都是同样的方法，只是根据不同的参数（按钮），返回给你不同的对象（Tea或Cola）。
public interface Drink {
enum Type {TEA, COLA};
}
public Tea implements Drink {
}
public Cola implements Drink {
}
public class AutoSeller {//工厂
public static Drink getDrink(Drink.Type type) {
switch(type) {
case TEA:
return new Tea();
case COLA:
return new Cola();
default:break;
}
}
}

如上， 在你选择饮料按下按钮里， 自动售货机的代码可能只要执行AutoSeller.getDrink(type)就可以返回你想要的饮料了。
之所以要把Drink定义成接口，一般来讲，用这种架构的话， Drink里面会声明一些接口方法， 这些方法是Tea和Cola都需要的， 但Drink不用关心方法的具体实现， 具体实现只要由Tea和Cola去完成。
而你通过AutoSeller.getDrink(type)去拿到一个Drink对象后，可以用这个对象直接去调Drink中声明的方法。