Hello
回顾: 面向对象设计的基本原则
1.OCP(开闭原则): 一个应用的实体对扩展开放,对修改关闭.(白话: 现在我有两个类构建一个功能,如果想要扩展新功能的话,根据原则是不要在原有的两个类上做修改,重新新建一个类来完成新加的功能)
2.DIP(依赖反转原则): 要针对接口编程,不要针对实现编程(白话: A实现类调用B实现类,具体关系,根据原则B类应当实现接口C类,然后A类与C类发生关系,将具体关系转为抽象依赖)
3.LoD(迪米特法则): 只与朋友通信.(白话: 该法则的初衷在于降低对象之间的耦合,减少类和类的直接关系,功能的复用,模块独立化...更多信息[百度,gooale]查阅)
附加: 耦合类型,由高到低 ↓↓↓
- 内容耦合: 当一个模块直接修改或操作另一个模块的数据时,或一个模块不通过正常入口而转入另一个模块时,该耦合是最高程度的耦合,应该避免使用之
- 公共耦合: 两个及以上的模块共同引用一个全局数据项为公共耦合
- 外部耦合: 一组模块都访问同一全局简单变量而不是同一全局数据结构,而且不是通过参数表传递该全局变量的信息,为外部耦合
- 控制耦合: 一个模块通过接口向另一个模块传递一个控制信号,接受信号的模块根据信号值而进行适当的动作,为控制耦合
- 标记耦合: 若一个模块A通过接口向两个模块B和C传递一个公共参数,那么称模块B和C之间存在一个标记耦合
- 数据耦合: 模块之间通过参数来传递数据,为数据耦合.数据耦合是最低的一种耦合形式,系统中都存在这种类型的耦合,因为为了完成一些有意义的功能,往往需要将某些模块的输出数据作为另一些模块的输入数据
- 非直接耦合: 两个模块之间没有直接关系,它们之间的联系完全是通过主模块的控制和调用来实现的
工厂模式
实现创建和调用的分离, 将选择实现类、创建对象统一管理和控制.
三种工厂模式:
简单工厂
创建同一结构类型的任何对象,对于新增的对象,需要修改已有代码
创建一个接口Dog
public interface Dog { void ability(); }
创建三种Dog,直接上真名了
public class 中华田园犬 implements Dog {
@Override
public void ability() {
System.out.println("中华田园犬: 什么都能吃,听话,好养,能力强");
}
}
public class 哈士奇 implements Dog {
@Override
public void ability() {
System.out.println("哈士奇: 吃荤吃素还不知道,这种狗的能力大家都知道");
}
}
public class 哈巴狗 implements Dog {
@Override
public void ability() {
System.out.println("哈巴狗: 大眼憨厚,听话好使");
}
}
创建工厂类
public class FactoryZone {
//第一种方式
public static Dog factoryForDog(String type){
Dog dog=null;
if (type.equals("中华田园犬")){
dog=new 中华田园犬();
}else if (type.equals("哈士奇")){
dog=new 哈士奇();
}else if (type.equals("哈巴狗")){
dog=new 哈巴狗();
}
//新增的话,需要在此处追加.
return dog;
}
//第二种方式
public Dog get中华田园犬(){
return new 中华田园犬();
}
public Dog get哈士奇(){
return new 哈士奇();
}
public Dog get哈巴狗(){
return new 哈巴狗();
}
}
测试 FactoryMain
public class FactoryMain { public static void main(String[] args) { //无工厂模式,这种情况下FactoryMain依赖Dog接口以及中华田园犬类,哈士奇类,哈巴狗类 Dog dog=new 中华田园犬(); dog.ability(); Dog dog1=new 哈士奇(); dog1.ability(); Dog dog2=new 哈巴狗(); dog2.ability(); //简单工厂模式,这种情况下FactoryMain依赖FactoryZone以及Dog接口 //内部FactoryZone依赖Dog接口以及中华田园犬类,哈士奇类,哈巴狗类 //整体关系复杂,调用者简单 FactoryZone.factoryForDog("中华田园犬").ability(); FactoryZone.factoryForDog("哈士奇").ability(); FactoryZone.factoryForDog("哈巴狗").ability(); } }
工厂方法
创建同一结构类型的固定对象,可以新增任何对象
创建 DogFactory接口
public interface DogFactory { Dog getDog(); }
创建不同的生产工厂
public class 中华田园犬Factory implements DogFactory {
@Override
public Dog getDog() {
return new 中华田园犬();
}
}
public class 哈士奇Factory implements DogFactory {
@Override
public Dog getDog() {
return new 哈士奇();
}
}
public class 哈巴狗Factory implements DogFactory {
@Override
public Dog getDog() {
return new 哈巴狗();
}
}
如果新增了其他的Dog的时候,需要新增另外的类xxFactory implements DogFactory
该设计符合开闭原则,如果很多Dog的话,就也要加很多的xxFactory类
public class FactoryMain { public static void main(String[] args) { //工厂方式模式,FactoryMain依赖DogFactory以及中华田园犬Factory(),哈士奇Factory(),哈巴狗Factory() //DogFactory依赖Dog接口以及中华田园犬类,哈士奇类,哈巴狗类 DogFactory dogFactory = new 中华田园犬Factory(); dogFactory.getDog().ability(); DogFactory dogFactory1 = new 哈士奇Factory(); dogFactory1.getDog().ability(); DogFactory dogFactory2 = new 哈巴狗Factory(); dogFactory2.getDog().ability(); } }
理论和实际总是相差些什么,正常情况下,还是使用简单工厂会多点.
抽象工厂
创建不同产品族的任何对象,不可以新增新单个对象,可以新增不同产品族,用到这种模式说明项目体系比较大了,引用某大大的一张图做记录,该模式是工厂的工厂,根据下图建立理解思维,代码省略:
-----------------------------------------------------------------------------------