求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 工厂模式

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 { // 定义工厂类

private static Factory factory;

private Factory(){}

public static Factory getInstance() {

if(factory==null){

factory=new Factory();

}

return factory;

}

public Apple newApplet(){

return new Apple();

}

public Orange newOrange(){

return new Orange();

}

};

class FactoryModel {

public static void main(String args[]) {

Fruit f = Factory.getInstance().newApplet();

if (f != null) { // 判断是否取得实例

f.eat();

}

f = Factory.getInstance().newOrange();

if (f != null) { // 判断是否取得实例

f.eat();

}

}

};

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工厂模式和单体模式

单体模式 很简单，就是将构造函数变为私有，那么就不能通过new 来创建对象。 同时创建一个 共有的静态的方法来获得实例，代码如下：

class Test{

private static Test instance = null;

private Test(){}

public static Test getInstance(){

if( instance == null ){

instance = new Test();

}

return instance ;

}

}

工厂模式有三个参与者，抽象产品(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的几个工厂方法解析

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;

}

}

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

工厂模式java实例如下：

public interface Work {

void doWork();

}

ConcreteProduct

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();

}

}

字符串反转如下：

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;

}

冒泡排序算法，从小到大

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

     //小到大的排序

       int temp = 0;

       for(int i = 0;itargetArr.length;i++){

           for(int j = i;jtargetArr.length;j++){

               if(targetArr[i]targetArr[j]){

                   temp = targetArr[i];

                   targetArr[i] = targetArr[j];

                   targetArr[j] = temp;

                  }

            }

       }

    return targetArr;

}

分享标题：工厂模式java的代码,java实现工厂模式
浏览路径：http://ybzwz.com/article/hddcjh.html