2024年10月java工厂模式例子（Java中常用的设计模式有哪些请详细说明一下工厂模式）
⑴java工厂模式例子（Java中常用的设计模式有哪些请详细说明一下工厂模式
⑵Java中常用的设计模式有哪些请详细说明一下工厂模式
⑶单例模式（有的书上说叫单态模式其实都一样该模式主要目的是使内存中保持个对象.工厂模式该模式主要功能是统一提供实例对象的引用。看下面的例子：publilassFactory{publilassesDaogetClassesDao(){ClassesDaocd=newClassesDaoImpl();returncd;}}interfaceClassesDao{publicStringgetClassesName();}classClassesDaoImplimplementsClassesDao{publicStringgetClassesName(){System.out.println(“A班“);}}classtest{publicstaticvoidmain(Stringargs){Factoryf=newFactory();f.getClassesDao().getClassesName();}}这个是最简单的例子了，就是通过工厂方法通过接口获取对象的引用.建造模式该模式其实就是说，一个对象的组成可能有很多其他的对象一起组成的，比如说，一个对象的实现非常复杂，有很多的属性，而这些属性又是其他对象的引用，可能这些对象的引用又包括很多的对象引用。封装这些复杂性，就可以使用建造模式。.门面模式这个模式个人感觉像是Service层的一个翻版。比如Dao我们定义了很多持久化方法，我们通过Service层将Dao的原子方法组成业务逻辑，再通过方法向上层提供服务。门面模式道理其实是一样的。.策略模式这个模式是将行为的抽象，即当有几个类有相似的方法，将其中通用的部分都提取出来，从而使扩展更容易。
⑷java工厂模式，懂的人进
⑸举两个例子以快速明白Java中的简单工厂模式：女娲抟土造人话说：“天地开辟，未有人民，女娲抟土为人。”女娲需要用土造出一个个的人，但在女娲造出人之前，人的概念只存在于女娲的思想里面。女娲造人，这就是简单工厂模式的应用。首先，在这个造人的思想里面，有几个重要的角色：女娲本身、抽象的人的概念和女娲所造出的一个个具体的人。.女娲是一个工厂类，也就是简单工厂模式的核心角色。.具休的一个个的人，包括张三，李四等。这些人便是简单工厂模式里面的具体产品角色.抽象的人是最早只存在于女娲的头脑里的一个想法，女娲按照这个想法造出的一个个具体的人，便都符合这个抽象的人的定义。换言之，这个抽象的想法规定了所有具体的人必须都有的接口（特征或者功能其UML类图出下所示：理解了上面的这些东西，再来理解下面的例子，对照理解，相信看完这篇文章，便对java简单工厂模式有一个很好的理解：有一个农场公司，专门向市场销售各类水果，在这个系统里需要描述下列水果：葡萄Grape草莓Stuawberry苹果Apple水果与其他植物不同，最终可以采摘食用，那么一个自然的做法是建立一个各种水果都适用的接口，以便与其他农场里的植物区分开来，此时，则是为水果类声明了一个接口，表现在代码上：publicinterfaceFruit{//生长voidgrow();//收获voidharvest();//种植voidplant();}水果接口规定出所有的水果必须实现的接口，包括任何水果类必须具备的方法plant(),grow(),和harvest();Apple类是水果类的一种，因此它实现了水果接口所声明的所有方法。另处，由于苹果是多年生植物，因此多出一个treeAge性质，描述苹果的树龄。代码如下所示：packagefac;publilassAppleimplementsFruit{//通过implements实现接口FruitprivateinttreeAge;publicvoidgrow(){log(“Appleisgrowing“);}publicvoidharvest(){log(“Applehasbeenharvested“);}publicvoidplant(){log(“Applehabeenplanted“);}publicstaticvoidlog(Stringmsg){System.out.println(msg);}publicintgetTreeAge(){returntreeAge;}publicvoidsetTreeAge(inttreeAge){this.treeAge=treeAge;}}同理，葡萄Grape：packagefac;publilassGrapeimplementsFruit{privatebooleanseedless;publicvoidgrow(){log(“Grapeisgrowing.“);}publicvoidharvest(){log(“Grapehasbeenharvested“);}publicvoidplant(){log(“Grapehabeenplanted“);}publicstaticvoidlog(Stringmsg){System.out.println(msg);}publicbooleanisSeedless(){returnseedless;}publicvoidsetSeedless(booleanseedless){this.seedless=seedless;}}草莓Stuawberry：packagefac;publilassStrawberryimplementsFruit{publicvoidgrow(){log(“Strawberryisgrowing“);}publicvoidharvest(){log(“Strawberryhasbeenharvested“);}publicvoidplant(){log(“Strawberryhasbeenplanted“);}publicstaticvoidlog(Stringmsg){System.out.println(msg);}}农场园丁也是系统的一部分，由一个类来代表，FruitGardener类，代码如下：packagefac;publilassFruitGardener{publicstaticFruitfactory(Stringwhich)throwsException{if(which.equalsIgnoreCase(“apple“)){returnnewApple();}elseif(which.equalsIgnoreCase(“strawberry“)){returnnewStrawberry();}elseif(which.equalsIgnoreCase(“grape“)){returnnewGrape();}else{thrownewException(“Badfruitrequest“);}}}这时有人来果园玩，和园丁说，给我们介绍下你的水果吧。于是园丁：packagefac;publilassPeople{publicstaticvoidmain(Stringargs)throwsException{FruitGardenerfg=newFruitGardener();Fruitap=fg.factory(“Apple“);ap.grow();Fruitgp=fg.factory(“Grape“);gp.plant();Fruitdd=fg.factory(“ddd“);//抛出Badfruitrequest异常}}（注：以上代码在JDK.，Myeclise.下编译通过类比两个例子，园丁就相当于女娲，而水果就相当于具体的人，接口水果类就相当于存在于类女娲思想里的人的抽象概念。由以上两个例子可得出，简单工厂模式需要由以下角色组成：接口接口的实现类（简单工厂模式里面的具体产品角色工厂理解了以下两个例子，再来看第三个例子：注意对比以下三个实例的不同实例：package.jzkangta.factorydemo;//定义接口interfaceCar{publicvoidrun();publicvoidstop();}//具体实现类classBenzimplementsCar{publicvoidrun(){System.out.println(“Benz开始启动了。。。。。“);}publicvoidstop(){System.out.println(“Benz停车了。。。。。“);}}//具体实现类classFordimplementsCar{publicvoidrun(){System.out.println(“Ford开始启动了。。。“);}publicvoidstop(){System.out.println(“Ford停车了。。。。“);}}//工厂classFactory{publicstatiargetCarInstance(){returnnewFord();}}publilassFactoryDemo{publicstaticvoidmain(Stringargs){Carc=Factory.getCarInstance();c.run();c.stop();}}实例二：packagefac;//定义接口interfaceCar{publicvoidrun();publicvoidstop();}//具体实现类classBenzimplementsCar{publicvoidrun(){System.out.println(“Benz开始启动了。。。。。“);}publicvoidstop(){System.out.println(“Benz停车了。。。。。“);}}classFordimplementsCar{publicvoidrun(){System.out.println(“Ford开始启动了。。。“);}publicvoidstop(){System.out.println(“Ford停车了。。。。“);}}//工厂classFactory{publicstatiargetCarInstance(Stringtype){Carc=null;if(“Benz“.equals(type)){c=newBenz();}if(“Ford“.equals(type)){c=newFord();}returnc;}}publilassFactoryDemo{publicstaticvoidmain(Stringargs){Carc=Factory.getCarInstance(“Benz“);if(c!=null){c.run();c.stop();}else{System.out.println(“造不了这种汽车。。。“);}}}实例三：interfaceCar{publicvoidrun();publicvoidstop();}classBenzimplementsCar{publicvoidrun(){System.out.println(“Benz开始启动了。。。。。“);}publicvoidstop(){System.out.println(“Benz停车了。。。。。“);}}classFordimplementsCar{publicvoidrun(){System.out.println(“Ford开始启动了。。。“);}publicvoidstop(){System.out.println(“Ford停车了。。。。“);}}classToyotaimplementsCar{publicvoidrun(){System.out.println(“Toyota开始启动了。。。“);}publicvoidstop(){System.out.println(“Toyota停车了。。。。“);}}classFactory{publicstatiargetCarInstance(Stringtype){Carc=null;try{c=(Car)Class.forName(“.jzkangta.factorydemo.“+type).newInstance();//利用反射得到汽车类型}catch(InstantiationExceptione){//TODOAuto-generatedcatchblocke.printStackTrace();}catch(IllegalAessExceptione){//TODOAuto-generatedcatchblocke.printStackTrace();}catch(ClassNotFoundExceptione){//TODOAuto-generatedcatchblocke.printStackTrace();}returnc;}}publilassFactoryDemo{publicstaticvoidmain(Stringargs){Carc=Factory.getCarInstance(“Toyota“);if(c!=null){c.run();c.stop();}else{System.out.println(“造不了这种汽车。。。“);}}}对比三个实例：实例一，虽然实现了简单工厂，但每次只能得到一种汽车，如果我们想换一种，就得修改工厂，太不方便，而实例二则改变了这种情况，便得我们可以按照我们的需要更换汽车，但我们所更换的汽车必须是实现类中有的，如果我们想要增加一种汽车的时候，我们还是得更改工厂，通过改进，实例三利用反射机制，得到汽车类型，这样当我们需要增加一种新的汽车时，就无需要再修改工厂，而只需要增加要实现的类即可。也就是说要增加什么样的汽车直接增加这个汽车的类即可，而无需改变工厂。从而达到了工厂分离的效果。
⑹java简单工厂模式是什么
⑺简单工厂模式的：简单工厂模式是类的创建模式，又叫做静态工厂方法（StaticFactoryMethod模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。那么简单工厂模式是在什么场景下使用呢，下面就以本人的理解举例说明:就拿登录功能来说，假如应用系统需要支持多种登录方式如：口令认证、域认证（口令认证通常是去数据库中验证用户，而域认证则是需要到微软的域中验证用户。那么自然的做法就是建立一个各种登录方式都适用的接口，如下图所示：publicinterfaceLogin{//登录验证publicbooleanverify(Stringname,Stringpassword);}publilassDomainLoginimplementsLogin{Overridepublicbooleanverify(Stringname,Stringpassword){//TODOAuto-generatedmethodstub/***业务逻辑*/returntrue;}}publilassPasswordLoginimplementsLogin{Overridepublicbooleanverify(Stringname,Stringpassword){//TODOAuto-generatedmethodstub/***业务逻辑*/returntrue;}}我们还需要一个工厂类LoginManager，根据调用者不同的要求，创建出不同的登录对象并返回。而如果碰到不合法的要求，会返回一个Runtime异常。publilassLoginManager{publicstaticLoginfactory(Stringtype){if(type.equals(“password“)){returnnewPasswordLogin();}elseif(type.equals(“passcode“)){returnnewDomainLogin();}else{/***这里抛出一个自定义异常会更恰当*/thrownewRuntimeException(“没有找到登录类型“);}}}测试类：publilassTest{publicstaticvoidmain(Stringargs){//TODOAuto-generatedmethodstubStringloginType=“password“;Stringname=“name“;Stringpassword=“password“;Loginlogin=LoginManager.factory(loginType);booleanbool=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表示从客户端传递过来的参数：publilassTest{publicstaticvoidmain(Stringargs){//TODOAuto-generatedmethodstubStringloginType=“password“;Stringname=“name“;Stringpassword=“password“;//处理口令认证if(loginType.equals(“password“)){PasswordLoginpasswordLogin=newPasswordLogin();booleanbool=passwordLogin.verify(name,password);if(bool){/***业务逻辑*/}else{/***业务逻辑*/}}//处理域认证elseif(loginType.equals(“passcode“)){DomainLogindomainLogin=newDomainLogin();booleanbool=domainLogin.verify(name,password);if(bool){/***业务逻辑*/}else{/***业务逻辑*/}}else{/***业务逻辑*/}}}上面的代码会不会很蛋疼啊。。。呵呵《JAVA与模式》一书中使用java.text.DataFormat类作为简单工厂模式的典型例子叙述。简单工厂模式的优点模式的核心是工厂类。这个类含有必要的逻辑判断，可以决定在什么时候创建哪一个登录验证类的实例，而调用者则可以免除直接创建对象的责任。简单工厂模式通过这种做法实现了对责任的分割，当系统引入新的登录方式的时候无需修改调用者。简单工厂模式的缺点这个工厂类集中了所以的创建逻辑，当有复杂的多层次等级结构时，所有的业务逻辑都在这个工厂类中实现。什么时候它不能工作了，整个系统都会受到影响。
⑻用java编写程序写出简单的工厂模式
⑼java中工厂模式分为:
⑽提供一个简单工厂模式的案例：
⑾publicabstractclassWoman{
⑿privateStringmySkill;
⒀publicStringgetMySkill(){
⒁returnmySkill;
⒂publicWoman(){
⒃//System.out.println(“我是女人“);
⒄publicvoidsetMySkill(StringmySkill){
⒅this.mySkill=mySkill;
⒆----------------------------
⒇publilassLovelinessWomanextendsWoman{
⒈publicLovelinessWoman()
⒉StringmySkill=“撒过娇、出过轨、勾引领导下过水“;
⒊this.setMySkill(mySkill);
⒋-----------------------------
⒌publilassSteelinessWomanextendsWoman{
⒍publicSteelinessWoman()
⒎StringmySkill=“装过神、弄过鬼，跟别人老公亲过嘴“;
⒏this.setMySkill(mySkill);
⒐--------------------------------------
⒑publilassWomanMakeFactory{
⒒publicWomanfindWoman(inttypeID){
⒓switch(typeID){
⒔returnnewLovelinessWoman();
⒕returnnewVirtuousWoman();
⒖returnnewSteelinessWoman();
⒗returnnull;
⒘publicWomanfindWoman(Stringtype)throwsClassNotFoundException,InstantiationException,IllegalAessException{
⒙*Typet=Type.GetType(“SimpleFactory.“+type);
⒚*(Woman)Activator.CreateInstance(t);returnwm;
⒛Stringstring=“.jbit.design.simplefactory.“+type;
Classc=Class.forName(string);
Womanwm=(Woman)c.newInstance();
-------------------------
publilassTest{
*paramargs
*throwsIllegalAessException
*throwsInstantiationException
*throwsClassNotFoundException
publicstaticvoidmain(Stringargs)throwsClassNotFoundException,InstantiationException,IllegalAessException{
Scannerinput=newScanner(System.in);
booleansel=false;
System.out.println(“请选择你要找的女人的类型“);
System.out.println(“LovelinessWoman：可爱型女人VirtuousWoman：善良型女人SteelinessWoman：冷酷型女人“);
Stringtypeid=input.next();
WomanMakeFactoryfactory=newWomanMakeFactory();
Womanwm=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代码。
interfaceLog{
publicvoidwriteLog();
classFileLogimplementsLog{
publicvoidwriteLog(){
System.out.println(“文件记录“);
classDatabaseLogimplementsLog{
publicvoidwriteLog(){
System.out.println(“数据库记录“);
interfaceLogFactory{
publicLogcreateLog();
classFileLogFactoryimplementsLogFactory{
publicLogcreateLog(){
returnnewFileLog();
classDatabaseLogFactoryimplementsLogFactory{
publicLogcreateLog(){
returnnewDatabaseLog();
publilassClient{
publicstaticvoidmain(Stringargs){
LogFactoryfactory;
//这里可以改成使用DOM和Java反射机制读取XML文件，获取工厂类名
factory=newDatabaseLogFactory();
log=factory.createLog();
log.writeLog();
catch(Exceptione){
System.out.println(e.getMessage());
java工厂模式例子
产品publicinterfaceWork{voiddoWork();}ConcreteProductpublilassStudentWorkimplementsWork{publicvoiddoWork(){System.out.println(“学生做作业!“);}}publilassTeacherWorkimplementsWork{publicvoiddoWork(){System.out.println(“老师审批作业!“);}}生产者publicinterfaceIWorkFactory{WorkgetWork();}ConcreteCreatorpublilassStudentWorkFactoryimplementsIWorkFactory{publicWorkgetWork(){returnnewStudentWork();}}publilassTeacherWorkFactoryimplementsIWorkFactory{publicWorkgetWork(){returnnewTeacherWork();}}TestpublilassTest{publicstaticvoidmain(Stringargs){IWorkFactorystudentWorkFactory=newStudentWorkFactory();studentWorkFactory.getWork().doWork();IWorkFactoryteacherWorkFactory=newTeacherWorkFactory();teacherWorkFactory.getWork().doWork();}}
关于java工厂模式
呵，我最近也在研究这个，文字一堆的概念性的东西我就不说了，看着就烦~我理解的工厂模式应该这样的：对于初学者来说，设计一个程序往往是边写代码边修正，缺乏一个环节：设计工厂模式我觉得应该是以设计为第一步的编程方法首先拿到一个项目后，先分析这个项目你准备写哪些类，分别实现哪些功能然后看看你的个各类中是否有功能相同或者功能类似的部分，将这些部分提取出来然后按照他们的层次设计不同的接口，最后为所有接口设计一个抽象类举个例子，假设我们要描述一个人的特征，可以定义一个human类，并赋予它成员变量：age,sex,height,weight...等等等等。那么在描述这个人的时候，可以实例化这个human类，然后采用human.age=;human.sex=“男性“;等等这类方法来描述这个对象。这样的描述不能说有错，但并不是工厂模式。假设有四个不同的人，先提取他们的共同特征，男女，都是人。那么可以这样描述他们：先定义一个顶层的抽象类：人类然后定义个接口，分别对人类进行扩展性描述：男人，女人再定义个接口，再对上面的类进行扩展性描述：年轻男人，年老男人，年轻女人，年老女人那么引用了年轻男人这个接口的类就直接被赋予了人类、性别、年龄这三个属性特征。也就是说，如果用前一种方式来描述一个人，它只是一个孤立的类，用工厂模式来描述一个人，它其实是一个树形结构。表面上看起来，工厂模式写起来似乎更加的麻烦，其实它有它的优点所在：、能体现你的几个类的层次结构，父子关系，引用关系。而不是为了引用代码就使用继承，为了多重继承就使用接口，我觉得这些都是错误的用法。、假设需要你描述个人，每个人都要用个形容词来修饰他，那么第一种方法无疑是艰巨的任务。为了描述一个人的某个特征，你不得不去描述他们的个特征，这样的工作要重复次！但如果用工厂模式，你只需要建立好工厂模式的构架，选择就接近对象特征的那个类进行实例化就可以了！、在维护方法，一旦程序需要扩展功能，第一种方法就只能不断的向human类添加成员变量，向滚雪球一样越滚越大，而你所有引用了human类的地方都必须修改，对于一个大的项目来说维护工作是致命的！而使用工厂模式，你可以随时在任意两个类中插入其他的类，只需要更改上下的引用而已，而你其他引用了这些类的地方则完全不受其影响！所以才说JAVA是一门设计的语言，以上只是我个人的理解，至于对不对，还在实践中~~
Java的工厂模式有哪一些，分别有什么作用，一般用在哪些地方
我简单的说下，举个例子，当我们的程序结构比较繁杂时，比如有个类，而类中又有很多方法，这些方法之间都互相有依赖关系，也就是一个方法之间的某段逻辑处理需要用到另一个类中的代码逻辑，这种时候对于整个程序而言是非常不利于开发的（我们需要考虑到很多类、方法之间的耦合问题，那么就有一个概念了，也就是面对接口编程。通俗的说就是把类中的方法封装起来，外部调用的人完全不需要考虑方法是如何实现的，但是这样做也有一个不好的地方，我们的接口是不提供方法实现的，而需要在类中实现接口的方法。那么问题产生了，我们在new接口对象的时候需要明确的知道他的实例类。想象一下，如果程序在继续庞大，接口非常多，接口实例类非常多，这样又会产生我们之前的问题（我们需要考虑到很多类、方法之间的耦合问题那么这个时候就产生了一中设计思想，也就是工厂模式，这种模式的核心思想就是管理接口的实例对象，把接口和实例对象之间的关系封装起来处理，外部需要用到某个接口的实例时，由工厂进行分配，而不需要关注具体是哪个实例。如果你做到比较复杂的程序时你应该就能体会到了。
什么是工厂模式有没有用工厂模式解决实际问题
工厂模式的思想主要为：多个类似的子类继承同一个父类，对其父类中的变量进行操作；工厂类负责判断、控制哪个子类被执行，而工厂类调用子类完成后，返回的结果是该子类的父类，该父类中的变量已经被操作过了，访问该父类，得到我们想要的结果例如：publicinterfaceFruit{voidgrow();//生长voidharvest();//收获voidplant();//种植}publilassAppleimplementsFruit{privateinttreeAge;publicvoidgrow(){System.out.println(“Appleisgrowing“);}publicvoidharvest(){System.out.println(“Applehasbeenharvested“);}publicvoidplant(){System.out.println(“Applehasbeenplanted“);}publicintgetTreeAge(){returntreeAge;}publicvoidsetTreeAge(intage){this.treeAge=age;}}publilassGrapeimplementsFruit{privatebooleanseedless;publicvoidgrow(){System.out.println(“Appleisgrowing“);}publicvoidharvest(){System.out.println(“Applehasbeenharvested“);}publicvoidplant(){System.out.println(“Applehasbeenplanted“);}publicbooleangetSeedless(){returnseedless;}publicvoidsetSeedless(booleanseed){this.seedless=seed;}}publilassFruitGardener{publicstaticFruitfactory(Stringwhich)throwsBadFruitException{if(which.equalsIgnoreCase(“apple“)){returnnewApple();}elseif(which.equalsIgnoreCase(“grape“)){returnnewGrape();}else{thrownewBadFruitException(“BadFruitrequest“);}}}publilassBadFruitExceptionextendsException{publicBadFruitException(Stringmsg){super(msg);}}publicstaticvoidmain(Stringargs){try{FruitGardener.factory(“apple“);FruitGardener.factory(“grape“);}catch(BadFruitExceptione){System.out.println(e);}}}