设计模式(Design pattern):优秀经验的总结
1:设计模式分类:
1.1 创建型模式;
对象的创建,主要包括:简单工厂模式;工厂方法模式;抽象工厂模式;建造者模式;原型模式;单例模式
1.1.1 简单工厂模式
又叫静态工厂方法模式,定义一个专门创建对象的工厂类.
优点:明确了类的职责,客户端不需要在负责对象的创建
缺点:静态工厂类负责所有对象的创建,如果有新的对象增加,需要不断修改工厂类,不利于维护.
package d12; public abstract class Animal { public abstract void eat(); }
package d12; public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃肉!"); } }
package d12; public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼!"); } }
package d12; public class AnimalFactory { public static Animal createAnimal(String animalType) { if ("dog" == animalType) { return new Dog(); } else if ("cat" == animalType) { return new Cat(); } //缺点:如果增加其他动物的话,需要不断修改该工具类 return null; } }
package d12; public class SimpleFactoryTest { public static void main(String[] args) { // 1.0 普通调用 Dog d = new Dog(); d.eat(); /*输出结果 *狗吃肉! *? */ //2.0 创建简单工厂类,用于对象的创建 Animal c = AnimalFactory.createAnimal("cat"); if (d!=null) { c.eat(); } /*输出结果 *猫吃鱼! *? */ } }
1.1.2 工厂方法模式
抽象工厂类负责定义创建对象的接口,具体对象的创建工作有继承抽象工厂类的具体类实现
优点:与 简单工厂类相比,如果有新的对象增加,只需要增加一个具体的类和具体的工厂类即可,扩展性强
缺点:增加代码量
package d12; public abstract class Animal { public abstract void eat(); }
package d12; public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃肉!"); } }
package d12; public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼!"); } }
package d12; public interface Factory { public abstract Animal createAnimal(); }
package d12; public class DogFactory implements Factory { @Override public Animal createAnimal() { return new Dog(); } }
package d12; public interface FactoryMethodTest { public static void main(String[] args) { Factory f = new DogFactory(); Animal a = f.createAnimal(); a.eat(); } }
1.1.3 单例模式
确保类在内存中只有一个对象,该类必须自动实现,并且对外提供
优点:在内存中只有一个对象
缺点:扩展性差
package d12; //01 构造方法私有化 //02 自己创建对象 //03 对外界提供 public class Student { //单利模式--饿汉式 private Student() {} //02 自己创建 ,为了让外界直接访问加static,为了让外界不能修改添加private private static Student s = new Student(); //03 对外界提供 public static Student getStudent() { return s; } }
package d12; //01 构造方法私有化 //02 自己创建对象 //03 对外界提供 public class Student { //单利模式--懒汉式 private Student() {} //02 自己创建 ,为了让外界直接访问加static,为了让外界不能修改添加private private static Student s = null; //03 对外界提供 public static Student getStudent() { if (s==null) { s = new Student(); } return s; } }
懒汉式存在线程安全问题
解决方法,添加同步
1.2 结构型模式;
对象的组成结构,主要包括:外观模式;适配器模式;代理模式;装饰模式;桥接模式;组合模式;享元模式
1.2.1 适配器模式
两个不兼容的接口之间的桥梁.
优点:灵活性好
缺点:过多地使用适配器，会让系统非常零乱，不易整体进行把握
场景:接口(方法比较多) == 适配器(实现接口,仅仅是空实现)==实现类(实现其中的某个或部分方法)
package d12; public interface UserDao { void add(); void delete(); void update(); void select(); }
package d12; public abstract class UserAdapter implements UserDao { @Override public void add() { } @Override public void delete() { } @Override public void update() { } @Override public void select() { } }
package d12; public class UserDaoImpl extends UserAdapter { @Override public void add() { // TODO Auto-generated method stub System.out.println("添加方法!"); } }
package d12; public class UserDaoTest { public static void main(String[] args) { // TODO Auto-generated method stub UserDao ud = new UserDaoImpl(); ud.add(); } }
1.2.2 装饰模式
package d12; public abstract class Phone { //手机类 的子类中都有Call方法 public abstract void call(); }
package d12; public class Huawei extends Phone { @Override public void call() { System.out.println("华为手机:可以打电话"); } }
package d12; public abstract class PhoneDecorate extends Phone { private Phone p; public PhoneDecorate(Phone p) { this.p = p; } @Override public void call() { p.call(); } }
package d12; public class RingDecorate extends PhoneDecorate { public RingDecorate(Phone p) { super(p); // TODO Auto-generated constructor stub } @Override public void call() { System.out.println("彩铃装饰"); super.call(); } }
package d12; public class MusicDecorate extends PhoneDecorate { public MusicDecorate(Phone p) { super(p); } @Override public void call() { super.call(); System.out.println("音乐装饰"); } }
package d12; import java.io.BufferedReader; import java.io.InputStreamReader; public class PhoneTest { public static void main(String[] args) { // TODO Auto-generated method stub Huawei hw = new Huawei(); PhoneDecorate rd = new RingDecorate(hw); rd.call(); /*输出结果 彩铃装饰 华为手机:可以打电话 */ //同理 添加听音乐装饰 PhoneDecorate md = new MusicDecorate(hw); md.call(); /*输出结果 华为手机:可以打电话 音乐装饰 */ //注意 同时装饰两个 彩铃+音乐 //new MusicDecorate(hw) 继承自PhoneDecorate 继承自Phone PhoneDecorate mwd = new RingDecorate(new MusicDecorate(hw)); mwd.call(); /*输出结果 彩铃装饰 华为手机:可以打电话 音乐装饰 */ //这种用法 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); } }
1.3 行为型模式
对象的行为,主要包括:模板设计模式;观察者模式;状态模式;职责链模式;命令模式;访问者模式;策略模式;备忘录模式;迭代器模式;解释器模式
1.3.1 模板设计模式
定义一个算法的骨架,而将具体的算法延迟到子类中来实现
优点:灵活多改变
缺点:如果算法骨架有修改的话,需要修改抽象类
package d12; public abstract class GetTime { public long getTime() { long startTime = System.currentTimeMillis(); code(); long endTime = System.currentTimeMillis(); return endTime-startTime; } public abstract void code(); }
package d12; import java.util.Iterator; public class GetTimeDemo extends GetTime { @Override public void code() { for (int i = 0; i < 100000; i++) { System.out.println(i); } } }
package d12; public class GetTimeTest { public static void main(String[] args) { GetTime d =new GetTimeDemo(); System.out.println("用时: "+d.getTime()+"毫秒"); } }
