android源码设计模式学习笔记（一）

（一）开闭原则OCP
定义：软件中的对象（类，模块，函数）应该对于扩展是开放的，但是对于修改时封闭的
原因：在软件的生命周期内，因为变化，升级和维护等原因需要对软件原有代码进行修改时，可能会将错误引入原本已经经过测试的旧代码中，破坏原有系统，因此，因该尽量通过扩展的方式来实现变化
（二）里氏替换原则
核心：抽象，抽象又依赖进程这个特性
继承的优缺点：
优点：
（1）代码重用，减少创建类的成本，每个子类都拥有父类的方法和属性
（2）子类与父类基本相似，但又与父类有所区别
（3）提高代码的扩展性
缺点：
（1）继承时侵入性的，只要继承就必须拥有父类的所有属性和方法
（2）可能造成子类代码冗余，灵活性降低

public class Window {
    public void show(View view){
        view.draw();
    }
}
public abstract class View {
    public void measure(int width,int height){}
    abstract void draw();
}

public class TextView extends View{
    @Override
    void draw() {
        //自己的绘制方式
    }
}

public class ImageView extends View{
    @Override
    void draw() {
       //自己的绘制方式
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这里指的就是里氏替换原则，可以自定义各式各样的view，然后传递给window，window负责组织view，并将view显示到屏幕上

（三）迪米特原则
原理：一个对象应该对其他对象有最少的了解，调用者或依赖者只需要知道它的方法即可，其他的可以不用管，类与类之间关系越紧密，耦合度越大，当一个类发生改变时，对另一个类的影响也越大

public class Room {
    public float area;
    public float price;

    public Room(float area,float price){
        this.area = area;
        this.price = price;
    }
}
1
2
3
4
5
6
7
8
9

public class Mediation {
    private List<Room> mRoomList = new ArrayList<>();

    public Mediation(){
        for (int i = 0 ; i < 5 ; i++){
            mRoomList.add(new Room(14 + i,(14 + i) * 1000));
        }
    }

    public List<Room> getRoom(){
        return mRoomList;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

public class Person {
    private List<Room> mRoomList;

    public void getRoom(){
        Mediation mediation = new Mediation();
        mRoomList = mediation.getRoom();
        for (Room room : mRoomList){
            if (room.price == 1500 && room.area == 15){
                Log.d("TAG", "I find a room ");
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

从上面的代码中可以看到，person中不仅依赖Mediation，还依赖Room，如果都把这些检测条件放到person中，那么Mediation的作用将会很小，当Room变化时，Person也需要变化，而person与Mediation耦合，这就出现纠缠不清的情况，这个时候要分清谁才是真正的朋友。
要明确的是，我们只和我们的朋友通信

public class Mediation {
    private List<Room> mRoomList = new ArrayList<>();
    private float area;
    private float price;

    public Mediation(float area,float price){
        this.area = area;
        this.price = price;
        for (int i = 0 ; i < 5 ; i++){
            mRoomList.add(new Room(14 + i,(14 + i) * 1000));
        }
    }

    public Room getRoom(){
        for (Room room : mRoomList){
            if (room.price == price && room.area == area){
                return room;
            }
        }
        return null;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class Person {
    private Room mRoomList;
    public void getRoom(){
        Mediation mediation = new Mediation(15,1500);
mRoomList = mediation.getRoom();
    }
1
2
3
4
5
6