java常用五种设计模式

一.单例设计模式
1.定义
Singleton是一种创建型模式,指某个类使用了Singleton模式,则这个类被创建后,只能产生一个实例供外部访问,并且提供一个全局的访问点。单例设计模式指的就是无论程序如何运行,采用单例设计模式的类(Singleton)永远都只会有一个实例化对象产生。
2.具体实现步骤
1).在其内部产生该类的实例化对象,并将其封装成private static类型;
2).将采用单例设计模式的类的构造方法私有化;
3).定义一个静态方法返回该类的实例。
3.代码示例
[Java] 纯文本查看 复制代码
?

/sizealign=leftclass Singleton{

// 1.在内部产生本类的实例化对象
private static Singleton instance = new Singleton();        
// 2.将构造方法封装为私有化
private Singleton(){            
}   
// 3.通过静态方法返回instance对象
public static Singleton getInstance(){      
    return instance;
}   
public void print(){
    System.out.println("hello world!");
}

}

public class Singleton_Summary {

public static void main(String[] args) {        
    // 声明三个对象
    Singleton st1 = null;
    Singleton st2 = null;
    Singleton st3 = null;       
    st1 = Singleton.getInstance();
    st2 = Singleton.getInstance();
    st3 = Singleton.getInstance();      
    st1.print();
    st2.print();
    st3.print();        
    System.out.println("st1==st2==st3: " + (st1 == st2));       
}

}
单例模式的实现一:
饿汉式,线程安全,但效率比较低。
代码示例:
[Java] 纯文本查看 复制代码
?

/alignclass SingletonTest01{

private static final SingletonTest01 instance = new SingletonTest01();
private SingletonTest01(){      
}
public static SingletonTest01 getInstance(){
    return instance;
}

}

public class Singleton01_Ehan {

public static void main(String[] args) {        
}

}
单例模式的实现二:

懒汉式,非线程安全
代码示例:
[Java] 纯文本查看 复制代码
?

/alignclass SingletonTest02{

private static SingletonTest02 instance;
private SingletonTest02(){      
}
public static SingletonTest02 getInstance(){
    if(instance == null){
        instance = new SingletonTest02();
    }
    return instance;
}

}

懒汉式线程安全,但是效率非常低
[Java] 纯文本查看 复制代码
?

/alignclass SingletonTest03{

private static SingletonTest03 instance;
private SingletonTest03(){

}
public static synchronized SingletonTest03 getInstance(){
    if(instance == null){
        instance = new SingletonTest03();
    }
    return instance;
}

}
懒汉式线程安全,并且效率高
[Java] 纯文本查看 复制代码
?

/alignclass SingletonTest04{

private static SingletonTest04 instance;
private SingletonTest04(){      
}
public static SingletonTest04 getInstance(){
    if(instance == null){
        synchronized (SingletonTest04.class) {
            if(instance == null){
                instance = new SingletonTest04();
            }
        }
    }
    return instance;
}

}
二.工厂设计模式
1.定义
主要用来实例化有共同接口的类,工厂模式可以动态决定应该实例化那一个类。具体做法即程序在接口和子类之间加入了一个过渡端,通过此过渡端可以动态取得实现了共同接口的子类实例化对象。
2.工厂模式主要有以下几种形态:
1)简单工厂(SimpleFactory);
2)工厂方法(FactoryMethod);
3)抽象工厂(AbstractFactory);

3.代码示例
[Java] 纯文本查看 复制代码
?

/aligninterface Animal{

public void say();

}

class Cat implements Animal{

public void say() {
    System.out.println("我是cat,hello world!");
}

}

class Dog implements Animal{

public void say() {
    System.out.println("我是dog,no bug!");
}

}

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 FactoryDemo01 {

public static void main(String[] args) {

    Animal a = null;
    a = Factory.getInstance("Cat");     // 通过工厂获取一个实例

    if(a != null){
        a.say();
    }
}

}
三.代理设计模式
1.定义
指由一个代理主题来操作真实主题,真实主题执行具体的业务操作,而代理主题负责其他相关业务的处理。
比如生活中的通过代理访问网络,客户通过网络代理连接网络(具体业务),由代理服务器完成用户权限和访问限制等与上网相关的其他操作(相关业务)。

2.代码示例
[Java] 纯文本查看 复制代码
?

/aligninterface Network{ // 定义Network接口

public void browse();               // 定义浏览的抽象方法

}

class Server implements Network{ // 真实上网操作

public void browse() {
    System.out.println("上网浏览信息!");
}

}

class Proxy implements Network{ // 代理上网

private Network network;
public Proxy(Network network){      // 设置代理的真实操作
    this.network = network;         // 设置代理的子类
}
public void check(){                // 身份验证操作
    System.out.println("检查用户是否合法!");
}
public void browse() {
    this.check();                   // 调用具体的代理业务操作
    this.network.browse();          // 调用真实的上网操作
}

}
四.观察者设计模式
1.定义
观察者设计模式,比如:现在许多购房者都密切观察者房价的变化,当房价变化时,所有的购房者都能观察到,以上的购房者属于观察者,这就是观察者设计模式。
java中可以借助Observable类和Observer接口轻松实现以上功能,当然此种模式并不仅仅局限于采用这两个类。

2.代码示例
[Java] 纯文本查看 复制代码
?

/alignclass House extends Observable{

private float price;
public House(float price){
    this.price = price;
}
public void setPrice(float price){
    this.setChanged();                  // 设置变化点
    this.notifyObservers(price);        // 通知所有观察者变化改变
    this.price = price;
}
public float getPrice(){
    return this.price;
}
public String toString(){
    return "房子的价格为:" + this.price;
}

}

class HousePriceObserver implements Observer{

private String name;
public HousePriceObserver(String name){
    super();
    this.name = name;
}
// 只要改变了,Observable 对象就调用此方法;
public void update(Observable o, Object arg) {  
    if(arg instanceof Float){
        System.out.println(this.name + "观察的价格更改为:" + ((Float) arg).floatValue());
    }
}

}

public class ObserverDemo01 {

public static void main(String[] args) {

    // 通过构造方法给房子价格赋值
    House house = new House(1000000);

    // 输出房子价格
    System.out.println("价格未修改时:\n" + house);

    // 实例化观察者
    HousePriceObserver hpo1 = new HousePriceObserver("瑞文");
    HousePriceObserver hpo2 = new HousePriceObserver("亚索");
    HousePriceObserver hpo3 = new HousePriceObserver("剑圣");

    // 给房子注册观察者
    house.addObserver(hpo1);
    house.addObserver(hpo2);
    house.addObserver(hpo3);

    // 修改房价,会触发update(Observable o, Object arg) 方法通知购房者新的房价信息;
    house.setPrice(2000000);    

    System.out.println("价格修改之后:" + house);
}

}
五.适配器设计模式
1.定义
如果一个类想要实现一个有很多抽象方法的接口,但是本身只需要实现接口中的部分方法就可以达成目的,因此,此时就需要一个中间过渡类。但此过渡类又不希望直接使用,因此将此过渡类定义为抽象类最为合适,再让以后的子类直接继承该抽象类便可以选择性覆盖所需要的方法,而此抽象类便是适配器类。

2.代码示例
[Java] 纯文本查看 复制代码
?

/aligninterface Window{

public void open();         // 窗口打开
public void close();        // 窗口关闭
public void iconified();    // 窗口最小化
public void deiconified();  // 窗口恢复
public void activated();    // 窗口活动

}

/*

  • 定义抽象类实现接口,在此类中重写方法,但是所有方法体为空

*/
abstract class WindowAdapter implements Window{

public void open() {            // 窗口打开     
}

public void close() {           // 窗口关闭     
}

public void iconified() {       // 窗口最小化        
}

public void deiconified() {     // 窗口恢复     
}

public void activated() {       

评论

暂无评论