A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

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

懒汉式线程安全,但是效率非常低
[Java] 纯文本查看 复制代码
[/align][align=left]class SingletonTest03{
    private static SingletonTest03 instance;
    private SingletonTest03(){

    }
    public static synchronized SingletonTest03 getInstance(){
        if(instance == null){
            instance = new SingletonTest03();
        }
        return instance;
    }
}
懒汉式线程安全,并且效率高
[Java] 纯文本查看 复制代码
[/align][align=left]class 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] 纯文本查看 复制代码
[/align][align=left]interface 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] 纯文本查看 复制代码
[/align][align=left]interface 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] 纯文本查看 复制代码
[/align][align=left]class 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] 纯文本查看 复制代码
[/align][align=left]interface 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() {       
    }

}

/*
 * 子类继承WindowAdapter抽象类,选择性实现需要的方法
 */
class WindowImpl extends WindowAdapter{
    public void open(){
        System.out.println("窗口打开!");
    }
    public void close(){
        System.out.println("窗口关闭!");
    }
}

public class AdapterDemo01 {
    public static void main(String[] args) {[/align][align=left]
        Window win = new WindowImpl();[/align][align=left]
        win.open();[/align][align=left]
        win.close();
    }
}

评分

参与人数 1黑马币 +1 收起 理由
yuanhai + 1 赞一个!

查看全部评分

2 个回复

倒序浏览
奈斯
回复 使用道具 举报

很不错,受教了
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马