🍍🍍OOP设计原理
开闭原理
对扩展开发 对修改关闭 是所有原则的总目标
里氏替换原则
1.子类应当可以替换父类并出现在父类能出现的地方
2.是多态的基础
迪米特原则
优点：其目的是降低类之间的耦合度，提高模块的相对独立性 缺点：过度使用迪米特法制则会使系统产生大量的中介类，从而增加系统的复杂性
单一职责原则（DIP）
类不要承担太多的功能，职责要单一 如果承担太多功能，则每个功能的变化都会影响该类
接口分离原则（ISP）
客户段不应依赖它不需要的接口 可以理解为接口要符合单一职责原则
依赖倒置原则
抽象不依赖具体，具体依赖于抽象 中心思想是面向接口编程
eg:
image
组合/聚合复用原则
如果处于代码复用的目的，则应该使用组合/聚合复用原则，而不要使用继承
🍍🍍oop思想四大基本特性：
- 抽象：提取现实世界中某事物的关键特性，为该事物构建模型的过程。对同一事物在不同的需求下，需要提取的特性可能不一样。得到的抽象模型中一般包含：属性（数据）和操作（行为）。这个抽象模型我们称之为类。对类进行实例化得到对象。
- 封装：封装可以使类具有独立性和隔离性；保证类的高内聚。只暴露给类外部或者子类必须的属性和操作。类封装的实现依赖类的修饰符（public、protected和private等）
- 继承：对现有类的一种复用机制。一个类如果继承现有的类，则这个类将拥有被继承类的所有非私有特性（属性和操作）。这里指的继承包含：类的继承和接口的实现。
- 多态：多态是在继承的基础上实现的。多态的三个要素：继承、重写和父类引用指向子类对象。父类引用指向不同的子类对象时，调用相同的方法，呈现出不同的行为；就是类多态特性。多态可以分成编译时多态和运行时多态。
🍍🍍24种设计模式（gof23+1）
创建型模式：
1、简单工厂模式（不包含在gof23中）
2、工厂模式
3、抽象工厂模式
4、单例模式
5、原型模式
6、创建者模式
结构型模式：
1、组合模式
2、装饰者模式
3、外观模式
4、适配器模式
5、代理模式
6、享元模式
7、桥接模式
行为型模式
1、观察者模式
2、策略者模式
3、状态模式
4、中介模式
5、模板方法
6、命令模式
7、备忘录模式
8、访问者模式
9、解释器模式
10、迭代器模式
11、职责链模式
🍍🍍常见的几种设计模式：
1、构造函数模式
/**
* 构造一个动物的函数
*/
function Animal(name, color){
this.name = name;
this.color = color;
this.getName = function(){
return this.name;
}
}
// 实例一个对象
var cat = new Animal('猫', '白色');
console.log( cat.getName() );
2、工厂模式
/**
* 工厂模式
*/
function Animal(opts){
var obj = new Object();
obj.name = opts.name;
obj.color = opts.color;
obj.getInfo = function(){
return '名称：'+obj.name +'， 颜色：'+ obj.color;
}
return obj;
}
var cat = Animal({name: '波斯猫', color: '白色'});
cat.getInfo();
3、模块模式
/**
* 模块模式 = 封装大部分代码，只暴露必需接口
*/
var Car = (function(){
var name = '法拉利';
function sayName(){
console.log( name );
}
function getColor(name){
console.log( name );
}
return {
name: sayName,
color: getColor
}
})();
Car.name();
Car.color('红色');
4、混合模式
/**
* 混合模式 = 原型模式 + 构造函数模式
*/
function Animal(name, color){
this.name = name;
this.color = color;
console.log( this.name + this.color)
}
Animal.prototype.getInfo = function(){
console.log('名称：'+ this.name);
}
function largeCat(name, color){
Animal.call(null, name, color);
this.color = color;
}
largeCat.prototype = create(Animal.prototype);
function create (parentObj){
function F(){}
F.prototype = parentObj;
return new F();
};
largeCat.prototype.getColor = function(){
return this.color;
}
var cat = new largeCat("Persian", "白色");
console.log( cat )
5、单例模式
/**
* 在执行当前 Single 只获得唯一一个对象
*/
var Single = (function(){
var instance;
function init() {
//define private methods and properties
//do something
return {
//define public methods and properties
};
}
return {
// 获取实例
getInstance:function(){
if(!instance){
instance = init();
}
return instance;
}
}
})();
var obj1 = Single.getInstance();
var obj2 = Single.getInstance();
console.log(obj1 === obj2);
6、发布订阅模式
/**
* 发布订阅模式
*/
var EventCenter = (function(){
var events = {};
/*
{
my_event: [{handler: function(data){xxx}}, {handler: function(data){yyy}}]
}
*/
// 绑定事件 添加回调
function on(evt, handler){
events[evt] = events[evt] || [];
events[evt].push({
handler:handler
})
}
function fire(evt, arg){
if(!events[evt]){
return
}
for(var i=0; i < events[evt].length; i++){
events[evt][i].handler(arg);
}
}
function off(evt){
delete events[evt];
}
return {
on:on,
fire:fire,
off:off
}
}());
var number = 1;
EventCenter.on('click', function(data){
console.log('click 事件' + data + number++ +'次');
});
EventCenter.off('click'); // 只绑定一次
EventCenter.on('click', function(data){
console.log('click 事件' + data + number++ +'次');
});
EventCenter.fire('click', '绑定');
image
以上为Android开发中的oop设计原理设计模式的一些解析；更多Android的高级开发技术，可以参考《Android核心技术手册》这个资料库，点击可前往查看获取。
最后
其实想想设计原则的设计和运用过程本质上就是对于“软件”（包含了系统，模块，类，函数，数据）这个对象本身，会遇到哪些场景（耦合，变化，维护，升级，千变万化），设计出符合要求（灵活性，扩展性，正确性）的软件的过程。
宁愿多花一些时间去提炼总结出自己的思考，也不要囫囵吞枣的粗浅的阅读，过段时间又给忘了重新回头去看。
网友评论