杂谈面向对象设计模式
Interface in Java & 工厂模式
Java（或者说面向对象）语言几点规则
1，复用性强
2，高内聚，低耦合
3，开闭原则（对扩展开放；对修改封闭）
4，针对接口编程，不针对实现编程
高内聚、低耦合 的理念怎么说？
高内聚：是一个类专注做一件事，这样可以提高复用性；
低耦合：减少类与类之间的耦合性，这样可以避免后期维护使得；（比如《利用Java的反射与代理机制实现IOC》一文中提到的Chines类与American类就存在很强的耦合性）
其实，Java中很多设计模式就是为了实现这两个理念而产生的。
1，引出
Android中有很多接口，比较Watchdog.Monitor
Watchdog.java
public interface Monitor {
void monitor();
}
void monitor();
}
注：这个接口还在Watchdog中，这里显然不是一种
规范，是一种
注入机制？
“反射是java根据类名创建类对象的一种机制，IOC是根据这种机制实现的，依赖注入是实现IOC的一种技术”
reference: 利用Java的反射与代理机制实现IOC
还有在Java的线程中有一个Runnable接口，类通过实现Ruunable接口来达到多线程机制
|
public class TestThread {
public static void main(String[] args){ Runnable1 r1 = new Runnable1(); //阻塞式执行，先执行完run()方法 ，再向下执行 //r1.run(); //在线程中执行，与main thread交替执行 Thread t = new Thread( r1); t.start(); for(int i=0; i<100; i++){ System.out.println("Main Thread" + i); } } } class Runnable1 implements Runnable{ public void run(){ for(int i=0; i<100; i++){ System.out.println("Runnable1" + i); } } } |
2，形象解释（来自zhihu）
| 接口的作用对于很多新手来说很不容易理解，我给大家举个例子。 接口只是一个规范，所以里面的方法都是空的。 假如我开了一个宠物粮店，声明所有宠物都可以来我这里买粮食，这就相当于一个接口， public interface PetRestaurant { public void buy(); } 当一只狗看到了，知道自己是宠物，所以它去实现这个接口 public class DogPet implements PetRestaurant { @Override public void buy() { System.out.println("我是狗，我要买狗粮"); } } 当一只猫看到了，知道自己也是宠物，所以也去实现这个接口 public class CatPet implements PetRestaurant { @Override public void buy() { System.out.println("我是猫，我要买猫粮"); } } 当狗和猫来我的店之前，我是不知道他们到底是什么，但是当他们来到我的店，我就知道一个要猫粮食，一个要狗粮食。因为他们都实现了 我这个接口，都可以买。下面这个类相当于一个接待顾客的类，即店小二，他接待所有实现了我这个宠物店接口的动物，传进来一个PetRestaurant 类型的宠物，注意，这个PetRestaurant 是接口 public class test { public void buy(PetRestaurant pet) { pet.buy(); } } 好了，这个时候我这个老板出现了，我可以给他们卖粮食了，相当于测试类 public class Tests { public static void main(String[] args) { PetRestaurant dog = new DogPet(); //实例化一个狗，相当于把狗顾客实例化 PetRestaurant cat = new CatPet();//实例化一个猫，相当于把猫顾客实例化 test t = new test(); //实例化一个店小二 t.buy(cat); //把猫交给店小二 t.buy(dog); //把狗交给店小二 } } 这样运行的结果就是 我是猫，我要买猫粮 我是狗，我要买狗娘 你知道吗，整个过程我这个店主其实根本不知道来的到底是猫是狗还是其他什么，我只要有一个店小二，把这些来的不知什么动物都全部交给店小二，店小二就知道怎么去卖了，因为这些狗啊猫啊都实现了我这个宠物店的接口，而店小二就负责接待所有实现了我这个接口的动物。这就有一个好处，假如明天来了一头小猪，只要它实现了我这个接口，我只管交给店小二处理就OK了，我这个店小二根本不需要变化，我这个店主也只需要实例化一下这个动物就OK 你想，假如没有接口，会怎么办，来一个猫，我要去创造一个猫，还要实例化，来一只狗，我要创建一只狗，同样要实例化，还要配备专门的店小二去接待，就会相当麻烦 |
3，类图
4，接口与工厂模式
无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦
refer: JAVA设计模式之工厂模式(简单工厂模式+工厂方法模式+抽象工厂模式)
工厂模式（把构造类交给工厂去生产，避免细节，方便）（不同皮肤，主题的实现就是使用工厂模式）
工厂模式分为
a:简单工厂模式（ 买宠物粮的例子，接口来抽象buy方法，不现的宠物来实现具体的buy。“工厂”就是店小二，）
宝马车才是好说明实例
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
| 产品类： abstract class BMW {
public BMW(){
}
}
public class BMW320 extends BMW {
public BMW320() {
System.out.println("制造-->BMW320");
}
}
public class BMW523 extends BMW{
public BMW523(){
System.out.println("制造-->BMW523");
}
}
工厂类： public class Factory {
public BMW createBMW(int type) {
switch (type) {
case 320:
return new BMW320();
case 523:
return new BMW523();
default:
break;
}
return null;
}
}
public class Customer {
public static void main(String[] args) {
Factory factory = new Factory();
BMW bmw320 = factory.createBMW(320);//有“父类引用指向子类对象”
BMW bmw523 = factory.createBMW(523);
}
}
|
b:工厂方法模式
| 产品类： abstract class BMW {
public BMW(){
}
}
public class BMW320 extends BMW {
public BMW320() {
System.out.println("制造-->BMW320");
}
}
public class BMW523 extends BMW{
public BMW523(){
System.out.println("制造-->BMW523");
}
}
interface FactoryBMW { //把工厂类也抽象了。
BMW createBMW();
}
public class FactoryBMW320 implements FactoryBMW{
@Override
public BMW320 createBMW() {
return new BMW320();
}
}
public class FactoryBMW523 implements FactoryBMW {
@Override
public BMW523 createBMW() {
return new BMW523();
}
}
public class Customer {
public static void main(String[] args) {
FactoryBMW320 factoryBMW320 = new FactoryBMW320();
BMW320 bmw320 = factoryBMW320.createBMW();
FactoryBMW523 factoryBMW523 = new FactoryBMW523();
BMW523 bmw523 = factoryBMW523.createBMW();
}
}
|
c:抽象工厂模式（即接口的使用）
2.0排量两厢车和2.4排量两厢车属于同一个
等级结构
而2.0排量两厢车和2.0排量三厢车属于同一个
产品族
如果工厂的产品全部属于同一个等级结构，则属于工厂方法模式；
如果工厂的产品来自多个等级结构，则属于抽象工厂模式
| 抽象工厂模式代码 产品类：
//车子以及型号
abstract class BMW {
public BMW(){
}
}
public class BMW320 extends BMW {
public BMW320() {
System.out.println("制造-->BMW320");
}
}
public class BMW523 extends BMW{
public BMW523(){
System.out.println("制造-->BMW523");
}
}
//空调以及型号
public class Aircondition {
public Aircondition(){
}
}
public class AirconditionA extends Aircondition{
public AirconditionA(){
System.out.println("制造-->AirconditionA");
}
}
public class AirconditionB extends Aircondition{
public AirconditionB(){
System.out.println("制造-->AirconditionB");
}
}
//创建工厂的接口
public interface FactoryBMW {
BMW createBMW_A();
BMW createBMW_B();
Aircondition createaAirconditionA();
Aircondition createaAirconditionB();
}
//宝马320系列，生产配置A，B两种空调型号的320汽车
public class FactoryBWM320 implements FactoryBMW{
@Override
public BMW320 createBMW_A() {
// TODO Auto-generated method stub
createaAirconditionA();
return new BMW320();
}
@Override
public BMW320 createBMW_B() {
// TODO Auto-generated method stub
createaAirconditionB();
return new BMW320();
}
@Override
public Aircondition createaAirconditionA() {
// TODO Auto-generated method stub
return new AirconditionA();
}
@Override
public Aircondition createaAirconditionB() {
// TODO Auto-generated method stub
return new AirconditionB();
}
}
//宝马523系列，生产配置A，B两种空调型号的523汽车
public class FactoryBWM523 implements FactoryBMW {
@Override
public BMW523 createBMW_A() {
// TODO Auto-generated method stub
createaAirconditionA();
return new BMW523();
}
@Override
public BMW523 createBMW_B() {
// TODO Auto-generated method stub
createaAirconditionB();
return new BMW523();
}
@Override
public Aircondition createaAirconditionA() {
// TODO Auto-generated method stub
return new AirconditionA();
}
@Override
public Aircondition createaAirconditionB() {
// TODO Auto-generated method stub
return new AirconditionB();
}
}
public class Customer {
public static void main(String[] args){
//想要A型空调宝马320
FactoryBWM320 factoryBWM320_A = new FactoryBWM320();
BMW320 bmw320_A = factoryBWM320_A.createBMW_A();
//想要B型空调宝马320
FactoryBWM320 factoryBWM320_B = new FactoryBWM320();
BMW320 bmw320_B = factoryBWM320_B.createBMW_B();
//想要A型空调宝马523
FactoryBWM523 factoryBWM523_A = new FactoryBWM523();
BMW523 bmw523_A = factoryBWM523_A.createBMW_A();
//想要B型空调宝马523
FactoryBWM523 factoryBWM523_B = new FactoryBWM523();
BMW523 bmw523_B = factoryBWM523_B.createBMW_B();
}
}
|
extend:
设计模式的6大原则
1，开闭原则：对扩展开放，对修改关闭
2，里氏代换原则:任何基类可以出现的地方,子类也可以出现
3，依赖倒转原则:：要依赖抽象,而不要依赖具体的实现.
4，合成/聚合复用原则（CARP）:要尽量使用合成/聚合原则,而不是继承关系达到软件复用的目的
5，迪米特法则:系统中的类,尽量不要与其他类互相作用,减少类之间的耦合度
6，接口隔离法则:这个法则与迪米特法则是相通的