您的位置:首页 > 编程语言 > Java开发

java 23种设计模式详解01-02-03-工厂

qq_37183998 2017-11-17 12:56 183 查看

java 23种设计模式详解01-02-03-工厂模式

一、设计模式的理解

      把很简单的东西搞得那么复杂。“复杂”恰恰就是设计模式的精髓所在,简单的设计意味着缺少灵活性,代码很钢硬,只在这个项目里有用,拿到其它的项目中就是垃圾,我将其称之为“一次性代码”。

二、设计模式的分类

总体来说设计模式分为三大类:

创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

其实还有两类:并发型模式和线程池模式

三、设计模式的六大原则

1、开闭原则(Open Close Principle)

         开闭原则就是说对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。

2、里氏代换原则(Liskov Substitution Principle)

        里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。 LSP是继承复用的基石,只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。——
From Baidu 百科

3、依赖倒转原则(Dependence Inversion Principle)

      这个是开闭原则的基础,具体内容:真对接口编程,依赖于抽象而不依赖于具体。

4、接口隔离原则(Interface Segregation Principle)

        这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。还是一个降低类之间的耦合度的意思,从这儿我们看出,其实设计模式就是一个软件的设计思想,从大型软件架构出发,为了升级和维护方便。所以上文中多次出现:降低依赖,降低耦合。

5、迪米特法则(最少知道原则)(Demeter Principle)

       为什么叫最少知道原则,就是说:一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。

6、合成复用原则(Composite Reuse Principle)

     脚下留心:  原则是尽量使用合成/聚合的方式,而不是使用继承。

如图:

cb23



01简单工厂模式

一、什么是简单工厂模式

       简单工厂模式属于类的创建型模式,又叫做静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。

二、模式中包含的角色及其职责

1.工厂(Creator)角色

简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用,创建所需的产品对象。

2.抽象(Product)角色

简单工厂模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。

3.具体产品(Concrete Product)角色

简单工厂模式所创建的具体实例对象。

三、简单工厂模式的优缺点

        在这个模式中,工厂类是整个模式的关键所在。它包含必要的判断逻辑,能够根据外界给定的信息,决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例,而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。不难发现,简单工厂模式的缺点也正体现在其工厂类上,由于工厂类集中了所有实例的创建逻辑,所以“高内聚”方面做的并不好。另外,当系统中的具体产品类不断增多时,可能会出现要求工厂类也要做相应的修改,扩展性并不很好。

代码下载地址:链接:百度云地址 密码:fsy3

代码:

public class Apple implements Fruit{
/*
* 实现类
* 采集
*/
@Override
public void get(){
System.out.println("采集苹果");
}
}
public class Banana implements Fruit{
/*
* 实现类
* 采集
*/
@Override
public void get(){
System.out.println("采集香蕉");
}
}
public interface Fruit {
/*
* 采集
*/
public void get();
}
public class FruitFactory {
//	/*
//	 * 获得Apple类的实例
//	 */
//	public static  Fruit getApple() {
//		return new Apple();
//	}
//
//	/*
//	 * 获得Banana类实例
//	 */
//	public static Fruit getBanana() {
//		return new Banana();
//	}
/*
* get方法,获得所有产品对象
*/
public static Fruit getFruit(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
//		if(type.equalsIgnoreCase("apple")) {
//			return Apple.class.newInstance();
//
//		} else if(type.equalsIgnoreCase("banana")) {
//			return Banana.class.newInstance();
//		} else {
//			System.out.println("找不到相应的实例化类");
//			return null;
//		}
Class fruit = Class.forName(type);
return (Fruit) fruit.newInstance();

}
}

public class MainClass {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
//		//实例化一个Apple
//		Apple apple = new Apple();
//		//实例化一个Banana
//		Banana banana = new Banana();
//
//		apple.get();
//		banana.get();

//		//实例化一个Apple,用到了多态
//		Fruit apple = new Apple();
//		Fruit banana = new Banana();
//		apple.get();
//		banana.get();

//		//实例化一个Apple
//		Fruit apple = FruitFactory.getApple();
//		Fruit banana = FruitFactory.getBanana();
//		apple.get();
//		banana.get();

Fruit apple = FruitFactory.getFruit("Apple");
Fruit banana = FruitFactory.getFruit("Banana");
apple.get();
banana.get();

}
}

02工厂方法模式

一、什么是工厂方法模式
     工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类必须实现的接口,这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
二、模式中包含的角色及其职责  
1.抽象工厂(Creator)角色 工厂方法模式的核心,任何工厂类都必须实现这个接口。2.具体工厂( Concrete  Creator)角色 具体工厂类是抽象工厂的一个实现,负责实例化产品对象。3.抽象(Product)角色 工厂方法模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。4.具体产品(Concrete Product)角色 工厂方法模式所创建的具体实例对象
三、工厂方法模式和简单工厂模式比较
  工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类,而简单工厂模式把核心放在一个具体类上。工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口,或者有共同的抽象父类。当系统扩展需要添加新的产品对象时,仅仅需要添加一个具体对象以及一个具体工厂对象,原有工厂对象不需要进行任何修改,也不需要修改客户端,很好的符合了“开放-封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法,扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。

代码地址:链接:百度云下载密码:7js5

代码:

public class Apple implements Fruit{
/*
* 采集
*/
public void get(){
System.out.println("采集苹果");
}
}
public class AppleFactory implements FruitFactory {

public Fruit getFruit() {
return new Apple();
}

}
public class Banana implements Fruit{
/*
* 采集
*/
public void get(){
System.out.println("采集香蕉");
}
}
public class BananaFactory implements FruitFactory {

public Fruit getFruit() {
return new Banana();
}

}
public interface FruitFactory {
public Fruit getFruit();
}
public interface Fruit {
/*
* 采集
*/
public void get();
}

public class MainClass {
public static void main(String[] args) {
//获得AppleFactory
FruitFactory ff = new AppleFactory();
//通过AppleFactory来获得Apple实例对象
Fruit apple = ff.getFruit();
apple.get();

//获得BananaFactory
FruitFactory ff2 = new BananaFactory();
Fruit banana = ff2.getFruit();
banana.get();

//获得PearFactory
FruitFactory ff3 = new PearFactory();
Fruit pear = ff3.getFruit();
pear.get();
}
}
public class Pear implements Fruit {

public void get() {
System.out.println("采集梨子");
}

}
public class PearFactory implements FruitFactory {

public Fruit getFruit() {
return new Pear();
}
}

03抽象工厂模式

一、什么是抽象工厂模式
     抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口,使得客户端在不必指定产品的具体类型的情况下,能够创建多个产品族的产品对象。
二、产品族和产品等级结构

二、模式中包含的角色及其职责
1.抽象工厂(Creator)角色 抽象工厂模式的核心,包含对多个产品结构的声明,任何工厂类都必须实现这个接口。
2.具体工厂( Concrete  Creator)角色 具体工厂类是抽象工厂的一个实现,负责实例化某个产品族中的产品对象。
3.抽象(Product)角色 抽象模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。
4.具体产品(Concrete Product)角色 抽象模式所创建的具体实例对象
总结:抽象工厂中方法对应产品结构,具体工厂对应产品族。

代码地址:链接:百度云下载 密码:vsbn

代码:

public abstract class Apple implements Fruit{
/*
* 采集
*/
public abstract void get();
}
public abstract class Banana implements Fruit{
/*
* 采集
*/
public abstract void get();
}

public interface Fruit {
/*
* 采集
*/
public void get();
}
public interface FruitFactory {
//实例化Apple
public Fruit getApple();
//实例化Banana
public Fruit getBanana();
}
public class NorthApple extends Apple {

public void get() {
System.out.println("采集北方苹果");
}

}
public class NorthBanana extends Banana {

public void get() {
System.out.println("采集北方香蕉");
}

}

public class NorthFruitFactory implements FruitFactory {

public Fruit getApple() {
return new NorthApple();
}

public Fruit getBanana() {
return new NorthBanana();
}

}
public class SouthApple extends Apple {

public void get() {
System.out.println("采集南方苹果");
}

}
public class SouthBanana extends Banana {

public void get() {
System.out.println("采集南方香蕉");
}

}

public class SouthFruitFactory implements FruitFactory {

public Fruit getApple() {
return new SouthApple();
}

public Fruit getBanana() {
return new SouthBanana();
}

}
public class MainClass {
public static void main(String[] args) {
FruitFactory ff = new NorthFruitFactory();
Fruit apple = ff.getApple();
apple.get();

Fruit banana = ff.getBanana();
banana.get();

FruitFactory ff2= new SouthFruitFactory();
Fruit apple2 = ff2.getApple();
apple2.get();

Fruit banana2 = ff2.getBanana();
banana2.get();

FruitFactory ff3 = new WenshiFruitFactory();
Fruit apple3 = ff3.getApple();
apple3.get();

Fruit banana3 = ff3.getBanana();
banana3.get();
}
}
public class WenshiApple extends Apple {

public void get() {
System.out.println("采集温室苹果");
}

}
public class WenshiBanana extends Banana {

public void get() {
System.out.println("采集温室香蕉");
}

}

public class WenshiFruitFactory implements FruitFactory {

public Fruit getApple() {
return new WenshiApple();
}

public Fruit getBanana() {
return new WenshiBanana();
}

}


未完待续。。。。






                                            
标签: