JavaSE学习笔记---设计模式：外观、单例、简单工厂

于 2018-03-15 09:27:08 发布
阅读量168 收藏
点赞数
分类专栏： JavaSE 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yinhao7700/article/details/79563157
版权
设计模式：23种，按照一定的规范设计程序
外观模式：
    通过简易的外观，将我们复杂的内部结构，呈现在我们面前（面向对象的思想）
    电脑主机是电脑的外观
    建筑的外墙是建筑的外观
    例子1：
        旅游（自驾游）：
            1、规划路线
            2、订酒店
            3、订票
        旅游（旅行社）：
            出钱
            （ 1、规划路线
                2、订酒店
                3、订票）
    例子2：
         家里每个房间的电源开关------总闸
单例模式：在任何情况下只有一个对象实例
     特点：
        1、单例类只能有一个实例
        2、单例必须自己创建对象
        3、单例类需要对外提供该对象
     分类：
    饿汉式：
        1、将构造方法私有化
        2、在本类声明创建一个自己的对象
        3、提供一个公共 静态的方法，返回该对象
public class HungryUser {
        //2、在本类声明创建一个自己的对象
        private static HungryUser hungryUser = new HungryUser();
       
        //1、将构造方法私有化
        private HungryUser() {
             
       }
       
        //3、提供一个公共静态的方法，返回该对象
        public static HungryUser getInstance() {
              return hungryUser ;
       }
}
  
   懒汉式：
        1、将构造方法私有化
        2、声明单例对象（不初始化）
        3、提供一个 加锁了的公共 静态的方法。判断对象实例是否存在：存在，直接返回。不存在，创建返回。

public class LazyUser {
        //2、声明单例对象（不初始化）
        private static LazyUser lazyUser = null ;
       
        //1、将构造方法私有化
        private LazyUser() {
             
       }
       
        //3、提供一个加锁了的公共静态的方法。判断对象实例是否存在：存在，直接返回。不存在，创建返回。
        public synchronized static LazyUser getInstance() {
              if ( lazyUser == null ) {
                     lazyUser = new LazyUser();
             }
              return lazyUser ;
       }
}

经验之谈： 一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。

简单工厂模式：
    为不同的子类提供一个公共的出口，具体需要哪个子类对象，由用户决定。
    知识点：面向对象的多态和继承
    例子：我发达了，我想买狗、买猫、买鸟。分别去狗市场、猫市场、鸟市场分别购买。
               工厂模式：弄一个动物市场，直接购买

装饰者模式：不改变原有类功能的情况下 实现对其功能的加强或者新增。通过构造方法实现增强。
    IO流：利用装饰者模式设计
        字节流：InputStream OutputStream
public abstract class Hero {
        static int gjl = 1;
        static int fq = 1;
        static int hj = 1;
        static int mk = 1;
        public abstract void heroInfo();
}
//英雄
public class LolHero extends Hero{
        @Override
        public void heroInfo() {
             System. out .println( "攻击力：" + super . gjl + "法强：" + super . fq + "护甲：" + super . hj + "魔抗：" + super . mk );
       }
}
//装备
public class LolHeroZb extends Hero {
        private Hero hero ;
        public LolHeroZb(Hero hero ) {
              this . hero = hero ;
       }
        @Override
        public void heroInfo() {
              // TODO Auto-generated method stub
       }
}
//装备：帽子
public class Mz extends LolHeroZb{
        public Mz(Hero hero ) {
              super ( hero );
              super . fq += 3;
             addFq( super . fq );
       }
        public void addFq( int fq ){
             System. out .println( "装备帽子以后法强提高为：" + fq );
             System. out .println( "攻击力：" + super . gjl + "法强：" + super . fq + "护甲：" + super . hj + "魔抗：" + super . mk );
       }
}
//武器：无尽
public class Wj extends LolHeroZb{
        public Wj (Hero hero ) {
              super ( hero );
              super . gjl += 2;
             addGjl( super . gjl );
       }
        public void   addGjl( int gjl ){
             System. out .println( "装备无尽以后攻击力提高为：" + gjl );
             System. out .println( "攻击力：" + super . gjl + "法强：" + super . fq + "护甲：" + super . hj + "魔抗：" + super . mk );
       }
}
public class Test {
        public static void main(String[] args ) {
             LolHero hero = new LolHero();
              hero .heroInfo();
              //装备：帽子
             Mz mz = new Mz( hero );
              //武器：无尽
             Wj wj = new Wj( hero );
       }
}

观察者模式：
观察者：天气App：实现接口，即实现具体的新消息处理方法。
被观察者（主题）：气象台：提供注册方法，得到所有实现了接口的观察者，当变化时，调用所有注册了的观察者的接口方法。

使用API：
//被观察者
public class WeatherStation extends Observable{
        private String data ;
        public WeatherStation() {
             System. out .println( "气象台开始获取数据。。。请等待2S" );
              new Thread( new MyRunnable()).start();
       }
        public class MyRunnable implements Runnable {
              @Override
              public void run() {
                     try {
                           Thread. sleep (2000);
                    } catch (InterruptedException e ) {
                            // TODO Auto-generated catch block
                            e .printStackTrace();
                    }
                    System. out .println( "气象台获取成功，开始推送" );
                     data = "今天天气：阴 -1°" ;
                    setChanged();
                    notifyObservers();
             }      
       }
        public String getData() {
              return data ;
       }
        public void setData(String data ) {
              this . data = data ;
       }
}
//观察者
public class AppWeather implements Observer {
        private String name ;
        public AppWeather(Observable observable , String name ) {
              observable .addObserver( this );
              this . name = name ;
//           System.out.println(name + "启动");
       }
        @Override
        public void update(Observable o , Object arg ) {
             System. out .println( name + "提示" + ((WeatherStation) o ).getData());
       }
}
public class Main {
        public static void main(String[] args ) {
              // TODO Auto-generated method stub
             WeatherStation weatherStation = new WeatherStation();
             AppWeather appWeather1 = new AppWeather( weatherStation , "墨迹天气" );
             AppWeather appWeather2 = new AppWeather( weatherStation , "百度天气" );
             AppWeather appWeather3 = new AppWeather( weatherStation , "苹果天气" );
       }
}

使用接口：
public interface LightListener {
        void onLightChanged(String data );
}
//被观察者
public class TrafficLight {
        private ArrayList<LightListener> listeners ;
        public TrafficLight() {
              listeners = new ArrayList<LightListener>();
             System. out .println( "当前为红灯，停车等待2S" );
              new Thread( new MyRunnable()).start();
       }
        public void subscribe(LightListener listener ) {
              listeners .add( listener );
       }
        public class MyRunnable implements Runnable{
              @Override
              public void run() {
                     try {
                           Thread. sleep (2000);
                    } catch (InterruptedException e ) {
                            // TODO Auto-generated catch block
                            e .printStackTrace();
                    }
                    System. out .println( "变绿灯了， GO GO GO" );
                     for (LightListener lightListener : listeners ) {
                            lightListener .onLightChanged( "Go" );
                    }
             }
             
       }
}
//观察者
public class Car implements LightListener{
        private String name ;
        public Car(String name ) {
              super ();
              this . name = name ;
       }
        @Override
        public void onLightChanged(String data ) {
             System. out .println( name + data );
       }
}
public class Main {
        public static void main(String[] args ) {
             TrafficLight trafficLight = new TrafficLight();
              trafficLight .subscribe( new Car( "兰博基尼" ));
              trafficLight .subscribe( new Car( "玛莎拉蒂" ));
              trafficLight .subscribe( new Car( "凯迪拉克" ));
       }
}

事了
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值