java几种常用设计模式简单示例.docx

java几种常用设计模式简单示例.docx

《java几种常用设计模式简单示例.docx》由会员分享，可在线阅读，更多相关《java几种常用设计模式简单示例.docx（40页珍藏版）》请在冰豆网上搜索。

java几种常用设计模式简单示例

java几种常用设计模式简单示例

设计模式Java

1.单例设计模式

      所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。

具体实现步骤如下：

（1）将采用单例设计模式的类的构造方法私有化（采用private修饰）。

（2）在其内部产生该类的实例化对象，并将其封装成privatestatic类型。

     （3）定义一个静态方法返回该类的实例。

        示例代码如下：

Java代码

class Singleton {  

    private static Singleton instance = new Singleton（）;// 在内部产生本类的实例化对象  

    public static Singleton getInstance（） { // 通过静态方法返回instance对象  

        return instance;  

    }  

    private Singleton（） { // 将构造方法封装为私有化  

    }  

    public void print（） {  

        System.out.println（"Hello World!

!

!

"）;  

    }  

}  

public class SingletonDemo {  

    public static void main（String args[]） {  

        Singleton s1 = null; // 声明对象  

        Singleton s2 = null; // 声明对象  

        Singleton s3 = null; // 声明对象  

        s1 = Singleton.getInstance（）; // 取得实例化对象  

        s2 = Singleton.getInstance（）; // 取得实例化对象  

        s3 = Singleton.getInstance（）; // 取得实例化对象  

        s1.print（）; // 调用方法  

        s2.print（）; // 调用方法  

        s3.print（）; // 调用方法  

    }  

}  

[java]viewplaincopyprint?

class Singleton {  

    private static Singleton instance = new Singleton（）;// 在内部产生本类的实例化对象  

    public static Singleton getInstance（） { // 通过静态方法返回instance对象  

        return instance;  

    }  

    private Singleton（） { // 将构造方法封装为私有化  

    }  

    public void print（） {  

        System.out.println（"Hello World!

!

!

"）;  

    }  

}  

public class SingletonDemo {  

    public static void main（String args[]） {  

        Singleton s1 = null; // 声明对象  

        Singleton s2 = null; // 声明对象  

        Singleton s3 = null; // 声明对象  

        s1 = Singleton.getInstance（）; // 取得实例化对象  

        s2 = Singleton.getInstance（）; // 取得实例化对象  

        s3 = Singleton.getInstance（）; // 取得实例化对象  

        s1.print（）; // 调用方法  

        s2.print（）; // 调用方法  

        s3.print（）; // 调用方法  

    }  

}  

classSingleton{

privatestaticSingletoninstance=newSingleton（）;//在内部产生本类的实例化对象

publicstaticSingletongetInstance（）{//通过静态方法返回instance对象

returninstance;

}

privateSingleton（）{//将构造方法封装为私有化

}

publicvoidprint（）{

System.out.println（"HelloWorld!

!

!

"）;

}

}

publicclassSingletonDemo{

publicstaticvoidmain（Stringargs[]）{

Singletons1=null;//声明对象

Singletons2=null;//声明对象

Singletons3=null;//声明对象

s1=Singleton.getInstance（）;//取得实例化对象

s2=Singleton.getInstance（）;//取得实例化对象

s3=Singleton.getInstance（）;//取得实例化对象

s1.print（）;//调用方法

s2.print（）;//调用方法

s3.print（）;//调用方法

}

}

 一、单例模式的介绍

    Singleton是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点

二、单例模式的实现

实现的方式有如下四种：

Java代码

/** 

 *  

 * 单例模式的实现：

饿汉式,线程安全 但效率比较低 

 */  

public class SingletonTest {  

    private SingletonTest（） {  

    }  

    private static final SingletonTest instance = new SingletonTest（）;  

    public static SingletonTest getInstancei（） {  

        return instance;  

    }  

}  

[java]viewplaincopyprint?

/** 

 *  

 * 单例模式的实现：

饿汉式,线程安全 但效率比较低 

 */  

public class SingletonTest {  

    private SingletonTest（） {  

    }  

    private static final SingletonTest instance = new SingletonTest（）;  

    public static SingletonTest getInstancei（） {  

        return instance;  

    }  

}  

/**

*

*单例模式的实现：

饿汉式,线程安全但效率比较低

*/

publicclassSingletonTest{

privateSingletonTest（）{

}

privatestaticfinalSingletonTestinstance=newSingletonTest（）;

publicstaticSingletonTestgetInstancei（）{

returninstance;

}

}

Java代码

/** 

 * 单例模式的实现：

饱汉式,非线程安全  

 *  

 */  

public class SingletonTest {  

    private SingletonTest（） {  

    }  

    private static SingletonTest instance;  

    public static SingletonTest getInstance（） {  

        if （instance == null）  

            instance = new SingletonTest（）;  

        return instance;  

    }  

}  

[java]viewplaincopyprint?

/** 

 * 单例模式的实现：

饱汉式,非线程安全  

 *  

 */  

public class SingletonTest {  

    private SingletonTest（） {  

    }  

    private static SingletonTest instance;  

    public static SingletonTest getInstance（） {  

        if （instance == null）  

            instance = new SingletonTest（）;  

        return instance;  

    }  

}  

/**

*单例模式的实现：

饱汉式,非线程安全

*

*/

publicclassSingletonTest{

privateSingletonTest（）{

}

privatestaticSingletonTestinstance;

publicstaticSingletonTestgetInstance（）{

if（instance==null）

instance=newSingletonTest（）;

returninstance;

}

}

Java代码

/** 

 * 线程安全，但是效率非常低 

 * @author vanceinfo 

 * 

 */  

public class SingletonTest {  

    private SingletonTest（） {  

    }  

    private static SingletonTest instance;  

    public static synchronized SingletonTest getInstance（） {  

        if （instance == null）  

            instance = new SingletonTest（）;  

        return instance;  

    }  

}  

[java]viewplaincopyprint?

/** 

 * 线程安全，但是效率非常低 

 * @author vanceinfo 

 * 

 */  

public class SingletonTest {  

    private SingletonTest（） {  

    }  

    private static SingletonTest instance;  

    public static synchronized SingletonTest getInstance（） {  

        if （instance == null）  

            instance = new SingletonTest（）;  

        return instance;  

    }  

}  

/**

*线程安全，但是效率非常低

*@authorvanceinfo

*

*/

publicclassSingletonTest{

privateSingletonTest（）{

}

privatestaticSingletonTestinstance;

publicstaticsynchronizedSingletonTestgetInstance（）{

if（instance==null）

instance=newSingletonTest（）;

returninstance;

}

}

Java代码

/** 

 * 线程安全  并且效率高 

 * 

 */  

public class SingletonTest {  

    private static SingletonTest instance;  

    private SingletonTest（） {  

    }  

    public static SingletonTest getIstance（） {  

        if （instance == null） {  

            synchronized （SingletonTest.class） {  

                if （instance == null） {  

                    instance = new SingletonTest（）;  

                }  

            }  

        }  

        return instance;  

    }  

}  

 2.工厂设计模式

      程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。

     示例代码如下：

Java代码

interface Animal { // 定义一个动物的接口  

    public void say（）; // 说话方法  

}  

class Cat implements Animal { // 定义子类Cat  

    @Override  

    public void say（） { // 覆写say（）方法  

        System.out.println（"我是猫咪，喵呜！

"）;  

    }  

}  

class Dog implements Animal { // 定义子类Dog  

    @Override  

    public void say（） { // 覆写say（）方法  

        System.out.println（"我是小狗，汪汪！

"）;  

    }  

}  

class Factory { // 定义工厂类  

    public static Animal getInstance（String className） {  

        Animal a = null; // 定义接口对象  

        if （"Cat".equals（className）） { // 判断是哪个子类的标记  

            a = new Cat（）; // 通过Cat子类实例化接口  

        }  

        if （"Dog".equals（className）） { // 判断是哪个子类的标记  

            a = new Dog（）; // 通过Dog子类实例化接口  

        }  

        return a;  

    }  

}  

public class FactoryDemo {  

    public static void main（String[] args） {  

        Animal a = null; // 定义接口对象  

        a = Factory.getInstance（args[0]）; // 通过工厂获取实例  

        if （a !

= null） { // 判断对象是否为空  

            a.say（）; // 调用方法  

        }  

    }  

}  

[java]viewplaincopyprint?

interface Animal { // 定义一个动物的接口  

    public void say（）; // 说话方法  

}  

class Cat implements Animal { // 定义子类Cat  

    @Override  

    public void say（） { // 覆写say（）方法  

        System.out.println（"我是猫咪，喵呜！

"）;  

    }  

}  

class Dog implements Animal { // 定义子类Dog  

    @Override  

    public void say（） { // 覆写say（）方法  

        System.out.println（"我是小狗，汪汪！

"）;  

    }  

}  

class Factory { // 定义工厂类  

    public static Animal getInstance（String className） {  

        Animal a = null; // 定义接口对象  

        if （"Cat".equals（className）） { // 判断是哪个子类的标记  

            a = new Cat（）; // 通过Cat子类实例化接口  

        }  

        if （"Dog".equals（className）） { // 判断是哪个子类的标记  

            a = new Dog（）; // 通过Dog子类实例化接口  

        }  

        return a;  

    }  

}  

public class FactoryDemo {  

    public static void main（String[] args） {  

        Animal a = null; // 定义接口对象  

        a = Factory.getInstance（args[0]）; // 通过工厂获取实例  

        if （a !

= null） { // 判断对象是否为空  

            a.say（）; // 调用方法  

        }  

    }  

}  

interfaceAnimal{//定义一个动物的接口

publicvoidsay（）;//说话方法

}

classCatimplementsAnimal{//定义子类Cat

@Override

publicvoidsay（）{//覆写say（）方法

System.out.println（"我是猫咪，喵呜！

"）;

}

}

classDogimplementsAnimal{//定义子类Dog

@Override

publicvoidsay（）{//覆写say（）方法

System.out.println（"我是小狗，汪汪！

"）;

}

}

classFactory{//定义工厂类

publicstaticAnimalgetInstance（StringclassName）{

Animala=null;//定义接口对象

if（"Cat".equals（className））{//判断是哪个子类的标记

a=newCat（）;//通过Cat子类实例化接口

}

if（"Dog".equals（className））{//判断是哪个子类的标记

a=newDog（）;//通过Dog子类实例化接口

}

returna;

}

}

publicclassFactoryDemo{

publicstaticvoidmain（String[]args）{

Animala=null;//定义接口对象

a=Factory.getInstance（args[0]）;//通过工厂获取实例

if（a!

=null）{//判断对象是否为空

a.say（）;//调用方法

}

}

}

 3.代理设计模式

      指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。

比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

     示例代码如下：

Java代码

interface Network { // 定义Network接口  

    public void browse（）; // 定义浏览的抽象方法  

}  

class Real implements Network { // 真实的上网操作  

    public void browse（） { // 覆写抽象方法  

        System.out.println（"上网浏览信息！

"）;  

    }  

}  

class Proxy implements Network { // 代理上网  

    private Network network;  

    public Proxy（Network network） {// 设置代理的真实操作