oop7大设计原则
软件开发标准列表
◆软件设计原则●开放－封闭原则（OCP）Open-Closed Principle原则讲的是：一个软件实体应当对扩展开放，对修改关闭。
通过扩展已有软件系统，可以提供新的行为，以满足对软件的新的需求，使变化中的软件有一定的适应性和灵活性。
已有软件模块，特别是最重要的抽象层模块不能再修改，这使变化中的软件系统有一定的稳定性和延续性。
用面向对象的语言来讲，不允许更改的是系统的抽象层，而允许更改的是系统的实现层。
●里氏代换原则（LSP）Liskov Substitution Principle（里氏代换原则）：子类型(subtype)必须能够替换它们的基类型。
反过来基类无法替换子类特征。
意思是子类具有基类的所有特性，也有着基类无法比拟、独特的属性信息。
●依赖倒置原则（DIP）依赖倒置（Dependence Inversion Principle）原则讲的是：要依赖于抽象，不要依赖于具体。
依赖倒置原则要求客户端依赖于抽象耦合。
原则表述：抽象不应当依赖于细节；细节应当依赖于抽象；要针对接口编程，不针对实现编程。
使用传统过程化程序设计所创建的依赖关系，策略依赖于细节，这是错误的，因为策略受到细节改变的影响。
依赖倒置原则使细节和策略都依赖于抽象，抽象的稳定性决定了系统的稳定性。
●接口隔离原则（ISP）接口隔离原则（Interface Segregation Principle）讲的是：使用多个专门的接口比使用单一的总接口总要好。
换而言之，从一个客户类的角度来讲：一个类对另外一个类的依赖性应当是建立在最小接口上的。
过于臃肿的接口是对接口的污染。
不应该强迫客户依赖于它们不用的方法。
实现方法是：使用委托分离接口；使用多重继承分离接口。
●合成/聚合复用原则（CARP）合成/聚合复用原则（Composite/Aggregate Reuse Principle或CARP）经常又叫做合成复用原则（Composite Reuse Principle或CRP），就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分；新对象通过向这些对象的委派达到复用已有功能的目的。
OOAD基本概念
OOAD基本概念学习⽬标：1.理解与掌握⾯向对象的概念与⽅法。
2.使⽤UML。
3.完成⾯向对象的分析与设计⼯作。
4.了解OO的设计原则及⼀些典型的设计模式什么是⾯向对象？1. ⾯向对象（Object-Orientation, 简称OO）是⼀种系统建模技术。
2. ⾯向对象编程（Object-Orientation Programming，简称OOP）是按照OO的⽅法学来开发程序的过程。
3. 通过分析系统内对象的交互来描述或建模⼀个系统。
4. 交互的对象最终以类的形式组织。
5. OO的⽅法由三部分组成：过程，标识，规则。
对象1. 是⼀个客观存在的、唯⼀的实体。
2. 是⾯向对象编程过程中分析与解决问题的出发点与基础。
3. 拥有⾃⼰的标识、数据与⾏为。
4. 可以简单或复杂。
5. 可以抽象或具体。
6. 在OOP中是⼀个类的动态实例。
7. 如Student—id,name,age(attribute)--setName,getName,countScore(methods)--new Student()类1. 类是对象的模板。
2. 对象通过类实例化产⽣。
3. ⼀个类可以创建多个对象OOADOOAD(Object Oriented Analysis and Design)，⾯向对象的分析与设计。
OOAD是根据OO的⽅法学，对软件系统进⾏分析与设计的过程。
--OOA 分析阶段--OOD 设计阶段定义OOA阶段1. 分析阶段主要解决以下问题-- 建⽴针对业务问题域的清晰视图。
-- 列出系统必须完成的核⼼任务。
-- 针对问题域建⽴公共词汇表。
-- 列出针对此问题的最佳解决⽅案。
2.此阶段要解决的核⼼问题是“What to do?”定义OOD阶段1.设计阶段主要解决以下问题-- 如何解决具体的业务问题。
-- 引⼊系统⼯作所需的⽀持元素。
-- 定义系统的实现策略2. 此阶段要解决的核⼼问题是“How to do?”OOP的主要特征1 .抽象（abstract）2.封装（encapsulation）3.继承（inheritance）4.多态（polymorphism）5.关联（association）6.聚合（aggregation）7.组合（composition）8.内聚与耦合（cohesion & coupling）抽象1. 忽略掉⼀个对象或实体的细节⽽只关注其本质特征的过程。
7大设计原则
7大设计原则
1. 简单性原则
设计应该尽可能简单。
简单的设计往往更易于理解和使用，而且
更不容易出错。
简单性原则可以应用于各种设计领域，包括软件设计、产品设计和网站设计等。
2. 可见性原则
设计应该使所有的操作和选项都可见。
用户应该能够清楚地看到
他们可以做什么和如何做。
可见性原则可以帮助用户更快地找到他们
所需要的信息和功能。
3. 反馈原则
设计应该提供反馈机制，让用户知道他们的操作是否成功。
反馈
可以是视觉、听觉或触觉的，它可以帮助用户更好地理解系统的运作
方式。
4. 一致性原则
设计应该保持一致性，使用户可以在不同的情况下都可以使用相
同的操作方式。
一致性原则可以减少用户的学习成本，提高用户的效率。
5. 容错性原则
设计应该具有容错性，使用户即使犯了错误也可以轻松地恢复。
容错性原则可以减少用户的焦虑感和压力感，提高用户的体验。
6. 灵活性原则
设计应该具有灵活性，使用户可以根据自己的需求和喜好进行自
定义设置。
灵活性原则可以提高用户的满意度和忠诚度。
7. 简洁性原则
设计应该尽可能简洁，避免过多的冗余信息和功能。
简洁性原则
可以帮助用户更快地找到他们所需要的信息和功能，提高用户的效率
和体验。
以上是7大设计原则，它们是设计师在进行设计时需要遵循的基
本原则。
这些原则可以帮助设计师设计出更好的产品和服务，提高用户的体验和满意度。
面向对象编程语言的设计与实现
面向对象编程语言的设计与实现面向对象编程（Object-Oriented Programming，OOP）是一种广泛使用的编程范paradimg，它的主要思想是将现实世界的事物抽象成对象，并通过对象之间的交互来实现程序的功能。
面向对象编程语言就是用来实现面向对象编程的工具，本文将探讨面向对象编程语言的设计与实现。
一、面向对象编程语言的特点面向对象编程语言具有以下几个特点：1. 封装性（Encapsulation）：面向对象编程语言允许将数据和方法封装在对象内部，通过公共接口进行访问。
这种封装性可以保护数据的安全性，同时提供了简洁而清晰的接口。
2. 继承性（Inheritance）：继承是面向对象编程语言中的重要概念，它允许从现有的类创建新的类。
通过继承，子类可以继承父类的属性和方法，并且还可以添加自己的特有属性和方法，从而实现代码的复用和扩展性。
3. 多态性（Polymorphism）：面向对象编程语言中的多态性指的是同一类型的对象在不同情境下可能展现出不同的行为。
通过多态性，可以写出更加灵活和可扩展的代码，同时减少代码的冗余。
二、面向对象编程语言的设计原则设计面向对象编程语言的时候，需要遵循一些重要的设计原则，以确保语言的可用性和灵活性：1. 单一职责原则（Single Responsibility Principle）：一个类或者对象只应该有一个引起它变化的原因。
这个原则可以确保类的职责单一，减少代码的耦合性，提高代码的可维护性。
2. 开放封闭原则（Open-Closed Principle）：软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。
这个原则可以提高代码的可扩展性和重用性。
3. 里氏替换原则（Liskov Substitution Principle）：子类对象可以替换父类对象，而程序的行为不变。
遵循这个原则可以确保代码的正确性和一致性。
4. 接口隔离原则（Interface Segregation Principle）：使用多个专门的接口，而不是使用单一的总接口。
java的设计原则
java的设计原则Java是一种广泛使用的编程语言，它的设计原则涉及到很多方面，包括可读性、可维护性、灵活性等。
本文将对Java的设计原则进行详细介绍。
一、SOLID原则SOLID原则是面向对象编程中的五个基本原则，它们分别是单一职责原则（SRP）、开放封闭原则（OCP）、里氏替换原则（LSP）、接口隔离原则（ISP）和依赖倒置原则（DIP）。
这些原则可以帮助我们设计出更加健壮、灵活和可扩展的代码。
1. 单一职责原则单一职责原则指一个类只负责一个功能或者任务。
这样可以提高代码的可读性和可维护性，同时也降低了类之间的耦合度。
2. 开放封闭原则开放封闭原则指软件实体应该对扩展开放，对修改关闭。
这意味着当需求发生变化时，我们不需要修改已有的代码，而是通过扩展来满足新需求。
3. 里氏替换原则里氏替换原则指子类可以替换掉父类并且不会影响程序的正确性。
这意味着在使用继承时，子类需要保持和父类一致的行为和约束。
4. 接口隔离原则接口隔离原则指一个类不应该依赖它不需要的接口。
这样可以避免因为接口改变而导致的代码修改。
5. 依赖倒置原则依赖倒置原则指高层模块不应该依赖低层模块，而是应该依赖其抽象。
这样可以降低模块之间的耦合度，提高代码的可复用性。
二、DRY原则DRY原则指“Don't Repeat Yourself”，即不要重复自己。
这意味着我们应该尽可能地避免重复代码，而是把相同或相似的功能抽象成一个公共部分，以提高代码的可维护性和可扩展性。
三、KISS原则KISS原则指“Keep It Simple, Stupid”，即保持简单。
这意味着我们应该尽量避免过度设计和复杂实现，而是采用简单明了的方式来解决问题，以提高代码的可读性和可维护性。
四、YAGNI原则YAGNI原则指“You Ain't Gonna Need It”，即你不会需要它。
这意味着我们应该尽可能地避免过度设计和实现，在真正需要时再进行扩展和修改，以提高代码的简洁性和可维护性。
程序设计七大原则
软件设计的七大原则设计模式遵循的一般原则：1.开-闭原则(Open-Closed Principle, OCP):一个软件实体应当对扩展开发,对修改关闭.说的是,再设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展.换言之,应当可以在不必修改源代码的情况下改变这个模块的行为，在保持系统一定稳定性的基础上，对系统进行扩展。
这是面向对象设计（OOD）的基石，也是最重要的原则。
2.里氏代换原则(Liskov Substitution Principle,常缩写为.LSP)(1).由Barbar Liskov(芭芭拉.里氏)提出，是继承复用的基石。
(2).严格表达:如果每一个类型为T1的对象o1,都有类型为T2的对象o2,使得以T1定义的所有程序P在所有的对象o1都代换称o2时,程序P的行为没有变化,那么类型T2是类型T1的子类型.换言之,一个软件实体如果使用的是一个基类的话,那么一定适用于其子类,而且它根本不能察觉出基类对象和子类对象的区别.只有衍生类可以替换基类，软件单位的功能才能不受影响，基类才能真正被复用，而衍生类也能够在基类的基础上增加新功能。
(3).反过来的代换不成立(4).<墨子.小取>中说:"白马,马也; 乘白马,乘马也.骊马(黑马),马也;乘骊马,乘马也."(5).该类西方著名的例程为:正方形是否是长方形的子类(答案是"否")。
类似的还有椭圆和圆的关系。
(6).应当尽量从抽象类继承,而不从具体类继承,一般而言,如果有两个具体类A,B有继承关系,那么一个最简单的修改方案是建立一个抽象类C,然后让类A和B 成为抽象类C的子类.即如果有一个由继承关系形成的登记结构的话,那么在等级结构的树形图上面所有的树叶节点都应当是具体类;而所有的树枝节点都应当是抽象类或者接口.(7)."基于契约设计(Design By Constract),简称DBC"这项技术对LISKOV代换原则提供了支持.该项技术Bertrand Meyer伯特兰做过详细的介绍:使用DBC,类的编写者显式地规定针对该类的契约.客户代码的编写者可以通过该契约获悉可以依赖的行为方式.契约是通过每个方法声明的前置条件(preconditions)和后置条件(postconditions)来指定的.要使一个方法得以执行,前置条件必须为真.执行完毕后,该方法要保证后置条件为真.就是说,在重新声明派生类中的例程(routine)时,只能使用相等或者更弱的前置条件来替换原始的前置条件,只能使用相等或者更强的后置条件来替换原始的后置条件.3.依赖倒置原则(Dependence Inversion Principle),要求客户端依赖于抽象耦合.(1)表述:抽象不应当依赖于细节,细节应当依赖于抽象.(Program to an interface, not an implementaction)(2)表述二:针对接口编程的意思是说,应当使用接口和抽象类进行变量的类型声明,参量的类型声明,方法的返还类型声明,以及数据类型的转换等.不要针对实现编程的意思就是说,不应当使用具体类进行变量的类型声明,参量类型声明,方法的返还类型声明,以及数据类型的转换等.要保证做到这一点,一个具体的类应等只实现接口和抽象类中声明过的方法,而不应当给出多余的方法.只要一个被引用的对象存在抽象类型,就应当在任何引用此对象的地方使用抽象类型,包括参量的类型声明,方法返还类型的声明,属性变量的类型声明等. (3)接口与抽象的区别就在于抽象类可以提供某些方法的部分实现,而接口则不可以,这也大概是抽象类唯一的优点.如果向一个抽象类加入一个新的具体方法,那么所有的子类型一下子就都得到得到了这个新的具体方法,而接口做不到这一点.如果向一个接口加入了一个新的方法的话,所有实现这个接口的类就全部不能通过编译了,因为它们都没有实现这个新声明的方法.这显然是接口的一个缺点.(4)一个抽象类的实现只能由这个抽象类的子类给出,也就是说,这个实现处在抽象类所定义出的继承的登记结构中,而由于一般语言都限制一个类只能从最多一个超类继承,因此将抽象作为类型定义工具的效能大打折扣.反过来,看接口,就会发现任何一个实现了一个接口所规定的方法的类都可以具有这个接口的类型,而一个类可以实现任意多个接口.(5)从代码重构的角度上讲,将一个单独的具体类重构成一个接口的实现是很容易的,只需要声明一个接口,并将重要的方法添加到接口声明中,然后在具体类定义语句中加上保留字以继承于该接口就行了.而作为一个已有的具体类添加一个抽象类作为抽象类型不那么容易,因为这个具体类有可能已经有一个超类.这样一来,这个新定义的抽象类只好继续向上移动,变成这个超类的超类,如此循环,最后这个新的抽象类必定处于整个类型等级结构的最上端,从而使登记结构中的所有成员都会受到影响.(6)接口是定义混合类型的理想工具,所为混合类型,就是在一个类的主类型之外的次要类型.一个混合类型表明一个类不仅仅具有某个主类型的行为,而且具有其他的次要行为.(7)联合使用接口和抽象类:由于抽象类具有提供缺省实现的优点,而接口具有其他所有优点,所以联合使用两者就是一个很好的选择.首先,声明类型的工作仍然接口承担的,但是同时给出的还有一个抽象类,为这个接口给出一个缺省实现.其他同属于这个抽象类型的具体类可以选择实现这个接口,也可以选择继承自这个抽象类.如果一个具体类直接实现这个接口的话,它就必须自行实现所有的接口;相反,如果它继承自抽象类的话,它可以省去一些不必要的的方法,因为它可以从抽象类中自动得到这些方法的缺省实现;如果需要向接口加入一个新的方法的话,那么只要同时向这个抽象类加入这个方法的一个具体实现就可以了,因为所有继承自这个抽象类的子类都会从这个抽象类得到这个具体方法.这其实就是缺省适配器模式(Defaule Adapter).(8)什么是高层策略呢?它是应用背后的抽象,是那些不随具体细节的改变而改变的真理. 它是系统内部的系统____隐喻.4.接口隔离原则(Interface Segregation Principle, ISP) （1）一个类对另外一个类的依赖是建立在最小的接口上。
php面向对象程序设计(OOP)的61条准则
(23)尽量减少类和协作者之间传递的消息的数量。
(24)尽量减少类和协作者之间的协作量，也即：减少类和协作者之间传递的不同消息的数量。
(25)尽量减少类的扇出，也即：减少类定义的消息数和发送的消息数的乘积。
(26)如果类包含另一个类的对象，那么包含类应当给被包含的对象发送消息。也即：包含关系总是意味着使用关系。
(27)类中定义的大多数方法都应当在大多数时间里使用大多数数据成员。
(28)类包含的对象数目不应当超过开发者短期记忆的容量。这个数目常常是6。
当类包含多于6个数据成员时，可以把逻辑相关的数据成员划分为一组，然后用一个新的包含类去包含这一组成员。
(29)让系统功能在窄而深的继承体系中垂直分布。
(10)把不相关的信息放在另一个类中(也即：互不沟通的行为)。
朝着稳定的方向进行依赖.
(11)确保你为之建模的抽象概念是类，而不只是对象扮演的角色。
(12)在水平方向上尽可能统一地分布系统功能，也即：按照设计，顶层类应当统一地共享工作。
(13)在你的系统中不要创建全能类/对象。对名字包含Driver、Manager、System、Susystem的类要特别多加小心。
(41)所有的抽象类都应当是基类。
(42)所有的基类都应当是抽象类。
(43)把数据、行为和/或接口的共性尽可能地放到继承层次体系的高端。
(44)如果两个或更多个类共享公共数据(但没有公共行为)，那么应当把公共数据放在一个类中，每个共享这个数据的类都包含这个类。
(45)如果两个或更多个类有共同的数据和行为(就是方法)，那么这些类的每一个都应当从一个表示了这些数据和方法的公共基类继承。
oop方案
OOP方案引言在软件开发中，面向对象编程（Object-Oriented Programming，OOP）是一种常用的编程范式。
它将程序设计和构建过程分为对象的定义和对象的实例化两个步骤，通过面向对象的思想和技术，使得软件的设计、开发和维护更加模块化和可扩展。
本文将介绍面向对象编程的基本概念、原则和常用的设计模式，以及如何使用OOP来设计和实现一个项目或系统。
面向对象编程的基本概念面向对象编程的基本概念包括类（Class）、对象（Object）、封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）等。
类（Class）类是面向对象编程的基本概念，它是对一类具有相同属性和方法的对象的抽象。
类定义了对象的结构和行为，它是对象的模板。
在面向对象编程中，类通常包括成员变量和成员方法。
成员变量是类的属性或状态，成员方法是类的行为或操作。
对象（Object）对象是类的实例，它具有类定义的属性和方法。
面向对象编程中的操作和数据都是通过对象进行的。
对象之间可以进行消息传递和交互。
一个对象通过调用其他对象的方法来实现自己的功能。
封装（Encapsulation）封装是面向对象编程的一个重要原则，它指的是将数据和操作封装在一个类中，通过访问控制来隐藏实现细节。
封装可以防止外部对类的直接访问和修改，只能通过类提供的公共接口来访问和操作。
这样可以增加程序的安全性和稳定性。
继承（Inheritance）继承是面向对象编程的另一个重要原则，它允许一个对象使用另一个对象的属性和方法。
通过继承，可以实现代码的重用和扩展。
在继承关系中，有一个基类（父类）和派生类（子类）的概念。
派生类可以继承基类的属性和方法，并且可以在此基础上添加新的属性和方法。
多态（Polymorphism）多态是面向对象编程的一个重要特性，它使得一个对象可以有多种形态。
多态可以实现方法的重载和重写，对于不同类型的对象可以有不同的行为。
OOP设计模式
OOP设计模式面向对象编程（OOP）是一种编程方法，它将现实世界中的概念和数据建模为程序中的对象。
OOP设计模式是一种通用的解决问题的策略，它为开发人员提供了一系列的经过验证的解决方案。
本文将介绍OOP设计模式及其优点。
1. 什么是OOP设计模式？OOP设计模式是一种在面向对象编程中使用的模式。
它是一组解决一般性问题的基本模板。
这些模板可以以一种通用的方式应用于不同的问题，并具有极高的可重用性。
OOP设计模式涉及的问题包括对象创建、对象关系、对象行为和状态管理。
2. OOP设计模式的优点OOP设计模式的优点在于，它能够解决许多复杂的设计问题。
OOP设计模式提供的组合方式提高了程序的可读性、健壮性和可维护性。
2.1 提高可读性OOP设计模式允许开发人员以一种通用的方式表达代码。
这种表达方式更易于理解和维护。
例如，观察者模式（Observer Pattern）被广泛应用于GUI开发中。
开发人员使用这种模式来建立对事件的响应，以更清晰和一致的方式来呈现和处理GUI元素。
2.2 提高健壮性OOP设计模式可以帮助开发人员创造高质量的代码。
将设计问题分解为可重用组件允许开发人员更仔细地测试和调试代码。
这些组件的可复用性还允许开发人员在以后的项目中使用它们，而不必通过重新编写代码来完成任务。
例如，单例模式（Singleton Pattern）在需要保证只有一个对象实例时非常有用。
2.3 提高可维护性OOP设计模式提供的可重用组件使得在项目中添加代码变得更加容易。
这些组件已经过测试，因此不需要改变已经可以正常工作的代码。
这使得开发人员能够专注于增加新的特性而不必担心改变既有代码的任何不必要的风险。
3. OOP设计模式的类型OOP设计模式包含很多种类型，每一种都解决了不同的问题。
以下是一些经典的OOP设计模式：3.1 单例模式 (Singleton Pattern)单例模式是一种常用的OOP设计模式。
该模式保证类只有一个实例，并提供全局访问点来访问该实例。
面向对象设计七大原则
⾯向对象设计七⼤原则1. 单⼀职责原则（Single Responsibility Principle）每⼀个类应该专注于做⼀件事情。
2. ⾥⽒替换原则（Liskov Substitution Principle）超类存在的地⽅，⼦类是可以替换的。
3. 依赖倒置原则（Dependence Inversion Principle）实现尽量依赖抽象，不依赖具体实现。
4. 接⼝隔离原则（Interface Segregation Principle）应当为客户端提供尽可能⼩的单独的接⼝，⽽不是提供⼤的总的接⼝。
5. 迪⽶特法则（Law Of Demeter）⼜叫最少知识原则，⼀个软件实体应当尽可能少的与其他实体发⽣相互作⽤。
6. 开闭原则（Open Close Principle）⾯向扩展开放，⾯向修改关闭。
7. 组合/聚合复⽤原则（Composite/Aggregate Reuse Principle CARP）尽量使⽤合成/聚合达到复⽤，尽量少⽤继承。
原则：⼀个类中有另⼀个类的对象。
细则单⼀职责原则（Single Responsibility Principle）因为：可以降低类的复杂度，⼀个类只负责⼀项职责，其逻辑肯定要⽐负责多项职责简单的多；提⾼类的可读性，提⾼系统的可维护性；变更引起的风险降低，变更是必然的，如果单⼀职责原则遵守的好，当修改⼀个功能时，可以显著降低对其他功能的影响。
需要说明的⼀点是单⼀职责原则不只是⾯向对象编程思想所特有的，只要是模块化的程序设计，都适⽤单⼀职责原则。
所以：从⼤局上看Android中的Paint和Canvas等类都遵守单⼀职责原则，Paint和Canvas各司其职。
⾥⽒替换原则（Liskov Substitution Principle）因为：⾥⽒替换原则告诉我们，在软件中将⼀个基类对象替换成它的⼦类对象，程序将不会产⽣任何错误和异常，反过来则不成⽴，如果⼀个软件实体使⽤的是⼀个⼦类对象的话，那么它不⼀定能够使⽤基类对象。
面向对象七大基本设计原则
面向对象七大基本设计原则面向对象设计原则是OOPS（Object-Oriented Programming System，面向对象的程序设计系统）编程的核心。
在设计面向对象的程序的时，模式不是一定要套的，但是有一些原则最好是遵守。
这些原则已知的有七个，包括：单一职责原则、开闭原则、里氏代换原则、依赖注入（倒转）原则、接口分离原则、迪米特原则、合成聚合复用原则。
原则一单一职责原则单一职责原则（SRP：Single responsibility principle）又称单一功能原则核心：解耦和增强内聚性（高内聚，低耦合）。
描述：类被修改的几率很大，因此应该专注于单一的功能。
如果你把多个功能放在同一个类中，功能之间就形成了关联，改变其中一个功能，有可能中止另一个功能，这时就需要新一轮的测试来避免可能出现的问题。
原则二里氏替换原则里氏替换原则（LSP：Liskov Substitution Principle）核心：在任何父类出现的地方都可以用他的子类来替代（子类应当可以替换父类并出现在父类能够出现的任何地方）四层含义：（1）子类必须完全实现父类的方法。
在类中调用其他类是务必要使用父类或接口，如果不能使用父类或接口，则说明类的设计已经违背了LSP原则。
（2）子类可以有自己的个性。
子类当然可以有自己的行为和外观了，也就是方法和属性（3）覆盖或实现父类的方法时输入参数可以被放大。
即子类可以重载父类的方法，但输入参数应比父类方法中的大，这样在子类代替父类的时候，调用的仍然是父类的方法。
即以子类中方法的前置条件必须与超类中被覆盖的方法的前置条件相同或者更宽松。
（4）覆盖或实现父类的方法时输出结果可以被缩小。
原则三依赖注入原则依赖注入原则（DIP：Dependence Inversion Principle）别名：依赖倒置原则或依赖反转原则核心：要依赖于抽象，不要依赖于具体的实现三层含义：（1）高层模块不应该依赖低层模块，两者都应该依赖其抽象（抽象类或接口）；（2）抽象不应该依赖细节（具体实现）；（3）细节（具体实现）应该依赖抽象。
OOAD-设计模式（一）概述
OOAD-设计模式（⼀）概述前⾔ 在我们很多时候设计代码都是需要⽤到各种不⼀样的设计模式的，接下来着⼏篇给⼤家领略⼀下设计模式。
知道设计模式的作⽤，以及在代码的具体体现。
很多时候我们看不懂代码就是因为我们不知道它使⽤的设计模式。
国庆的我很痛苦，学习是痛苦的，成长是快乐的！⼀、什么是⾯向对象1）⾯向对象(Object-Orientation,简称OO)是⼀种系统建模技术/编程思想。
2）⾯向对象编程(Object-Orientation Programming,简称OOP)是按照OO的⽅法学来开发程序的编程⽅式3）⾯向对象分析⽅法 Object-Oriented Analysis,简称OOA分析阶段主要解决以下问题：建⽴针对业务问题域的清晰视图列出系统必须要完成的核⼼任务针对问题域建⽴公共词汇表列出针对此问题域的最佳解决⽅案此阶段要解决的核⼼问题是"what to do?"4）⾯向对象设计Object-Oriented Design, 简称OOD设计阶段主要解决以下问题：如何解决具体的业务问题引⼊系统⼯作所需的各⽅⾯的⽀持元素定义系统的实现策略 此阶段要解决的核⼼问题是"How to do?"5）OO: ⾯向对象,是⼀套集编程思想,⽅法,原则,模式,解决⽅案等为⼀体的编程模式。
OO的思想贯穿于整个软件开发的过程,⽐如需求分析,设计,编程,测试,升级等。
综上可以知道什么是OOAD？OOAD（Object Oriented Analysis Design，的分析和设计，）是现代软件企业⼴为采⽤的⼀项有效技术。
OOAD⽅法要求在设计中要映射现实世界中指定中的对象和实体，例如：顾客、汽车和销售⼈员等。
这就需要设计要尽可能地接近现实世界，即以最⾃然的⽅式表述实体。
所以的优点即为能够构建与现实世界相对应的问题模型，并保持他们的结构、关系和⾏为为模式。
⼆、⾯向对象的特点2.1、抽象 抽象就是将⼀些事物的共性和相似点抽离出来，并将这些属性归为⼀个类，这个类只考虑这些事物的共性和相似之处，并且会忽略与当前业务和⽬标⽆关的那些⽅⾯，只将注意⼒集中在与当前⽬标有关的⽅⾯。
提高代码可重用性的方法和技巧
提高代码可重用性的方法和技巧代码的可重用性是指代码能够在不同的环境或需求下被重复使用的程度。
提高代码的可重用性可以减少代码的冗余，提高开发效率，减少错误，增强代码的可维护性。
下面将介绍一些提高代码可重用性的方法和技巧。
1.采用模块化设计(Modal Design)模块化是将代码分解为独立、可重用的组件的过程，可以将代码库组织成一系列相互独立的模块。
每个模块只关注特定的功能，具有清晰的接口定义。
通过模块化设计，可以提高代码的可重用性和组装性。
2.使用面向对象的编程(OOP)面向对象编程的主要思想是将代码按照对象的方式进行设计和实现，通过定义对象的属性和方法，以及对象之间的关系，将相关的代码组织在一起。
面向对象的编程可以提高代码的可重用性，通过继承、多态等特性可以轻松地扩展代码功能。
3.设计通用的接口(API)设计通用的接口可以使代码更易于重用。
通过定义清晰的输入和输出接口，外部使用者可以方便地调用和集成代码。
接口应该尽量简单、可扩展和灵活。
4.提取通用的功能模块在开发过程中，如果发现某些功能在不同的项目或场景中都有用到，可以将其提取为独立的模块，并将其放入单独的代码库中。
这样可以通过库的方式进行重用。
5.使用设计模式设计模式是一些常见的编程问题的解决方案，通过使用设计模式可以提高代码的可重用性和灵活性。
例如，工厂模式可以将对象的创建和使用分离，单例模式可以确保只有一个实例存在。
6.代码抽象和封装抽象和封装是代码重用的基础。
通过将功能相似的代码抽象成函数、类或组件的形式，并提供简单的接口和适当的参数，可以增加代码的可复用性，减少冗余。
7.单一职责原则在代码设计过程中，应遵循单一职责原则，将一个模块或类的职责控制在一个范围内。
这样可以增加代码的可维护性和可测试性，并降低修改代码时的风险。
8.测试驱动开发(TDD)测试驱动开发是指在编写代码之前先编写测试用例，并根据测试用例的要求来编写代码。
通过TDD可以保证代码的可测试性，并促使每段代码的可重用性。
设计的30个原则
设计的30个原则设计是一门创造性的艺术，它涵盖了许多不同的领域，包括产品设计、图形设计、用户界面设计等。
在设计中，有许多原则可以帮助我们创建出优秀的作品。
下面，我将介绍30个设计原则，帮助你提高设计水平。
1. 简约原则：简洁的设计更容易被人们理解和接受。
2. 一致性原则：保持设计元素的一致性，使用户感到熟悉和舒适。
3. 对比原则：使用对比来突出设计中的重要元素，增加视觉效果。
4. 平衡原则：在设计中平衡不同元素的分布，使整体看起来和谐。
5. 重复原则：通过重复使用相同的元素来建立统一感。
6. 对齐原则：将设计元素对齐，使整体看起来整洁有序。
7. 重点原则：通过突出重点来引导用户关注。
8. 合理布局原则：合理地组织设计元素，使用户可以轻松找到所需信息。
9. 可读性原则：确保设计中的文字清晰可读，不模糊或过小。
10. 可访问性原则：设计应该能够被所有人轻松理解和使用。
11. 色彩原则：选择合适的色彩方案，以增强设计的视觉吸引力。
12. 字体原则：选择适合设计风格的字体，使文字与整体风格相匹配。
13. 清晰度原则：确保设计中的图像和图标清晰可辨。
14. 空白原则：合理利用空白，使设计更加清爽和有序。
15. 流程原则：设计的流程应该是直观和易于理解的。
16. 可操作性原则：设计中的交互元素应该易于操作和使用。
17. 可预测性原则：设计应该符合用户的预期，减少用户的困惑。
18. 反馈原则：设计中的交互应该给用户及时反馈，让用户了解他们的操作结果。
19. 导航原则：设计中的导航应该简单明了，帮助用户快速找到所需信息。
20. 可扩展性原则：设计应该具有可扩展性，以适应不同的需求和平台。
21. 响应式原则：设计应该具有响应式布局，以适应不同的屏幕尺寸。
22. 故事性原则：设计中的元素应该能够讲述一个故事，吸引用户的兴趣。
23. 创新原则：设计应该具有创新性，与众不同，吸引用户的眼球。
24. 可维护性原则：设计应该易于维护和更新，以保持其活力和时效性。
面向对象设计的七大原则
⾯向对象设计的七⼤原则在上⼀篇⾥我们谈了谈为何设计模式，那接下来我们再浅谈⼀下在⾯向对象设计中我们常常要遵循的⼀些原则。
这些原则是经过⽆数的前⼈总结出来的经验的结晶。
仅仅有遵循这些原则。
你才有可能涉及出优秀的代码。
今天我们要谈的原则有七⼤原则，即：单⼀职责。
⾥⽒替换。
迪⽶特法则，依赖倒转，接⼝隔离，合成/聚合原则。
开放-封闭。
1. 开闭原则定义：软件实体应当对扩展开放，对改动关闭。
这句话说得有点专业。
更通俗⼀点讲，也就是：软件系统中包括的各种组件，⽐如模块（Modules）、类（Classes）以及功能（Functions）等等。
应该在不改动现有代码的基础上。
去扩展新功能。
开闭原则中“开”。
是指对于组件功能的扩展是开放的。
是同意对其进⾏功能扩展的。
开闭原则中“闭”。
是指对于原有代码的改动是封闭的，即不应该改动原有的代码。
问题由来：凡事的产⽣都有缘由。
我们来看看。
开闭原则的产⽣缘由。
在软件的⽣命周期内，由于变化、升级和维护等原因须要对软件原有代码进⾏改动时。
可能会给旧代码中引⼊错误，也可能会使我们不得不正确整个功能进⾏重构，⽽且须要原有代码经过⼜⼀次測试。
这就对我们的整个系统的影响特别⼤。
这也充分展现出了系统的耦合性假设太⾼，会⼤⼤的添加后期的扩展。
维护。
为了解决问题，故⼈们总结出了开闭原则。
解决开闭原则的根本事实上还是在解耦合。
所以。
我们⾯向对象的开发，我们最根本的任务就是解耦合。
解决⽅法：当软件须要变化时。
尽量通过扩展软件实体的⾏为来实现变化。
⽽不是通过改动已有的代码来实现变化。
⼩结：开闭原则具有理想主义的⾊彩。
说的⾮常抽象，它是⾯向对象设计的终极⽬标。
其它⼏条原则，则能够看做是开闭原则的实现。
我们要⽤抽象构建框架，⽤实现扩展细节。
2. 单⼀职责原则（Single Responsibility Principle）定义：⼀个类。
仅仅有⼀个引起它变化的原因。
即：应该仅仅有⼀个职责。
每个职责都是变化的⼀个轴线。
面向对象程序设计课堂笔记
面向对象程序设计课堂笔记一、什么是面向对象程序设计。
面向对象程序设计（Object-Oriented Programming，OOP）是一种编程范式，它将现实世界看作由各种对象组成，每个对象都具有不同的属性和行为，并且可以与其他对象进行交互。
二、面向对象程序设计的三大特征。
1. 封装（Encapsulation）。
封装是指将数据和操作数据的方法进行封装，构成一个类。
通过对外提供公共的方法和属性，类的内部实现可以隐藏起来，保证类的安全性和可维护性。
2. 继承（Inheritance）。
继承是指子类可以继承父类的属性和方法，并且可以在此基础上进行扩展。
这样可以提高代码的复用性和可维护性，同时也有助于层次化设计。
3. 多态（Polymorphism）。
多态是指同一个类的对象可以呈现不同的形态。
多态的实现是通过继承和接口实现的。
多态可以提高代码的灵活性和可扩展性。
三、面向对象程序设计的基本要素。
1. 类（Class）。
类是面向对象程序设计的基本组成单位，是一种抽象数据类型。
类的属性和方法决定了对象的特征和行为。
2. 对象（Object）。
对象是类的实例，每个对象都有自己的属性和方法，可以与其他对象进行交互。
3. 属性和方法（Property and Method）。
属性和方法是类的两个基本元素，属性是对象的特征或状态，方法是对象具有的行为或动作。
4. 继承（Inheritance）。
继承是一种代码复用的方式，子类可以继承父类的属性和方法，并且可以在此基础上进行扩展。
继承可以实现代码的层次化设计。
5. 重载（Overload）和重写（Override）。
重载是指在一个类中定义多个同名方法，但是参数类型、个数或顺序等不同，以提供更多的操作方式。
重写是指子类重写父类的方法，可以实现多态的功能。
6. 接口（Interface）。
接口是一种规范，规定了类必须实现的一组方法。
它可以实现多态和代码的松耦合。
四、面向对象程序设计的思想和技术。
面向对象程序设计的特点
面向对象程序设计的特点面向对象程序设计（Object-Oriented Programming，简称OOP）是一种编程范式，它使用“对象”来设计软件，并将数据和处理数据的方法结合在一起。
面向对象程序设计具有以下几个显著特点：封装性（Encapsulation）封装性是面向对象程序设计的核心概念之一。
它指的是将对象的实现细节隐藏起来，只暴露出一个可以被外界访问的接口。
这样做的好处是提高了代码的安全性和可维护性，因为对象的内部状态只能通过定义好的方法来访问和修改。
继承性（Inheritance）继承性允许新创建的类（子类）继承现有类（父类）的属性和方法。
这不仅减少了代码的重复，而且通过扩展现有类的功能，使得代码更加模块化。
继承还支持多态性，即同一个接口可以有不同的实现。
多态性（Polymorphism）多态性是指允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。
这使得代码更加灵活，可以编写出更加通用的代码，而不必担心对象的具体类型。
抽象性（Abstraction）抽象性是指通过创建抽象类或接口来定义对象的抽象特性。
这些抽象类或接口不提供具体的实现细节，而是定义了一组方法的签名，具体的实现由继承这些抽象类或实现这些接口的子类来完成。
这有助于简化设计和实现过程，使得开发者可以专注于对象的接口而不是具体的实现。
动态绑定（Dynamic Binding）动态绑定是指在程序运行时，根据对象的实际类型来调用相应的方法。
这与静态绑定不同，静态绑定是在编译时就确定调用哪个方法。
动态绑定是多态性实现的关键技术之一。
消息传递（Message Passing）在面向对象程序设计中，对象之间通过发送消息来交互。
每个对象都维护着一个接收消息的接口，当一个对象需要请求另一个对象执行操作时，它会发送一个消息给那个对象。
这种方式使得对象之间的耦合度降低，提高了代码的可重用性。
接口隔离原则（Interface Segregation Principle）接口隔离原则是面向对象设计的一个原则，它提倡将大型的接口拆分成更小的、特定的接口，这样客户端就可以只依赖于它们需要的接口。
OOP程序七大原则
OOP程序七⼤原则开闭原则开闭原则相当于所有原则的祖先，主张对修改关闭，对拓展开放．⾥⽒替换原则当两个类有继承关系时，⼦类不能修改⽗类的⽅法和变量,⾥⽒替换中的替换指的是：当有⽗类出现的地⽅，这个⽗类可以替换成⼦类，⽽且对程序没有影响，这就遵循了⾥⽒替换原则；当替换成⼦类时对程序有影响，说明⼦类修改了⽗类的⽅法，就没有遵循⾥⽒替换原则了；依赖倒置原则依赖倒置原则是对开闭原则的⼀个实现，也是主张对拓展开放，对修改关闭．它的核⼼思想是⾯对接⼝编程，不要⾯对具体实现编程．这是⼀个遵守依赖倒置原则的UML图，原来的话当客户购买商品时,shopping这个⽅法要传⼊相应的⽹店进去，当要更改店铺时，就要修改Cusromer这个类⾥的shopping⽅法，⽽现在，只要定义⼀个Shop接⼝，所有的店铺都实现这个接⼝的⽅法，顾客类的shopping⽅法只要传⼊Shop 这个接⼝类就可以了．然后具体实现的时候，要到哪⾥买，就传⼊哪⼀个⽹店就可以了，⽽不⽤修改Cusromer这个类的⽅法；//代码来之＇C语⾔中⽂⽹＇public class DIPtest{public static void main(String[] args){Customer wang=new Customer();System.out.println("顾客购买以下商品：");wang.shopping(new ShaoguanShop());wang.shopping(new WuyuanShop());}}//商店interface Shop{public String sell(); //卖}//韶关⽹店class ShaoguanShop implements Shop{public String sell(){return "韶关⼟特产：⾹菇、⽊⽿……";}}//婺源⽹店class WuyuanShop implements Shop{public String sell(){return "婺源⼟特产：绿茶、酒糟鱼……";}}//顾客class Customer{public void shopping(Shop shop){//购物System.out.println(shop.sell());}}//输出顾客购买以下商品：韶关⼟特产：⾹菇、⽊⽿……婺源⼟特产：绿茶、酒糟鱼……单⼀职责单⼀职责要求⼀个类只负责⼀项职责. 这个听起来很简单，但是实际应⽤上却⾮常的难把握．因为这个职责在中国是⾮常抽象的概念，中国是⼀个⽂化底蕴⾮常丰富的国家，就像<<设计模式之禅>>这本书⾥所说的例⼦：⽐如说中国的筷⼦，他既可以当⼑来分割⾷物，也可以当叉⼦来叉取⾷物，⽽在国外，叉⼦就是叉⼦，⽤来取⾷物的，⼑就是⽤来分割⾷物的；所以这个单⼀职责要求软件开发⼈员有⾮常丰富的实践经验．不然很难把握；迪⽶特法则迪⽶特法则也称最⼩知道原则，⼀个类对外暴露的东西越少越好．1. 从依赖者的⾓度来说，只依赖应该依赖的对象。
oop七大原则
面向对象编程(OOP)的七大原则是：
单一职责原则(SRP)：一个类应该只有一个引起它变化的原因。
开放封闭原则(OCP)：软件实体应该对扩展开放，对修改封闭。
里氏替换原则(LSP)：所有引用基类对象的地方必须能透明地使用其子类的对象。
依赖倒置原则(DIP)：高层模块不应该依赖低层模块，它们应该依赖于抽象接口。
接口隔离原则(ISP)：客户端不应该强制依赖于它们不需要的接口。
合成/聚合复用原则(CARP)：尽可能使用对象组合/聚合，而不是继承来达到复用的目的。
迪米特法则(LKP)：一个对象应该对其他对象有最少的了解。
这些原则是面向对象编程设计的基础，遵循它们可以使代码更具扩展性、可维护性和可读性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
七、迪米特法则
迪米特法则说的是一个对象应该对其它对象有尽可能少的了解。即只与你直接的朋友通信，不要跟陌生人说话。如果需要和陌生人通话，而你的朋友与陌生人是朋友，那么可以将你对陌生人的调用由你的朋友转发，使得某人只知道朋友，不知道陌生人。换言之，某人会认为他所调用的是朋友的方法。 以下条件称为朋友的条件： 当前对象本身。 以参量的形式传入到当前对象方法中的对象。 当前对象的实例变量直接引用的对象。 当前对象的实例变量如果是一个聚集，那么聚集中的元素也都是朋友。 当前对象所创建的对象。 任何一个对象，如果满足上面的条件之一，就是当前对象的朋友，否则就是陌生人。 迪米特法则的主要用意是控制信息的过载，在将其运用到系统设计中应注意以下几点： 在类的划分上，应当创建有弱耦合的类。类之间的耦合越弱，就越有利于复用。 在类的结构设计上，每一个类都应当尽量降低成员的访问权限。一个类不应当public自己的属性，而应当提供取值和赋值的方法让外界间接访问自己的属性。 在类的设计上，只要有可能，一个类应当设计成
六、合成、聚合复用原则
合成、聚合复用原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部份，新的对象通过向这些对象的委派达到复用已有功能的目的。这个原则有一个简短的描述：要尽量使用合成、聚合，尽量不要使用继承。合成、聚合有如下好处：
新对象存取成分对象的唯一方法是通过成分对象的接口。
五、接口隔离原则
接口隔离原则讲的是：使用多个专门的接口比使用单一的接口要好。从客户的角度来说：一个类对另外一个类的依赖性应当是建立在最小的接口上的。如果客户端只需要某一些方法的话，那么就应当向客户端提供这些需要的方法，而不要提供不需要的方法。提供接口意味着向客户端作出承诺，过多的承诺会给系统的维护造成不必要的负担。
这种复用是黑箱复用，因为成分对象的内部细节是新对象所看不到的。
这种复用可以在运行时间内动态进行，新对象可以动态的引用与成分对象类型相同的对象。
合成、聚合可以应用到任何环境中去，而继承只能应用到一些有限环境中去。 导致错误的使用合成、聚合与继承的一个常见原因是错误的把“Has-a”关系当作“Is-a”关系。如果两个类是“Has-a”关系那么应使用合成、聚合，如果是“Is-a”关系那么可使用继承。
四、依赖倒置原则
依赖倒置原则讲的是：要依赖于抽象，不要依赖于具体。即针对接口编程，不要针对实现编程。针对接口编程的意思是，应当使用接口和抽象类进行变量的类型声明、参量的类型声明，方法的返还类型声明，以及数据类型的转换等。不要针对实现编程的意思就是说，不应当使用具体类进行变量的类型声明、参量的类型声明，方法的返还类型声明，以及数据类型的转换等。 依赖倒置原则虽然强大，但却不易实现，因为依赖倒置的缘故，对象的创建很可能要使用对象工厂，以避免对具体类的直接引用，此原则的使用还会导致大量的类。维护这样的系统需要较好的面向对象的设计知识。 此外，依赖倒置原则假定所有的具体类都是变化的，这也不总是正确的。有一些具体类可能是相当稳定、不会发生变化的，消费这个具体类实例的客户端完全可以依赖于这个具体类。
面向对象的七大设计原则
一、单一职责原则
就一个类而言，应该仅有一个引起它变化的原因。软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离。测试驱动的开发实践常常会在设计出现臭味之前就迫使我们分离职责。
二、“开一闭”原则讲的是：一个软件实体应当对扩展开放，对修改关闭。 这个规则说的是，在设计一个模块的时候，应当使这个模块可以在不被修改的前提下被扩展。 从另外一个角度讲，就是所谓的“对可变性封装原则”。“对可变性封装原则”意味着两点： 1 .一种可变性不应当散落在代码的很多角落里，而应当被封装到一个对象里面。同一种可变性的不同表象意味着同一个继承等级结构中的具体子类。 2.一种可变性不应当与另一种可变性混合在一起。即类图的继承结构一般不应超过两层。 做到“开—闭”原则不是一件容易的事，但是也有很多规律可循，这些规律同样也是设计原则，它们是实现开—闭原则的工具。
在对其它对象的引用上，一个类对其它对象的引用应该降到最低。
-----------------------注：面向对象的设计原则有很多，但在此列出的七种设计原则必须要掌握------------------------------------