工厂模式和单例模式

工厂模式

单例模式

 

工厂模式：

1．   解决了创建对象使用new模式的问题，降低了应用程序组件之间的耦合（依赖性）

2．   把组件之间的职责进行清晰的划分，具体是把组件的使用者与创建者的角色分清

3．   实施方案是采用接口编程，不依赖于实现，依赖于接口

4．   客户所关心是产品的功能（即接口），而不关心科品的如何实现

5．   A组件要使用B组件，那么A组件就要依赖于B组件

A．  以前的方法，在A组件中是通过 B demo=new B();

B．  现在的方法是A组件调用的不是B组件的本身而是调用B组件所实现的接口，并且通过工厂模式去得到B组件所实现的接口

6.        在A组件中应该看不到具体实现接口的类

 

 

单例模式

单例去建自己，

工厂去创建别人

特点：

1．   构造函数为私有的

2．   一定有一个静态方法名一般为Instacnce创建自己

3．   在有一个非静态方法，这些方法去创建其它类的实例

 

 

在JAVA如何来创建对象

1．   通过new关键字

2．   通过工厂模式可以建一个对象

3．   通过克隆 

例：       java.util.ArrayList a=new java.util.ArrayList();

                a.clone();

4． 通过Class.forName(“类名”).newInstance();  反射技术

         例：

    public Ipeople createIpeople(String people)

    {

        try

        {

            Ipeople ip = (Ipeople)Class.forName("factoryemp."+people).newInstance();  --包名加上

            return ip;

        }catch(Exception xx)

        {

            return null;

        }

}

 

 

完整的一个例子：

接口：

package factoryemp;

 

public interface Ipeople   //接口中有二个方法,只要写上接口，就说明未来会变化，把接口给客户

{

    public void SayHello();    //能实现这个接口的类可能有很多不至一个

    public void SayBay();

 

   

}

 

二个实现接口的类：

package factoryemp;

 

public class Chinese implements Ipeople{

    public Chinese() {

    }

    public void SayHello()

    {

        System.out.print("你好");

    }

    public void SayBay()

    {

        System.out.print("再见");

    }

}

 

package factoryemp;

 

public class America implements Ipeople{

    public America() {

    }

    public void SayHello()    //能实现这个接口的类可能有很多不至一个

    {

      System.out.print("Hello");

    }

    public void SayBay()

    {

        System.out.print("Bay");

    }

}

 

工厂：

 

package factoryemp;

import java.lang.*;

import factoryemp.*;

public class peopleFactory

{

    private static peopleFactory demo=null;    //静态方法只能使用静态成员static

    private peopleFactory()

    {

   

    }

    public static peopleFactory newInstance()   //为自己创建一个唯一的实例static方法

    {

        if(demo==null)

        {

            demo=new peopleFactory();

        }

       

        return demo;

       

    }

    public Ipeople createIpeople(String people)

    {

        try

        {

            Ipeople ip = (Ipeople)Class.forName("factoryemp"+people).newInstance();

            return ip;

        }catch(Exception xx)

        {

            return null;

        }

    }

 

}

 

Main调用:

 

package factoryemp;

 

public class test {

    public test() {

    }

 

    public static void main(String[] args)

    {

       //Chinese c=new Chinese();    --此实例化是以前的用法，缺点：1.没有职责区分开 2.角色很模糊

       //c.SayBay();

      // Ipeople demo=new Chinese();    //--把实现了接口的类的实例给接口,比上面的一种方法要先进，但还是有依赖性在A组件中应该看不到具体实现接口的类

       //demo.SayBay();

       peopleFactory pf=peopleFactory.newInstance();   //用工厂自己实例化自己

       Ipeople ip=pf.createIpeople("Chinese");

       ip.SayHello();

 

   

 

    }

}

 

用配置文件把项目中所有的组件都配置起来

1.        如果不用配置文件，那么就会在工厂类里面写很多的创建接口的方法

2.        而且由于这些组件的包名不一样，也无法控制

    public Object createInstance(String type)

    {

        String src=System.getProperty("user.dir")+"//WebM//xml//comment.xml";

        try

        {

          javax.xml.parsers.DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();

          DocumentBuilder db=dbf.newDocumentBuilder();

          Document doc=db.parse(src);

          Element root=doc.getDocumentElement();

          NodeList list=root.getElementsByTagName("compoment");

          for(int i=0;i<list.getLength();i++)

          {

              Element comElement=(Element)list.item(i);

              String id=comElement.getAttribute("id");

              String ee=comElement.getAttribute("type");

              if(id.equals(type))

              {

                 Object demo=Class.forName(type).newInstance();

              }

              break;

          }

        }catch(Exception xxx)

        {

            return null;

        }

        return demo;

    }

   

 

调用:

Ipeople d=(Ipeople)peopleFactory.newInstance().createInstance("cat");

       d.SayBay();

 

 

作业：

1．   做一个简单的留言板功能

a.        用户类

1.        描述类(用户名，密码，昵称)

2.        管理类(接口实现，为用户类的业务定义接口（）)

a.        public add(user NewUser)

b.        public del(String id)

c.        public update(User UpdateUser)

d.        public getUser(String id)

e.        public login (User checkUser)

3.        创建一个管理类，去实现该接口

b.        留言类（message类）

1.        1. 描述类(编号，用户ID，内容，时间)

2.        管理类(接口实现，为用户类的业务定义接口（）)

a.        public add(user message)

b.        public del(String id)

c.        public update(User Updatemessage)

d.        public getmessage (String id)

3.        创建一个管理类，去实现该接口

 

创建一个Xml文件,只有一个工厂,配置管理类

创建一个单例的工厂方法，去创建这些管理类

在客户端调用方法，测试

 

 

一切皆接口

 

============================================

单例模式

饿汉式:
  public class Singleton{
  private static Singleton singleton = new Singleton ();
  private Singleton (){}
  public Singleton getInstance(){

return singletion;

}
  }  

  懒汉式:
  public class Singleton{
  private static Singleton singleton = null;
  public static synchronized synchronized getInstance(){
  if(singleton==null){
  singleton = new Singleton();
  }
  return singleton;
  }
  }  

  比较:
  饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变
  懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的
  推荐使用第一种