什么是设计模式?(设计原则 + 模式)
对于设计人员,特别是开发人员吗,往往受限于眼界或经验不能够体会到设计原则的实用性,或者在处理具体问题时,不知道如何把设计原则应用到到设计和代码,因此产生了“模式”。
随着参与的项目越来越多,人们发现:很多问题并不是一个项目中出现的,它会在很多的项目中出现。于是人们就把这些问题总结出来,然后给出了解决这些问题的方案,而这些方案--"模式"(解决问题的套路)
设计模式的分类
人们总结出23种设计模式,通分为三大类:
1.创建模式:创建一些特殊的对象,或者在特殊要求下创建对象
2.结构模式:主要利用组合/聚合或者继承,让类与类能够形成某种关联关系--代理
3.行为模式:刻画了类和对象交换及分配职责的方式
在此,我会详讲六种
创建模式:单例模式、工厂模式、原型模式
结构模式:装饰器模式、适配器模式
行为模式:观察者模式
单例模式
在某些特殊情况下,我们创建的一个类,这个类只能产生一个对象
单例模式的实现方案:
1.饿汉模式
public class Singleton{
private Singleton(){}
private static Singleton sing = new Singleton();
public static Singleton getInstance(){
return sing;
}
}
2.懒汉模式(线程不安全、线程安全但效率低)
public class Singleton{
private Singleton(){}
public static synchronized Singleton getInstance(){
if(sing == null){
sing = new Singleton();
}
return sing;
}
}
3.双重检验模式(线程安全,且效率高的) 把锁的粒度变小,只锁第一次初始化时
public class Singleton{
private Singleton(){}
private static Singleton sing;
public static Singleton getInstance(){
if(sing == null){
synchronized(Singleton.class){
if(sing == null){
sing = new Singleton();
}
}
}
return sing;
}
}
4.内部类实现模式
public class Singleton{
private Singleton(){}
private static class Inner{
private static Singleton sing = new Singleton();
}
public static Singleton getInstance(){
return Inner.sing;
}
}
5.枚举实现
public class Singleton{
private Singleton(){}
private static enum SinEnum{
SIN;
private Singleton sing = new Singleton();
}
public static Singleton getInstance(){
return SinEnum.SIN.sing;
}
}
工厂模式
讲使用者和对象的生产者进行分离。
在工厂模式中,几乎都有三种角色,工厂(抽象工厂、具体工厂) 产品(抽象产品、具体产品) 使用者。使用者想要使用产品,不用自己去生产产品,把生产的动作交给工厂去做,使用者只需要从工厂提供产品的位置(方法)去拿就好。
1.简单工厂模式--顾客需要给出清单
变化点在产品对象上,所以我们会抽象产品,然后通过一个工厂,根据不同的情况产生不同的产品对象
定义一个生产接口
public interface Product {
public void play();
}
定义一个Phone实现Product接口
public class Phone implements Product{
@Override
public void play() {
System.out.println("play phone");
}
}
定义一个Pad实现Product接口
public class Pad implements Product{
@Override
public void play() {
System.out.println("play Pad");
}
}
定义工厂实体类
public class Factory {
public Product getProduct(String type){
if(type == null){
return null;
}
if(type.equals("Phone")){
System.out.println("生产 Phone");
return new Phone();
}else if(type.equals("Pad")){
System.out.println("生产 Pad");
return new Pad();
}
return null;
}
}
一个测试类,模仿顾客
/**
* 顾客
*/
public class Test {
public static void main(String[] args) {
Factory factory = new Factory();
// 需要一个手机,只需告知给工厂即可,不用管任何的细节,屏蔽了具体的实现
Product phone = factory.getProduct("Phone");
Product Pad = factory.getProduct("Pad");
Product no = factory.getProduct(null);
phone.play();
Pad.play();
System.out.println(no);
}
}
2.工厂方法模式--根据工厂能产生什么顾客拿什么
工厂可以产生统一品牌的商品,会根据商品去抽象工厂,对每一个产品,提供一个工厂实现类
定义一个生产接口
public interface Product {
public void play();
}
定义一个工厂接口
/**
* 抽象工厂
*/
public interface Factory {
/** 方法返回值 抽象产品 */
public Product create();
}
两个产品 Phone、Pad(实现Product接口)
public class Pad implements Product{
@Override
public void play() {
System.out.println("Pad play");
}
}
public class Phone implements Product{
@Override
public void play() {
System.out.println("Phone play");
}
}
两个工厂类 PadFactory、PhoneFactory(实现Factory接口)
public class PadFactory implements Factory {
@Override
public Product create() {
System.out.println("生产 Pad");
return new IPad();
}
}
public class PhoneFactory implements Factory{
@Override
public Product create() {
System.out.println("生产 Phone");
return new Phone();
}
}
一个测试类,模仿顾客
/**
* 顾客
*/
public class Test {
public static void main(String[] args) {
Factory factory = new PhoneFactory();
Factory factory1 = new PadFactory();
Product phone = factory.create();
Product Pad = factory1.create();
phone.play();
pad.play();
}
}
3.抽象工厂模式--根据工厂能产生什么顾客拿什么,但是工厂能产生的产品会有多种品牌
超级工厂,可以生产不同品牌的各种产品,抽象出超级工厂,也要抽象出产品,然后根据不同的品牌给出该品牌商品的工工厂实现类
定义一个工厂接口
public interface Factory {
public Phone productPhone();
}
定义一个Phone接口
public interface Phone {
public void call();
}
定义两个工厂实体类(HuaweiFactory、AppleFactory)实现工厂接口
public class HuaweiFactory implements Factory{
@Override
public Phone productPhone() {
System.out.println("生产 华为 Phone");
return new HuaweiPhone();
}
}
public class AppleFactory implements Factory{
@Override
public Phone productPhone() {
System.out.println("生产IPhone");
return new ApplePhone();
}
}
定义两个产品(HuaweiPhone、ApplePhone)实现Phone接口
public class HuaweiPhone implements Phone{
@Override
public void call() {
System.out.println("使用4GHuawei手机打电话");
}
}
一个测试类,模仿顾客
public class Test {
public static void main(String[] args) {
Factory factory;
Phone phone;
factory = new HuaweiFactory();
phone = factory.productPhone();
phone.call();
factory = new AppleFactory();
phone = factory.productPhone();
phone.call();
}
}
注意:
三种工厂模式(简单工厂、工厂方法模式、抽象工厂模式)的区别:
简单工厂:
角色:工厂、抽象产品、具体产品
特点:是由一个工厂决定生产产品实例
工厂方法模式:
角色:抽象工厂、抽象产品、具体产品
特点:每一个产品都要有一个相应的工厂类,但不会对整体代码结构进行修改
抽象工厂模式
角色:抽象工厂、抽象产品、具体产品
特点:每个产品使用一个具体工厂来生产。每个具体工厂使用多个工厂方法生成对应的多个产品。然后,抽象出一个抽象工厂类提供接口对客户。
如何区分:
假设有一个工厂,可以生产各种型号的手机(同一品牌)(简单工厂或工厂方法)
如果客户在取手机时,需要提供手机的型号---简单工厂
如果客户在取手机是,不需要提供手机型号,按照工厂的规范生产--工厂方法
如果工厂不仅可以生产各种型号的手机,还可生产不同品牌的--抽象工厂(和工厂方法一样,根据自己建厂的规范生产产品)
原型模式
根据一个已经存在的对象,创建一个和他一样的对象--- 克隆
浅克隆---利用Object中clone()实现
1.让被克隆的类实现Cloneable接口
2.重写clone方法,方法访问修饰符public
3.对象.clone()的方式的到一个一样的对象
浅克隆指,被克隆的对象会产生一个新的,但是对象属性不会产生。
深度克隆
1.克隆对象所涉及的自定义类,需要实现序列化接口
2.在需要克隆的类中,添加一个方法,完成序列化反序列化即可。
举个例子:
定义一个Car类
public class Car implements Serializable {
}
定义一个Person类
public class Person implements Serializable,Cloneable {
private String name;
public Car car=new Car();
//浅度克隆
public Person ligntClone() throws CloneNotSupportedException {
Object obj=super.clone();
return (Person) obj;
}
//深度克隆
public Person deepClone() throws IOException, ClassNotFoundException {
ByteArrayOutputStream bo=new ByteArrayOutputStream();
ObjectOutputStream objout=new ObjectOutputStream(bo);
objout.writeObject(this);
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream objin=new ObjectInputStream(bi);
Object obj=objin.readObject();
return (Person) obj;
}
}
测试一下:
public class Test {
public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
Person person = new Person();
Person p1 = person.ligntClone();
Person p2 = person.deepClone();
System.out.println(person == p1);//结果为false
System.out.println(person.car == p1.car);//结果为true
System.out.println(person==p2);//结果为false
System.out.println(person.car==p2.car);//结果为false
}
}
装饰器模式
对象功能的扩展能够根据需要来动态地实现。
生活场景:星巴克的分店几乎开遍世界各地。它们提供了各式各样的美味咖啡:爱尔兰咖啡、蓝山咖啡、卡布基诺、雀巢。每样咖啡都有自己的描述属性和收费行为。另外它们还提供各种配料:奶、砂糖、冰块、豆浆。不同的咖啡加入不同的配料计算的价格是不一样的。
class Coffee{} // 咖啡父类
class ACoffee extends Coffee{} // 爱尔兰
class BCoffee extends Coffee{} // 蓝山
class KCoffee extends Coffee{} // 卡布基洛
class ACoffeeSuger extends ACoffee{} // 爱尔兰 加糖
class ACoffeeMilk extends ACoffee{} // 爱尔兰 奶
class ACoffeeSugerMilk extends ACoffeeSuger{} // 爱尔兰 加糖 加奶
class ACoffeeSugerDoubleMilk extends ACoffeeSugerMilk{} // 爱尔兰 加糖 加双倍奶
class BCoffeeSuger extends BCoffee{}// 蓝山 加糖
1.根据对象抽象一个公共的接口
2.根据接口给出不同的实现类(主料类(主料类产生的对象就是被装饰的对象) 和 配料类--装饰类)
3.在配料类中注入被装饰的对象
4.生产咖啡时,先生产主料(被修饰的对象),然后用配料不断去修饰主料
interface Stuff{ getName getPrice}
class ACoffee implements Stuff{} // 爱尔兰
class BCoffee implements Stuff{} // 蓝山
class KCoffee implements Stuff{} // 卡布基洛
class Suger implements Stuff{ 注入主料对象 } // 糖
class Milk implements Stuff{ 注入主料对象 } // 牛奶
class Ice implements Stuff{ 注入主料对象 } // 冰块
// 爱尔兰 加糖 加奶
Stuff coffee = new ACoffee();// 爱尔兰
Stuff coffeeAddSuger = new Suger(coffee); // 爱尔兰 加糖
Stuff coffeeAddSugerAndMilk = new Milk(coffeeAddSuger);// 爱尔兰 加糖 加奶
适配器模式
使得原本不兼容的两个接口(功能)可以兼容--搭建了两个接口间的桥梁
假如:我们现在有一台座机,可以通话,有一个照相机,可以进行拍照,能不能有一台设备把两者的功能合一呢?
class Tel{
public void call(){}
}
class Carame{
public void make(){}
}
class Phone extends Tel{
private Carame c = new Carame();
public void make(){
c.make();
}
}
实现适配器的方案,继承或者依赖(推荐使用)
优点:可以让没有任何关联的类,一起运行;
提高了类的复用
灵活性好
缺点:过多的使用适配器,会导致系统非常混乱,不容具体把控
java是单继承,
观察者模式
A球队(青年天才) 其他球队都对这个天才垂涎欲滴,都会派出球探观察青年天才的表现,根据它的表现决定球队,应该出多少钱买入该天才。在某一次比赛中,它面对一个传统豪强(强队),世界级的变现(帽子戏法+助攻帽子戏法),6-3大胜
生活场景:多个代理商代理同一个厂家的商品。不同代理商会在厂家出厂价基础上加上自己的利润,成为批发价。当商品的厂价发生变化时,不同代理商品的价格随之变化。
主题类(由它产生的对象 就是 被观察的对象) 继承 Observable的类
在主题类,需要针对主题(价格的变化进行关注,设置变化点,然后通知观察者价格有了变化)
public class Product extends Observable {
private double price;
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
// 通知观察者注意到主题的变化
this.setChanged();// 设置变化点
this.notifyObservers(price);//通知观察者
}
}
观察者类(由它产生的对象 就是 观察者) 实现Observer接口
重写update(当主题发生变化时,会调用方法)
public class ProductProxy1 implements Observer {
private double price;
/**
* 当主题类的值发生变化后,会调用该方法
* @param o 主题对象
* @param arg 主题更新的值对象
*/
@Override
public void update(Observable o, Object arg) {
double factoryPrice = (double) arg;
this.price = factoryPrice * 1.5;
}
public double getPrice() {
return price;
}
}
首先产生主题对象(被观察对象),产生观察者对象,然后给主题对象设置观察者,最后通过更改主题的值,测试观察者是否有观测到主题值的改变
public class Test {
public static void main(String[] args) {
// 产生主题对象 -- 被观察者
Product product = new Product();
// 产生观察者
ProductProxy1 p1 = new ProductProxy1();
// 给主题对象添加观察者
product.addObserver(p1);
// 主题发生变化
product.setPrice(1000);
System.out.println("出厂价格:"+ product.getPrice() +
"\n代理商售卖价格:" + p1.getPrice());
// 主题发生变化
product.setPrice(2000);
System.out.println("出厂价格:"+ product.getPrice() +
"\n代理商售卖价格:" + p1.getPrice());
}
}
以上就是我向大家介绍的六种设计模式,谢谢阅读!栓q~~