精华内容
下载资源
问答
  • 领域驱动设计的概念

    2021-05-02 10:42:50
    值对象:表示起描述性作用的并且可以相互替换的概念 八.聚合 聚合:是指一堆对象的集合,对象之间具有密不可分的联系,他们是内聚在一起的。 使用原则:再一次事务中,最多只能更改一个聚合的状态。如果一次业务操作...

    一.领域驱动设计的过程

    在这里插入图片描述

    二.DDD的优势

    在这里插入图片描述

    三.战略建模VS战术建模

    在这里插入图片描述

    四.核心域/支撑子域/通用子域

    一个业务系统一般只有一个核心域,其余的都是围绕核心域展开的。
    在这里插入图片描述

    五.理解限界上下文

    在这里插入图片描述在这里插入图片描述
    上下文映射图
    在这里插入图片描述

    六.领域实体

    在这里插入图片描述

    七.实体和值对象

    实体:表示那些具有生命周期并且会在其生命周期中发生改变的东西
    值对象:表示起描述性作用的并且可以相互替换的概念

    八.聚合

    聚合:是指一堆对象的集合,对象之间具有密不可分的联系,他们是内聚在一起的。
    使用原则:再一次事务中,最多只能更改一个聚合的状态。如果一次业务操作设计大了对多个聚合状态的更改该,那么应该采用发布领域实践的方式通知相应的聚合。(此时的数据一致性便从事务一致性变成了最终一致性)

    九.聚合根

    在这里插入图片描述

    十.领域服务

    三大特征:

    • 服务执行的操作代表了一个领域概念,这个领域概念无法自然地隶属于一个实体或者值对象
    • 被执行的操作涉及领域中的其他对象
    • 造作是无状态的

    十一.资源库

    资源库用于宝尊和获取聚合对象
    资源库分为两种:
    - 基于集合的(比如一个存在内存中的集合)
    - 基于持久化的(存储在数据库或文件中)

    十二.领域事件

    领域事件是在一个特定领域由一个用户动作触发的,是发生在过去的行为产生的事件,而这个事件是系统中的其他部分或者联系系统感兴趣的。

    十三.例子

    一个宏观的电商引入的先享卡业务域
    在这里插入图片描述

    展开全文
  • 演说之禅:幻灯片中设计原则

    千次阅读 2008-12-11 15:34:00
    前两个是信噪比原则和图效优势原则,虽然它们的概念比较宽泛和抽象,却对幻灯片的设计有着现实的指导意义。第三个留白原则能让我们以不同的眼光去看待幻灯片的设计问题,认识“空白”对表达意涵的有力作用。剩下的四...
    演说之禅:幻灯片中的设计原则
    此段文字节选自《演说之禅:职场必知的幻灯片秘笈》一书

        在本节中,我将向大家阐述有关设计的七项一般原则,它们无不对优秀幻灯片的设计有着巨大而积极的影响。前两个是信噪比原则和图效优势原则,虽然它们的概念比较宽泛和抽象,却对幻灯片的设计有着现实的指导意义。第三个留白原则能让我们以不同的眼光去看待幻灯片的设计问题,认识“空白”对表达意涵的有力作用。剩下的四个原则可以归纳为“四大基本原则”,分别是对比、重复、对齐和就近原则。罗宾?威廉姆斯(Robin Williams)在其畅销书《非设计师的设计手册》(The Non-Designer's Design Book)中反复强调,文档设计需要遵循上述“四大基本原则”。而我在下文中也会告诉大家如何把它们运用于幻灯片设计。
    信噪比原则
         信噪比(SNR)其实是个专业术语,常见于无线电通讯或电子通讯领域。但信噪比蕴含的理念几乎可以被应用于各个领域,包括设计和通讯等方面。对于幻灯片设计,信噪比等同于幻灯片上相关内容与无关内容的比率,而我们的目标就是使该比率达到最大值。过多的内容往往会造成认知上的理解困难。虽然我们拥有高效处理新事物或新讯息的能力,但这种能力毕竟是有限度的。追求更高的信噪比则意味着减轻人们在认知上的负担,使他们感到更加轻松自如。在很多情况下,就算没有过多非实质性内容的视觉轰炸,要使观众真正理解幻灯片也不是件容易的事情。
        为确保使幻灯片中相关内容与无关内容的比率达到最大值,幻灯片的内容应力求清晰明了,还应尽可能避免使用削弱主题的内容。造成主题削弱的原因有很多,比如选择使用了不恰当的图表和模棱两可的标识标记,或错误地强调了线条、造型或符号标记等对主题起不到烘托作用的元素等等。换言之,如果去掉幻灯片上的某些元素后不会妨碍人们理解的话,那么我们可以考虑把它们最小化,或者干脆不使用。举例来说,表格的边框要细,而且颜色要淡,或者干脆就不要边框。脚注或公司的标识等最好也能去掉(如果公司同意的话)。
        在《视觉解说》(Visual Explanations)一书中, 作者爱德华?塔夫特(Edward Tufte)提到了与信噪比的概念相统一的一条重要原则,称作“视觉特效差别最小化”原则,即“让元素视觉差别尽可能细微,但依然保证清晰和效率。”如果你能用较少的元素设计出幻灯片所要表达的内容,何必要多用呢?

    13164110_200810271658001.jpg预购买地址:http://www.china-pub.com/129849
    【书名】演说之禅:职场必知的幻灯片秘笈(全彩)
    【作者】(美)雷纳德(Reyno-lds,G.)著
            王佑,汪亮译
    【ISBN】978-7-121-07458-5
    【出版社】电子工业出版社
    【出版日期】2008年11月
    【宣传语】
        进入21世纪最需要的是沟通、创意构思和讨论的能力。
    ——全球管理大师、日本战略之父   大前研一
        国际畅销书,已被翻译成13国文字,内容被多家世界500强企业采用。
        幻灯片与演说设计大师 Garr Reynold,揭示幻灯片时代演说的秘诀。

    展开全文
  • 文章目录一:索引的概念1.1:数据库索引1.2:索引的作用1.3:索引优势劣势1.4:索引的分类1.5:创建索引1.6:创建索引的原则依据三:事务的概念4.1:原子性(Atomicity)4.2:一致性(Consistency)4.3:隔离性...

    一:索引的概念

    MySQL官方对索引的定义为:索引(index)是帮助MySQL高效获取数据的数据结构(有序)。在数据之外,数据库系统还维护者满足特定查找算法的数据结构,这些数据结构以某种方式引用(指向)数据, 这样就可以在这些数据结构上实现高级查找算法,这种数据结构就是索引。

    1.1:数据库索引

    • 是一个排序的列表,存储这索引值和这个所对应的物理地址
    • 无须对整个表进行扫描,通过物理地址就可以找到所需数据
    • 是表中一列或则若干个值排序的方法
    • 需要额外的磁盘空间
      相当于目录,方便查找 伴随着表存在的! 面对于小量的数据/小篇幅量的数据不需要建立索引,300行以内的不要要建立索引,否则会占用空间)

    1.2:索引的作用

    设置了合适的索引之后,数据库利用各种快速的定位技术,能够大大加快查询速率
    特别是当表很大时,或者查询涉及到多个表时,使用索引可使查询加快成干倍
    可以降低数据库的IO【输入输出】成本,并且索引还可以降低数据库的排序成本
    通过创建唯一性索引保证数据表数据的唯一性【确认具体到某一条记录】
    可以加快表与表之间的连接
    在使用分组和排序时,可大大减少分组和排序时间

    1.3:索引优势劣势

    优势

    • 类似于书籍的目录索引,提高数据检索的效率,降低数据库的IO成本。
    • 通过索引列对数据进行排序,降低数据排序的成本,降低CPU的消耗。劣势
    • 实际上索引也是一张表,该表中保存了主键与索引字段,并指向实体类的记录,所以索引列也是要占用空间的。
    • 虽然索引大大提高了查询效率,同时却也降低更新表的速度,如对表进行INSERT、UPDATE、DELETE。因为更新表时,MySQL不仅要保存数据,还要保存一下索引文件每次更新添加了索引列的字段,都会调整因为更新所带来的键值变化后的索引信息。

    1.4:索引的分类

    ●普通索引
    ●这是最基本的索l类型,且它没有唯一性之类的限制。
    ●唯一性索引
    ●这种索弓和前面的"普通索弓l”基本相同,但有- 个区别:薪列的所有值都只能出现一次,即必须唯一 。
    ●主键
    ●主键是一种唯一性索引,但它必须指定为“PRIMARY KEY"。
    注意: -个表中只能有一个主键,但可以在多个字段,-个主键对应多个字段。
    ●全文索引
    ●在MySQL中,文索的索弓|类型为FULLTEXT,文索引可以在VARCHAR或者TEXT类型的列上创建。
    ●单列索引与多列索引
    ●引可以是单列上创建的索引,也可以是在多列上创建的索引

    1.5:创建索引

    ●根据企业需求选择了合适的索引之后,可使用create index创建索弓|
    ●create index加各个索|关键字,便可创建各个类型的索l。

    创建索引有三种方式:
    ●1、创建表时直接定义。.
    ●2、create index引名称on名(列名1,列名2) ;
    ●3、alter table铭add index索|名称(列名);

    1.5.1:普通索引
    最基本的索引,没有唯一性之类的限制
    创建普通索引的方式
    ①创建表结构时创建

    mysql> create table user(id int(4) NOT NULL,name char(48) NOT NULL,age int(3) NOT NULL,sex varchar(36) NOT NULL,primary key (name),index index_id (id));       #创建表时创建索引
    mysql> show index from user;       #查看索引
    

    ②直接创建索引

    mysql> create index index_name on user(name);
    mysql> show index from user;  
    

    ③修改表结构方式添加索引

    mysql> alter table user add index index_age(age);
    mysql> show index from user;
    

    1.5.2:唯一性索引
    与“普通索弓I”基本相同
    与普通索弓|的区别是索弓|列的所有值只能出现一次,即必须唯一
    创建唯一索引的方式
    ①直接创建索引

    mysql> insert into user(id,name,age,sex) values(1,'liming',18,'男'),(2,'lisi',25,'男'),(3,'lili',20,'女');
    mysql> create unique index index_name on user(name);
    mysql> show index from user;
    

    ②修改表结构方式添加索引

    mysql> alter table user add unique index_name(name);
    mysql> show index from user;
    

    1.5.3:主键索引
    是一种特殊的唯一索引,指定为“PRIMARY KEY”
    一个表只能有一个主键,不允许有空值
    创建主键索引的方式

    mysql> create table user(id int(4) NOT NULL,name char(48) NOT NULL,age int(3) NOT NULL,sex varchar(36) NOT NULL,primary key (name)

    1.5.4:查看索引

    mysql> show index from 表名;
    mysql> show keys from 表名;
    

    1.5.5:删除索引

    mysql> drop index 索引名 on 表名;
    mysql> alter table index 表名 drop index 索引名;
    

    1.5.6:组合索引
    可以是单列上创建的索引,也可以是在多列上创建的索引
    最左原则,从左往右依次执行
    创建组合索引的方式

    mysql> create table users(name varchar(9), age int(3),sex tinyint(1),indexx users(name,age,sex));
    mysql> show index from users;
    

    1.5.7:全文索引
    MySQL从3.23.23版开始支持全文索引和全文检索
    索引类型为FULLTEXT
    可以在CHAR、VARCHAR或者TEXT类型的列上创建
    ①直接创建索引

    mysql> create index index_id on user(id);
    mysql> show index from user;
    

    ②修改表结构方式添加索引

    mysql> alter table user add index index_age(age);
    mysql> show index from user;
    

    1.6:创建索引的原则依据

    表的主键、外键必须有索引
    记录数超过300行的表应该有索引
    经常与其他表进行连接的表,在连接字段上应该建立索引
    唯一性太差的字段不适合建立索引
    更新太频繁的字段不适合建立索引
    经常出现在where子句中的字段,特别是大表的字段,应该建立索引
    索引应该建立在选择性高的字段上
    索引应该建立在小字段上,对于大的文本字段甚至超长字段,不要建立索引

    二:事务的概念

    • 事务是一种机制、一个操作序列,包含了一组数据库操作命令,并且把所有的命令作为一个整体一起向系统提交或撤销操作请求,即这一组数据库命令要么都执行,要么都不执行;当执行不成功时,会回滚,回到事务的起点
    • 事务是一个不可分割的工作巡逻单元,在数据库系统上执行并发操作时,事务时最小的控制单元
    • 适用于多用户同时操作的数据库系统的场景,如银行、保险公司及证券公司交易系统等等
    • 通过事务的整体性以保证数据的一致性

    2.1:原子性(Atomicity)

    • 事务是一个完整的操作,事务的各元素是不可分的(原子的)
    • 事务中的所有元素必须作为一个整体提交或回滚
    • 如果事务中的任何元素失败,则整个事务将失败
    • 原子性就是回滚机制

    2.2:一致性(Consistency)

    • 当事务完成时,数据必须处于一致状态:在事务开始之前,数据库中存储的数据处于一致状态;在正在进行的事务时,数据可能处于不一致的状态;当事务成功完成时,数据必须再次回到已知的一致状态

    2.3:隔离性(Isolation)

    • 对数据进行修改的所有并发事务是彼此隔离的,这表明事务必须是独立的,它不应以任何方式依赖于或影响其他事务
    • 修改数据的事务可以在另一个使用相同数据的事务开始之前访问这些数据,或者在另一个使用相同数据的事务结束之后访问这些数据

    2.4:持久性(Durability)

    • 事务持久性不管系统是否发生故障,事务处理的结果都是永久的
    • 一旦事务被提交,事务的效果被永久地保留在数据库中
    • 不可逆性,除非使用回滚操作

    三:事务控制语句

    3.1:默认情况下 MySQL的事务是自动提交的,当sql语句提交时事务便自动提交

    3.2:事务控制语句

    • BEGIN或START TRANSACTION 【事务的开始】
    • COMMIT 【提交 事务的结束】
    • ROLLBACK 【回滚】
    • SAVEPOINT identifier 【存档点】
    • RELEASE SAVEPOINT identifier 【删除存档点】
    • ROLL BACK TO identifier 【回滚到某个存档点】 【identifire 存档名称 随意更改】
    • SETTR ANSACTION 【设置事务】

    3.3:事务的控制方法

    3.3.1:事务处理命令控制事务

    1 BEGIN:开始一个事务
    2 COMMIT:提交一个事务
    3 ROLLBACK:回滚一个事务

    3.3.2:使用set命令进行控制

    1 set autocommit=0:禁止自动提交
    2 set autocommit=1:开启自动提交

    3.3.3:事务的操作

    1 mysql> begin; #开始事务
    2 mysql> insert into userq1(id,name,score,hobby) values(5,‘yy’,80,2);
    3 mysql> rollback; #回滚
    4 mysql> commit; #提交

    六:存储引擎

    在这里插入图片描述

    • MySQL中的数据用各种不同的技术存储在文件中,每一种技术都使用不同的存储机制、索引技巧、锁定水平并最终提供不同的功能和能力,这些不同的技术以及配套的功能在MySQL中称为存储引擎。
    • 存储引擎就是MySQL将数据存储在文件系统中的存储方式或者存储格式。

    6.1:目前MySQL常用的两种存储引擎:

    • MyISAM
    • InnoDB
    • MySQL存储引擎是MySQL数据库服务器中的组件负责为数据库执行实际的数据I/O操作。
    • 使用特殊存储引擎的主要优点之一在于, 仅需提供特殊应用所需的特性,数据库中的系统开销较小,具有更有效和更高的数据库性能。
    • MySQL系统中,存储引擎处于文件系统之上,在数据保存到数据文件之前会传输到存储引擎,之后按照各个存储引擎的存储格式进行存储。

    6.1:MyISAM

    MyISAM不支持事務,也不支持外键
    访问速度快
    对事务完整性没有要求
    MyISAM在磁盘上存储成三个文件

    1 .frm文件存储表定义
    2 数据文件的扩展名为.MYD(MYDATA)
    3 索引文件的扩展名是.MYI(MYIndex)
    表级锁定形式,数据在更新时锁定整个表
    数据库在读写过程中相互阻塞

    1.会在数据写入的过程阻塞用户数据的读取
    2.也会在数据读取的过程中阻塞用户的数据写入
    数据单独写入或读取,速度过程较快且胡资源相对少
    MyISAM支持的存储格式
    1.静态表
    2.动态表
    3.压缩表
    MyISAM适用的生产场景举例
    1.公司业务不需要事务的支持
    2.单方面读取或写 入数据比较多的业务
    3.MyISAM存储引擎数据读写都比较频繁场景不适合
    4.使用读写并发访问相对较低的业务
    5.数据修改相对较少的业务
    6.对数据业务一致性要求不是非常高的业务
    7.服务器硬件资源相对比较差

    6.2:InnoDB的介绍

    InnoDB特点介绍
    支持4个事务隔离级别
    行级锁定,但是全表扫描仍然会是表级锁定
    读写阻塞与事务隔离级别相关
    能非常高效的缓存索引和数据
    表与主键以簇的方式存储
    支持分区、表空间、类似Oracle数据库
    支持外键约束,5.5前不支持全文索引,5.5后支持全文索引
    对硬件资源要求还是比较高的场合
    InnoDB适用生产场景分析
    业务需要事务的支持
    行级锁定对高并发有很好的适用能力,但需要确保查询是通过索引来完成
    业务数据更新较为频繁的场景,如:论坛,微博等
    业务数据一致性要求较高,如:银行业务
    硬件设备内存较大,利用InnoDB较好的缓存能力来提高内存利用率,减少磁盘IO的压力
    企业选择存储引擎依据
    需要考虑每个存储引擎提供的核心功能及应用场景
    支持的字段和数据类型
    ①所有引擎都支持通用的数据类型
    ②但不是所有的引擎都支持其它的字段类型,如二进制对象
    锁定类型:不同的存储引擎支持不同级别的锁定
    ①表锁定
    ②行锁定
    索引的支持
    ①建立索引在搜索和恢复数据库中的数据时能显著提高性能
    ②不同的存储引擎提供不同的制作索引的技术
    ③有些存储引擎根本不支持索引
    事务处理的支持
    ①提高在向表中更新和插入信息期间的可靠性
    ②可根据企业业务是否要支持事务选择存储引擎

    方法一:alter table修改
    mysql> alter table 库名 engine=MyISAM;
    
    方法二:修改my.cnf配置文件,指定默认存储引擎并重启服务
    vim my.cnf
    default-storage-engine=InnoDB
    
    方法三:create table创建表时指定存储引擎
    mysql> create table engine Test(id int) engine=MyISAM;
    
    展开全文
  • 此外,与动态能力的概念一致,高绩效的公司在信息资源和绩效低下的人之间展现出互补性。 最后,我们利用数据集的关键设计特征来表明,信息资源在显式信息内容含量较高的域中更为重要,而功能对于隐性信息含量较高的...
  • 1.设计模式七大原则 单一职责原则 接口隔离原则 依赖倒转原则 里氏替换原则 开闭原则-ocp (工厂模式用到了这个) 迪米特法则 合成复用原则 1.1单一职责原则 概念:对类来说:一个类应该只负责一个职责。 如果...

    1.设计模式的七大原则

    1. 单一职责原则
    2. 接口隔离原则
    3. 依赖倒转原则
    4. 里氏替换原则
    5. 开闭原则-ocp (工厂模式用到了这个)
    6. 迪米特法则
    7. 合成复用原则

    1.1单一职责原则

    1. 概念:对类来说:一个类应该只负责一个职责

      如果A负责两个职责,A1.A2,为了避免职责A1发生变更后,影响职责A2的执行,需要把A进行粒度分解,分为A1,A2

    2. 优势及注意事项:

      1.降低类的复杂度

      2.提高程序的可读性、可维护性

      3.降低变更引起的风险

      4.遵守设计的单一原则

    3. 上代码

      public class SingleResponsibility {
      
      	public static void main(String[] args) {
      		// TODO Auto-generated method stub
      		RoadVehicle roadVehicle = new RoadVehicle();
      		roadVehicle.run("摩托车");
      		roadVehicle.run("汽车");
      		
      		AirVehicle airVehicle = new AirVehicle();
      		airVehicle.run("飞机");
              
              WaterVehicle waterVehicle = new WaterVehicle();
      		waterVehicle.run("游轮");
      	}
      
      }
      
      //1. 遵守单一职责原则,即一个类负责一个职责。
      //2. 但是这样做的改动较大,即将类分解,同时修改客户端
      //3. 思考改进:直接修改Vehicle 类,里边直接加这3个实现的方法,改动的代码会比较少。
      
      class RoadVehicle {
      	public void run(String vehicle) {
      		System.out.println(vehicle + "在公路运行");
      	}
      }
      
      class AirVehicle {
      	public void run(String vehicle) {
      		System.out.println(vehicle + "在天空运行");
      	}
      }
      
      class WaterVehicle {
      	public void run(String vehicle) {
      		System.out.println(vehicle + "在水中运行");
      	}
      }
      

    1.2接口隔离原则

    1. 概念

      在这里插入图片描述

    • 在这里插入图片描述

    • 在这里插入图片描述

    理解:接口隔离—一个类依赖另一个类通常是通过一个接口来完成。

    1. 上代码

      public class Segregation1 {
      
      	public static void main(String[] args) {
      		// TODO Auto-generated method stub
      		// 使用一把
      		A a = new A();
      		a.depend1(new B()); // A类通过接口去依赖B类
      		a.depend2(new B());
      		a.depend3(new B());
      
      		C c = new C();
      
      		c.depend1(new D()); // C类通过接口去依赖(使用)D类
      		c.depend4(new D());
      		c.depend5(new D());
      
      	}
      
      }
      
      // 接口1
      interface Interface1 {
      	void operation1();
      
      }
      
      // 接口2
      interface Interface2 {
      	void operation2();
      
      	void operation3();
      }
      
      // 接口3
      interface Interface3 {
      	void operation4();
      
      	void operation5();
      }
      
      class B implements Interface1, Interface2 {
      	public void operation1() {
      		System.out.println("B 实现了 operation1");
      	}
      
      	public void operation2() {
      		System.out.println("B 实现了 operation2");
      	}
      
      	public void operation3() {
      		System.out.println("B 实现了 operation3");
      	}
      
      }
      
      class D implements Interface1, Interface3 {
      	public void operation1() {
      		System.out.println("D 实现了 operation1");
      	}
      
      	public void operation4() {
      		System.out.println("D 实现了 operation4");
      	}
      
      	public void operation5() {
      		System.out.println("D 实现了 operation5");
      	}
      }
      
      class A { // A 类通过接口Interface1,Interface2 依赖(使用) B类,但是只会用到1,2,3方法
      	public void depend1(Interface1 i) {
      		i.operation1();
      	}
      
      	public void depend2(Interface2 i) {
      		i.operation2();
      	}
      
      	public void depend3(Interface2 i) {
      		i.operation3();
      	}
      }
      
      class C { // C 类通过接口Interface1,Interface3 依赖(使用) D类,但是只会用到1,4,5方法
      	public void depend1(Interface1 i) {
      		i.operation1();
      	}
      
      	public void depend4(Interface3 i) {
      		i.operation4();
      	}
      
      	public void depend5(Interface3 i) {
      		i.operation5();
      	}
      }
      

    1.3依赖倒转原则

    1. 基本介绍

      重点:

      它的中心思想是:面向接口编程

      抽象不依赖细节,细节依赖抽象

      接口和抽象类的目的是:指定规范

    在这里插入图片描述

    1. 注意事项

      • 底层模块尽量都要有抽象类或接口。

      • 变量的声明尽量是一个接口,

        举例:加入一个类A继承了接口B,写一个Object obj = new A(); 其实这样的话,obj是直接与接口B有交接,等于是通过B来联系类A,这样中间就会有一个缓冲,接口B就是这个缓冲,

    2. 依赖传递的方式:

      • 接口传递
      • 构造方法传递
      • setter方法传递
    public class DependecyInversion {
    
    	public static void main(String[] args) {
    		//客户端无需改变
    		Person person = new Person();
    		person.receive(new Email());
    		
    		person.receive(new WeiXin());
    	}
    
    }
    
    //定义接口
    interface IReceiver {
    	public String getInfo();
    }
    
    class Email implements IReceiver {
    	public String getInfo() {
    		return "电子邮件信息: hello,world";
    	}
    }
    
    //增加微信
    class WeiXin implements IReceiver {
    	public String getInfo() {
    		return "微信信息: hello,ok";
    	}
    }
    
    //方式2
    class Person {
    	//这里我们是对接口的依赖
    	public void receive(IReceiver receiver ) {
    		System.out.println(receiver.getInfo());
    	}
    }
    
    

    1.4里氏替换原则

    1. 基本介绍:

      • 它是一个麻省理工的一个姓里的女士提出来的。
      • 它要求我们尽量的不要改写我们的父类的方法。(不要重写父类方法)
      • 如果重写了,可以通过聚合、组合、依赖来解决问题。
    2. 目的:

      就是保证父类的方法不被覆盖

    3. 上代码

      public class Liskov {
      public static void main(String[] args) {
      	// TODO Auto-generated method stub
      	A a = new A();
      	System.out.println("11-3=" + a.func1(11, 3));
      	System.out.println("1-8=" + a.func1(1, 8));
      
      	System.out.println("-----------------------");
      	B b = new B();
      	//因为B类不再继承A类,因此调用者,不会再func1是求减法
      	//调用完成的功能就会很明确
      	System.out.println("11+3=" + b.func1(11, 3));//这里本意是求出11+3
      	System.out.println("1+8=" + b.func1(1, 8));// 1+8
      	System.out.println("11+3+9=" + b.func2(11, 3));
      		//使用组合仍然可以使用到A类相关方法
      	System.out.println("11-3=" + b.func3(11, 3));// 这里本意是求出11-3
      	}
      }
      //创建一个更加基础的基类
      class Base {
      	//把更加基础的方法和成员写到Base类
      }
      
      // A类
      class A extends Base {
      	// 返回两个数的差
      	public int func1(int num1, int num2) {
      		return num1 - num2;
      	}
      }
      
      // B类继承了A
      // 增加了一个新功能:完成两个数相加,然后和9求和
      class B extends Base {
      	//如果B需要使用A类的方法,使用组合关系
      	private A a = new A();
      	
      	//这里,重写了A类的方法, 可能是无意识
      	public int func1(int a, int b) {
      		return a + b;
      	}
      
      	public int func2(int a, int b) {
      		return func1(a, b) + 9;
      	}
      	
      	//我们仍然想使用A的方法
      	public int func3(int a, int b) {
      		return this.a.func1(a, b);
      	}
      }
      

    1.5开闭原则(ocp原则—open close principle)

    1. 基本介绍:

      • 开闭原则是编程中最基础最重要的原则

      • 对扩展开放,对修改关闭:——可以是用抽象创建框架,用实现来扩展细节。

        咂一看这句话有矛盾,我们来理解一下这句话:

        扩展开放——对提供者开放(可以理解为开发人员);

        修改关闭——对使用者关闭(可以理解为原先使用方的这边并没有修改)

      • 添加修改功能的时候尽量是扩展,不要进行修改。

    2. 方式1 的优缺点
      1)优点是比较好理解,简单易操作。
      2)缺点是违反了设计模式的 ocp 原则,即 对扩展开放 (提供方 ),对修改关闭 使用方 。

      ​ 即当我们给类增加新功能的时候,尽量不修改代码,或者尽可能少修改代码
      3)比如我们这时要新增加一个图形种类三角形 ,我们需要做如下修改的地方较多
      4)代码演示

      public class Ocp {
      
      	public static void main(String[] args) {
      		//使用看看存在的问题
      		GraphicEditor graphicEditor = new GraphicEditor();
      		graphicEditor.drawShape(new Rectangle());
      		graphicEditor.drawShape(new Circle());
      		graphicEditor.drawShape(new Triangle());
      	}
      
      }
      
      //这是一个用于绘图的类 [使用方]
      class GraphicEditor {
      	//接收Shape对象,然后根据type,来绘制不同的图形
      	public void drawShape(Shape s) {
      		if (s.m_type == 1)
      			drawRectangle(s);
      		else if (s.m_type == 2)
      			drawCircle(s);
      		else if (s.m_type == 3)
      			drawTriangle(s);
      	}
      
      	//绘制矩形
      	public void drawRectangle(Shape r) {
      		System.out.println(" 绘制矩形 ");
      	}
      
      	//绘制圆形
      	public void drawCircle(Shape r) {
      		System.out.println(" 绘制圆形 ");
      	}
      	
      	//绘制三角形
      	public void drawTriangle(Shape r) {
      		System.out.println(" 绘制三角形 ");
      	}
      }
      
      //Shape类,基类
      class Shape {
      	int m_type;
      }
      
      class Rectangle extends Shape {
      	Rectangle() {
      		super.m_type = 1;
      	}
      }
      
      class Circle extends Shape {
      	Circle() {
      		super.m_type = 2;
      	}
      }
      
      //新增画三角形
      class Triangle extends Shape {
      	Triangle() {
      		super.m_type = 3;
      	}
      }
      
      

      方 式 2 的设计方案 : 定 义一个 Shape 抽象

      上代码:

      public class Ocp {
      
      	public static void main(String[] args) {
      		//使用看看存在的问题
      		GraphicEditor graphicEditor = new GraphicEditor();
      		graphicEditor.drawShape(new Rectangle());
      		graphicEditor.drawShape(new Circle());
      		graphicEditor.drawShape(new Triangle());
      		graphicEditor.drawShape(new OtherGraphic());
      	}
      
      }
      
      //这是一个用于绘图的类 [使用方]
      class GraphicEditor {
      	//接收Shape对象,调用draw方法
      	public void drawShape(Shape s) {
      		s.draw();
      	}
      
      	
      }
      
      //Shape类,基类
      abstract class Shape {
      	int m_type;
      	
      	public abstract void draw();//抽象方法
      }
      
      class Rectangle extends Shape {
      	Rectangle() {
      		super.m_type = 1;
      	}
      
      	@Override
      	public void draw() {
      		// TODO Auto-generated method stub
      		System.out.println(" 绘制矩形 ");
      	}
      }
      
      class Circle extends Shape {
      	Circle() {
      		super.m_type = 2;
      	}
      	@Override
      	public void draw() {
      		// TODO Auto-generated method stub
      		System.out.println(" 绘制圆形 ");
      	}
      }
      
      //新增画三角形
      class Triangle extends Shape {
      	Triangle() {
      		super.m_type = 3;
      	}
      	@Override
      	public void draw() {
      		// TODO Auto-generated method stub
      		System.out.println(" 绘制三角形 ");
      	}
      }
      
      //新增一个图形
      class OtherGraphic extends Shape {
      	OtherGraphic() {
      		super.m_type = 4;
      	}
      
      	@Override
      	public void draw() {
      		// TODO Auto-generated method stub
      		System.out.println(" 绘制其它图形 ");
      	}
      }
      
      

    1.6迪米特法则

    1. 基本介绍:

      • 理论文字介绍太抽象,简单来说就是:A类—>B类的依赖—>A对B知道的越少越好,他们之间的交集越小越好。

      • 还有一个简单的定义:只与直接的朋友通信

        • 什么是直接的朋友?——有3种情况:

          假定有一个A类、一个B类,

          1-B类出现在A类的成员变量中

          2-B类出现在A类的方法参数中

          3-B类出现在A类的方法返回值中

    1.7 合成复用原则

    1. 核心思想:则是尽量使用合成聚合的方式,而不是使用继承

      1. 简单理解:一个A类、一个B类,B类想用A类中的方法,如果直接继承的话耦合度太高。

        解决的办法:

        1-在B类的方法参数中传入A类(这是UML类图中的依赖);

        2-在B类中写入A类的属性-就是A的对象实例,用set方法setA(A a)(这称为把A聚合到B里边去);

        3-在B类中加入A的属性并直接new出A的对象(构建属性A时直接new出来),就是等于当B实例创建好了之后,我的属性A也创建好了(这样A和B事组合的关系)

        图例:

      在这里插入图片描述

      这样做耦合度高的解释:(B类如果只想用A类中的2个方法,但A有5个方法,就会浪费;亦或者A类有其他的类被继承,A类的方法改变,B类也会受影响。)

    设计原则的核心思想

    1. 找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代
      码混在一起 。
    2. 针对接口编程,而不是针对实现编程 。
    3. 为了交互对象之间的松耦合设计而努力
    展开全文
  • 玉米杂种优势利用

    2020-02-13 12:33:53
    玉米杂种优势利用,李云霞,,玉米是异花授粉植物,育种主要是利用其杂种优势.本文首先介绍了杂种优势的概念,表现及原则,随后着重讲述了玉米杂种优势的利用,并以�
  • 设计模式02 之面向对象设计原则 1. 为什么要面向对象设计? 变化是复用最大天敌!面向对象设计最大的优势在于:抵御变化! 2. 重新认识面向对象 理解隔离变化: 从宏观层面来看,面向对象构建方式更能适应...
  • 2. 面向对象的优势 3. 如何学习面向对像  (1)掌握一种面向对象语言语法  (2)掌握面向对象思维方式  (3)熟悉面向对象设计原则  (4)掌握面向对象设计模式 4. 面向对象思维方法  (1)...
  • 文章目录常用设计原则和设计模式常用设计原则(记住)软件开发流程常用设计原则常用设计模式基本概念基本分类设计模式详解(重点)单例设计模式普通工厂模式基本概念类图结构代码实现举例普通工厂模式的优势...
  • 面向对象设计最大的优势在于:抵御变化。 重新认识面向对象 理解隔离变化 从宏观层面来看,面向对象构建方式更能适应软件变化,能将变化所带来影响减为最小。 各司其职 从微观层面来看,面向对象方式更...
  • 一、面向服务架构的概念 二、SOA的特征 三、SOA的设计原则 四、SOA角色 五、SOA的关键技术 1. UDDI 2.WSDL 3.SOAP 4.REST 六、SOA的实现方法 1.Web Service 2.服务注册表 3.企业服务总线 七、微服务 ...
  • 面向对象设计原则

    2017-03-28 15:10:27
    @(设计模式)[设计原则, 帮助, Markdown]变化是复用天敌,面向对象设计最大的优势在于抵御变化! 理解隔离变化 :从宏观层面来看,面向对象构建方式更能适应软件变化,能将变化所带来影响减为最小; 各司其职...
  • 分布式基本概念

    2019-05-06 23:30:03
    分布式(硬件:相互独立主机群,软件:...CAP理论:partition tolerance分区容忍性的原则上权衡consistency一致性和availability可用性 数据库事务特性CAID(consistency、automicity、isolation、durability...
  • 但是DDD的概念众多,晦涩难以理解,如何抓住重点,合理的运用到微服务架构中呢? 我认为如下的几个架构思想是重中之重 - 充血模型 <ul><li>事件驱动 </li></ul> ​ 下面两篇将为大家详细...
  • SOA平台之概念解读

    2020-03-03 23:26:58
    SOA就是能够通过Web服务优势,来解决企业环境平台兼容性,并且注入了不同组织之间交 互愿望,敏捷性与跨平台性。SOA这一术语就代表着这样一个模型:自动化逻辑(商业逻辑)被分解成更小、各自独立逻辑...
  • 良好接地指导原则

    2021-01-20 06:05:23
    尽管它的概念相对比较简单,实施起来却很复杂,遗憾的是,它没有一个简明扼要可以用详细步骤描述的方法来保证取得良好效果,但如果在某些细节上处理不当,可能会导致令人头痛的问题。  对于线性系统而言,"地"是...
  • HBase相关概念

    2015-09-11 20:22:00
    从表形式看,主要有列少行多高表和行多列少宽表,一般情况高表更有优势,因为HBase只能按行拆分。 防止数据过热:当行健为时间戳时,写入数据集中在其中一个Region很容易产生单点过热。解决办法...
  • 微服务(概念

    2019-12-30 15:01:23
    一、微服务介绍 1.什么是微服务 微服务由来 为什么需要微服务? ...3.1 早期单体架构带来...6.1 微服务设计原则 微服务优势与缺点 7.1 特性 7.2 特点 7.3 缺点 微服务开发框架 Sprint cloud 和 Sprint bo...
  • 微服务概念简标

    2019-10-12 16:53:12
    一、微服务介绍 1.什么是微服务 2. 微服务由来 3. 为什么需要微服务? 3.1 早期单体架构带来问题 ...6.1 微服务设计原则 7. 微服务优势与缺点 7.1 特性 7.2 特点 7.3 缺点 8. 微服务开发框架 9. Spri...
  • Spring之IOC概念讲解

    2021-03-04 07:03:23
    文章目录IOC控制反转Ioc - Inversion of Control依赖注入DI依赖注入DI实现控制反转IOC DI DL关系依赖注入方式依赖倒置原则IOC容器的优势 注解与Spring框架中IOC关系: 使用注解标记需要管理实例, 并依据注解...
  • 尽管它的概念相对比较简单,实施起来却很复杂,遗憾的是,它没有一个简明扼要可以用详细步骤描述的方法来保证取得良好效果,但如果在某些细节上处理不当,可能会导致令人头痛的问题。  对于线性系统而言,"地"是...
  • 面向对象设计最大的优势在于抵御变化! 什么认识下什么是面向对象 理解隔离变化 从宏观层面来看,面向对象构建方式更能适应软件变化,能将变化所带来影响减为最小。 各司其职 从微观层面来看,面向对象方式...
  • 面向对象设计最大的优势在于: 抵御变化 重新认识面向对象 理解隔离变化 •从宏观层面来看,面向对象构建方式更能适应软件变化,能将变化所带来影响减为最小 各司其职 • 从微观层面来看,面向对象方式更...
  • 变化是复用天敌,面向对象设计最大的优势就是抵御变化 对象是什么? 从语言实现层面来看,对象封装了代码和数据 从规格层面讲,对象是一系列可被使用公共接口 从概念层面讲,对象是某种拥有责任抽象 依赖...
  • SDN ­­ (software­defined networking)软件定义网络所具有灵活性和自动化优势使其成为云时代网络管理主流。 Neutron 设计目标是实现“网络即服务(Networking as a Service)”。为了达到这一目标,在...
  • Java 设计模式(十) 单一职责原则(SRP)

    千次阅读 2016-05-08 17:55:41
    单一职责原则(Single Responsibility Principle)SRP 基本概念单一职责原则 定义:应该有且仅有一个原因引起类变更,也就是接口或类和职责关系是一一对应。 难点:职责划分: 在不同情景和生产环境下我们对职责...
  • 化,以及Java与net的斗法并发编程的概念止被不断地强化其涵盖的内容也不断扩大, 在所有有关软件和编程的杂志和论文中亡几乎独占鳌头 由于Java语言在设计之初就考虑到了并发编程的因素,所以在和C ++的竞争中自占 ...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 209
精华内容 83
关键字:

优势原则的概念