java工厂模式概念（什么是Java的工厂模式）

本文目录

• 什么是Java的工厂模式
• Java的工厂模式有哪一些，分别有什么作用，一般用在哪些地方
• java中的工厂模式是什么意思
• java中的工厂模式是什么，请举例说明
• java什么是工厂设计模式
• java简单工厂模式是什么
• java 工厂模式 单例模式
• Java程序设计中工厂设计模式思想是怎样的
• java中 什么是工厂
• Java中常用的设计模式有哪些请详细说明一下工厂模式

什么是Java的工厂模式

factory模式不需要建立什么包，完全得靠你对factory模式的理解，工厂模式基本上应该是体现了一个多态的概念，用户只关心结果，而不需要关心其具体过程...
工厂模式有三个参与者，抽象产品(Product)、工厂(Creator)和具体产品(ConcreteProduct)。客户只会看到工厂和抽象产品。
public interface Product{
public String getName();
}
public class ConcreteProduct implements Product{
public String getName(){
return "产品1";
}
}
public class Creator{
public static Product create1(){
return new ConcreteProduct();
}
}
工厂模式的作用在于将创建具体产品的方法由工厂类控制，客户只需要知道产品的抽象类型

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

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

java中的工厂模式是什么意思

工厂模式简单的讲就是用工厂方法代替了new的操作，
在通俗点就是说，你new一个对象的时候直接调用工厂方法就行了，
在编程时，需要定义一个工厂接口，由不同的的子类去实现，再定一个具体工厂类，定义一个产生实例的方法，我们通过这个方法来获得实例就行了，

java中的工厂模式是什么，请举例说明

工厂模式就是在接口和子类之间加入了一个过渡端，通过此过渡端获得接口的实例化对象，这个过渡端也就是所谓的工厂类。这样以后如果再有程序子类要扩充，直接修改工厂类客户端就可以根据标记得到相应的实例，增加了程序的灵活性。eg:
interface Fruit{
public void eat() ;
}
class Apple implements Fruit{
public void eat(){
System.out.println("** $$$$$") ;
}
};
class Orange implements Fruit{
public void eat(){
System.out.println("** #####。") ;
}
};
class Factory{// 定义工厂类
public static Fruit getInstance(String className){
Fruit f = null ;
if("apple".equals(className)){// 判断
f = new Apple() ;
}
if("orange".equals(className)){// 判断
f = new Orange() ;
}
return f ;
}
};
public class InterfaceCaseDemo{
public static void main(String args){
Fruit f = Factory.getInstance(null) ;// 实例化接口
f.eat() ;
}
};

java什么是工厂设计模式

把创建对象的工作，交给一个抽象出来的概念’工厂’去做，就是工厂设计模式。比如,你要新建一个用户对象 User user=new User();这很简单，也好理解。但是如果你用工厂设计模式去做，就算最简单的实现你也得加个类型，如：UserFactory，而里面的代码可能只是：
public static User getUser(){
return new User();
}
在使用的时候就是变成：User user = UserFactory.getUser();
嗯，看起来是多此一举，没错，我这场景就是多此一举。工厂模式适用场景，首先得有较复杂的子父类结构，再者创建逻辑可能很复杂，这样才有意义，才有必要去使用工厂模式。又或者这个傻逼对象创建起来很消耗性能，且不是非得是全新的才能用，那么可以配合单例模式一起使用，实现对象的复用，达到性能优化的目的。
嗯，你可能又会疑惑，啥是单例，给你个很傻的描述：有个神奇的类，他有个神奇的方法，这个方法会帮你创建一个对象，且不管调用几次，怎么调用，他都保证只给你一个，且百分百是同一个。

java简单工厂模式是什么

简单工厂模式的：简单工厂模式是类的创建模式，又叫做静态工厂方法（Static Factory Method）模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
那么简单工厂模式是在什么场景下使用呢，下面就以本人的理解举例说明:
　　就拿登录功能来说，假如应用系统需要支持多种登录方式如：口令认证、域认证（口令认证通常是去数据库中验证用户，而域认证则是需要到微软的域中验证用户）。那么自然的做法就是建立一个各种登录方式都适用的接口，如下图所示：
public interface Login {
//登录验证
public boolean verify(String name , String password);
}
public class DomainLogin implements Login {
@Override
public boolean verify(String name, String password) {
// TODO Auto-generated method stub
/**
* 业务逻辑
*/
return true;
}
}
public class PasswordLogin implements Login {
@Override
public boolean verify(String name, String password) {
// TODO Auto-generated method stub
/**
* 业务逻辑
*/
return true;
}
}
我们还需要一个工厂类LoginManager，根据调用者不同的要求，创建出不同的登录对象并返回。而如果碰到不合法的要求，会返回一个Runtime异常。
public class LoginManager {
public static Login factory(String type){
if(type.equals("password")){

return new PasswordLogin();

}else if(type.equals("passcode")){

return new DomainLogin();

}else{
/**
* 这里抛出一个自定义异常会更恰当
*/
throw new RuntimeException("没有找到登录类型");
}
}
}
测试类：
public class Test {
public static void main(String args) {
// TODO Auto-generated method stub
String loginType = "password";
String name = "name";
String password = "password";
Login login = LoginManager.factory(loginType);
boolean bool = login.verify(name, password);
if (bool) {
/**
* 业务逻辑
*/
} else {
/**
* 业务逻辑
*/
}
}
}
简单工厂模式的结构如下图：
我们可以设想一下真实的场景，如果把上面的Test当做一个servlet的话，当客户端发起登录请求——》请求交给服务端的Servlet——》Servlet根据客户端传递的loginType调用工厂类LoginManager的factory()方法——》factory()方法根据参数loginType创建相应的登录验证类(DomainLogin或PasswordLogin)并返回——》登录验证类调用方法verify()验证用户名密码是否正确
假如不使用简单工厂模式则验证登录Servlet代码如下（假设Test为一个Servlet，变量loginType、name、password表示从客户端传递过来的参数）：
public class Test {
public static void main(String args) {
// TODO Auto-generated method stub

String loginType = "password";
String name = "name";
String password = "password";
//处理口令认证
if(loginType.equals("password")){
PasswordLogin passwordLogin = new PasswordLogin();
boolean bool = passwordLogin.verify(name, password);
if (bool) {
/**
* 业务逻辑
*/
} else {
/**
* 业务逻辑
*/
}
}
//处理域认证
else if(loginType.equals("passcode")){
DomainLogin domainLogin = new DomainLogin();
boolean bool = domainLogin.verify(name, password);
if (bool) {
/**
* 业务逻辑
*/
} else {
/**
* 业务逻辑
*/
}
}else{
/**
* 业务逻辑
*/
}
}
}
上面的代码会不会很蛋疼啊。。。呵呵
《JAVA与模式》一书中使用java.text.DataFormat类作为简单工厂模式的典型例子叙述。
简单工厂模式的优点
　　模式的核心是工厂类。这个类含有必要的逻辑判断，可以决定在什么时候创建哪一个登录验证类的实例，而调用者则可以免除直接创建对象的责任。简单工厂模式通过这种做法实现了对责任的分割，当系统引入新的登录方式的时候无需修改调用者。
简单工厂模式的缺点
　　这个工厂类集中了所以的创建逻辑，当有复杂的多层次等级结构时，所有的业务逻辑都在这个工厂类中实现。什么时候它不能工作了，整个系统都会受到影响。

java 工厂模式 单例模式

介绍本书给你《Head First.设计模式》
工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。
工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。
下面举例说明:
工厂:如果你想建一个Vehicle类,而Vehicle包括Car,Truck,Microbus,Bus等车型.这时你把这些车型共有的属性与动作都写在了Vehicle类里,比如属性wheel,比如动作run(),但是每种车的run可以说是不一样的,所以在Vehicle只是一个抽象方法,具体在子类里实现.这里可以把Vehicle看成一个造车工厂,工厂一般是抽象类或者就是接口.以下随便举个例子.
public interface A
{
void a();
void b();
void c();
}
public class B extends A
{
// 实现一系列方法
}
// 比如还有几个类......
public class AFactory
{
public static A factory(String name)
{
if(name == "b")
return new B();
..........................
}
}
单例:单例还是用代码来说明吧.
class Test{
private Test(){}//构造方法私有,这是单例所必须的.
private static Test test;//一个静态的Test对象
public static Test getInstance(){//这个静态方法是创建实例的方法,只有通过这个方法才能创建实例
if(test==null)
test = new Test();
return test;
}
}

Java程序设计中工厂设计模式思想是怎样的

工厂模式主要用一下几种形态：
1：简单工厂（Simple Factory）。
2：工厂方法（Factory Method）。
3：抽象工厂（Abstract Factory）。
　　简单工厂并不简单，它是整个模式的核心，一旦他出了问题，整个模式都将受影响而不能工作，为了降低风险和为日后的维护、扩展做准备，我们需要对它进行重构，引入工厂方法。工厂方法为工厂类定义了接口，用多态来削弱了工厂类的职能。
　　工厂方法和简单工厂的主要区别是，简单工厂是把创建产品的职能都放在一个类里面，而工厂方法则把不同的产品放在实现了工厂接口的不同工厂类里面，这样就算其中一个工厂类出了问题，其他工厂类也能正常工作，互相不受影响，以后增加新产品，也只需要新增一个实现工厂接口工厂类，就能达到，不用修改已有的代码。但工厂方法也有他局限的地方，那就是当面对的产品有复杂的等级结构的时候
　　抽象工厂的意图在于创建一系列互相关联或互相依赖的对象。

java中 什么是工厂

工厂是一种设计模式！
为何使用?
工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。
为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。
我们以类Sample为例， 如果我们要创建Sample的实例对象:
Sample sample=new Sample();
可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。
首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成:
Sample sample=new Sample(参数);
但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refactor重整）。
为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有背于Java 面向对象的原则，面向对象的封装(Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再 “封装”起来(减少段和段之间偶合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。
在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。
这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个接口.现在Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:
Sample mysample=new MySample();
Sample hissample=new HisSample();
随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的.
但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.
工厂方法
你会建立一个专门生产Sample实例的工厂:
public class Factory{
public static Sample creator(int which){
//getClass 产生Sample 一般可使用动态类装载装入类。
if (which==1)
return new SampleA();
else if (which==2)
return new SampleB();
}
}
那么在你的程序中,如果要实例化Sample时.就使用
Sample sampleA=Factory.creator(1);
这样,在整个就不涉及到 Sample的具体子类,达到封装效果,也就减少错误修改的机会,这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误.这每个做过具体工作的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,范错误可能性就越少.好象我们从编程序中也能悟出人生道理?呵呵.
使用工厂方法 要注意几个角色，首先你要定义产品接口，如上面的Sample,产品接口下有Sample接口的实现类,如SampleA,其次要有一个factory类，用来生成产品Sample，如下图，最右边是生产的对象Sample：
进一步稍微复杂一点，就是在工厂类上进行拓展，工厂类也有继承它的实现类concreteFactory了。
抽象工厂
工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory).
这两个模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2.
这里假设：Sample有两个concrete类SampleA和SamleB，而Sample2也有两个concrete类Sample2A和SampleB2
那么，我们就将上例中Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){
.........
return new SampleA
}
public Sample2 creator(String name){
.........
return new Sample2A
}
}
public class BombFactory extends Factory{
public Sample creator(){
......
return new SampleB
}
public Sample2 creator(String name){
......
return new Sample2B
}
}
从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产Sample和Sample2?
抽象工厂还有另外一个关键要点，是因为 SimpleFactory内，生产Sample和生产Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称叫SimpleFactory。
在实际应用中，工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用。

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.策略模式
这个模式是将行为的抽象，即当有几个类有相似的方法，将其中通用的部分都提取出来，从而使扩展更容易。