OOAD与设计模式

一、面向对象的概念
谈谈你对面对对象的理解:


OOAD(Object Oriented Analysis Design):面对对象的分析和设计
面向对象(Object-Orientation,简称OO)是一种系统建模技术/编程思想。
面向对象编程(Object-OrientationProgramming,简称OOP)是按照OO的方法学来开发程序的编程方式。
OO: 面向对象，是一套集编程思想，方法，原则，模式，解决方案  等为一体的编程模式。
oo的思想贯穿于整个软件开发的过程。






oo,ooa,ood,oop


服务于：软件开发。


了解软件开发流程：


需求分析(效果,what to do)----设计(how to do)----编码(do开发)-----测试----部署
javaWeb项目
需求分析:
用户提需求-->用户并不能很专业地说出自己的需求，想要什么，要什么样的效果（提示）-->在与用户接下来的沟通中，引导用户，对需求做出更详细的描述（分析，程序设计的思路），有方向的引导用户，说一个需求，要不A？要不B？要不C？要，全都要，时间、困难度。风险控制。
分析过程：


货车租售--网站，app（改需求：支付/登录,登录功能，界面，参考淘宝--发给用户，效果图）


货车，买一辆车--导购（专业，参数） 特性分析（三轮车，轿车/四个轮，方向盘，）


设计:


编码(开发)：


测试(测试)：




部署上线：javaEE
 Web项目


维护（运维）：






oo：面向对象


  elephant/fridge
大象  装  冰箱
1.打开冰箱
2.把大象存储进冰箱
3.关住冰箱
动作,过程


面向对象:
1.冰箱  打开
2.冰箱  存储
3.冰箱  关门
面对对象：
elephant/fridge
elephant{


}
public class fridge{
open()
store(elephant e)
close()
}




lecture/study
讲课与听课
(老师讲课，学生听课)
Teache
List<Student>
lecture()
Student
List<Teache>
study()


面对对象的特征
1.封装
信息的隐藏，实现行为细节的隐藏(访问修饰符)
缩减代码
person{
   private String name
   private Person(String name){}
   private void method1(){
  //实现细节的隐藏
   }
}
 p = new Peson("张三");
 p.name="李四"; p.name=""


属性隐藏：公共的访问入口


public:外界
protected:本类中+相同包+不同包继承
default:本类中+相同包
private:本类中


2.继承：满足is a,is kind of语义关系
作用：实现父类代码的复用，简化子类的构建过程
实现方式：extends
  特征:类只能单继承---（）
  子类能继承父类非私有的属性和行为，父类的构造器不能被继承。
  子类在创建时显示或者隐式调用父类的构造器。
  类，有参构造器，随手加上无参构造器。


3.多态：多种表现形态,相同类域下的不同对象调用相同的方法时，表现不同
1.子父类继承/接口的实现
2.子类需要重写父类的方法/实现
3.父类类型的引用指向子类的对象/接口
4.调用重写的方法
animal{
static eat(){"a eat"}
shout(){"shout"}
}
dog extends animal{
eat(){"d eat"}
shout(){"wangwang"}
}
animal a = new Dog(); a.shout--wangwang


4.运行时多态/编译时多态
重写：（继承）
1.方法名相同
2.参数列表相同（类型，位置，个数）
3.返回类型一致
4.访问权限不能被缩小，异常不能被扩大


注意：静态方法只能被静态方法重写，但是没有多态的体现。
重载：
1.方法名相同
2.参数列表不同
3.与返回类型无关。






指导开发高质量软件产品的一个指导性原则，贯穿整个软件开发的过程，包含设计原则，设计模式等等内容...


二、OOAD是根据OO的方法学，对软件系统进行分析和设计的过程。
-----OOA 分析阶段
分析阶段主要解决以下问题：
建立针对业务问题域的清晰视图
列出系统必须要完成的核心任务
针对问题域建立公共词汇表
列出针对此问题域的最佳解决方案


此阶段要解决的核心问题是"what to do?"


-----OOD 设计过程
设计阶段主要解决以下问题：
如何解决具体的业务问题
引入系统工作所需的支持元素
定义系统的实现策略


此阶段要解决的核心问题是"How to do?"


oop:面向对象的编程
面向对象的编程：
1.对象：对象是唯一的，万物皆对象。
对象是具体的存在。
对象具有状态。
对象可以通过自身的行为改变状态。


2.类(模板)：抽象对象所具有的共有特征 和行为封装的模板
类是抽象的概念。
抽象类--接口


OO的编程要素
1.对象:
1.域对象：主要目标是作为信息的载体存在，用来在各个层面进行数据的传递，信息的交互。一般在这种类(模板)中，提供属性以及属性取值和设置的方法。常见pojo，javabean...
register:name,password,hobby,gender..
文件中：对象(user:name="",password="",hobby="",gender="")
login:
User{
  private String username;
  private String password;
  private String gender;
  private int age;


  public String getUsername(){


  }
  public String setUsername(){


  }
}




2.行为对象：更关注的行为以及逻辑的处理。常见的是接口的实现类。
computer   Store,mouse
USBInterface{
driver();
../
../
../
}
Store implements USBInterface{
driver(){"存储"};
}
mouser  driver(){"点击"}
computer{
/*run(Store/mouse){
"存储","点击"
}*/
run(USBInterface userImple){
userImple.driver();
}
}
鼠标，存储
if()else if(){ }else if(){ }
标准，规则USB




2.消息：方法
一般情况下，单独的类基本上很少出现。通常借助于其他的类共同完成业务操作或者进行任务描述。


OO的编程过程中核心原则：
1.尽量能使用封装的特性就使用封装
2.面向接口编程。
3.重 组合/聚合 轻继承。
继承：类与类之间的关系
实现：实现类与接口
OO的编程要素：


依赖：use a对于两个相对独立的对象，当一个对象负责构造另一个对象的实例，
或者依赖另一个对象的服务时，这两个对象之间主要体现为依赖关系,偶然性。
作为方法的参数
A a(B b){},B


关联关系：对于两个相对独立的对象，当一个对象的实例与另一个对象的
一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。
类的成员变量
A b B List<a>
    关联关系又可总体分为聚合关系和组合关系。
    聚合关系和组合关系的特点及其区别:
    注意:聚合、组合主要是从意义上来讲的


      1.聚合关系也称"has-a"关系,组合关系也称"contains-a"关系


当对象A被加入到对象B中，成为对象B的组成部分时，对象B和对象A之间为聚集关系。
聚合是关联关系的一种，是较强的关联关系，强调的是整体与部分之间的关系。
汽车   轮胎
公司   员工
学校   学生


具体表现：与关联关系一样，聚合关系也是通过实例变量来实现这样关系的。
关联关系和聚合关系来语法上是没办法区分的，从语义上才能更好的区分两者的区别。


关联关系所涉及的两个对象是处在同一个层次上的。聚合关系涉及的两个对象处于不平等的层次上，
一个代表整体，一个代表部分。比如电脑和它的显示器、键盘、主板以及内存就是聚集关系，
因为主板是电脑的组成部分。


         聚合（Aggregation）：---Has a---------人拥有电脑
组合（Composition）：---Contains a---人是由脚、身体、头等部分组成的


    2.聚合关系表示事物的整体/部分关系的较弱情况,组合关系表示事物的整体/部分关系的较强的情况.
    :不同生共死（生命周期）  同生共死（生命周期是关联的）
    人-- --大脑
    人-- --心脏


    3.在聚合关系中,代表部分事物的可以属于多个聚合对象,可以为多个聚合对象共享,而且可以随时改
变它所从属的聚合对象.代表部分事物的对象与代表聚合事物对象的生存期无关,一旦删除了它的一个聚合对象,
不一定也就随即删除代表部分事物的对象.在组合关系中,代表整体事物的对象负责创建和删除代表部分事物的
对象,代表部分事物只属于一个组合对象.一旦删除了组合对象,也就随即删除了相应的代表部分事物的对象.


面向对象编程步骤：
  1.查找对象/抽取对象
  2.根据对象抽象模板
  3.分析对象和对象之间(类与类)的关系
  4.操作对象的属性和行为。


   ship
  张三让汽车跑起来
1.张三，汽车
2.person{String name; let()}
  Car{run()}
3.let(Car car){car.run();}
4.p = new Person("张三")
  Car = new Car();
  p.let(car);


交通工具Ce implemnts inter1
car 继承（抽象类）
ship 实现(接口)
car  extends ce{}
car implements ce,ce2,ce3{}


abstract:
height,name,color,desc...
animal,shout,run,eat,sleep,
     study
interface:


USBInterface{
driver()
}


抽象类和接口
1）.语法角度：
Interface:
  属性：public static final
  方法：abstract
只能被实现。


Class:abstract来修饰的。
  属性：
  方法：可以是普通方法，
 可以是abstract修饰的。
目的被继承。
2）设计角度：
一个类可以实现多个接口但是一个类只能继承一个父类。
接口和抽象类的设计，都是在有意识的规避java不能多继承的操作
接口 --- 》抽象类(接口是抽象类的极致的抽象)
3）思想角度：
1.类进行抽象的时候是否关注属性
  yes 抽象类   no interface
2.尽量让问题域独立存在，根据操作选择合适的抽象类或接口来进行操作。


人吃香蕉、苹果、梨、、、
Person{
eat(Banana b){
"吃"+color+name+", 可"+....
};
}


Fruit{
String name
shape
color
...
}
banana extends Fruit{


}


apple{


}


pear{


}


门有开关的功能
//电器
Interface onoff{
open();
close();
//alarm();
//
}
//警示..
Interface alarm{
alarm();
//...
//...
}
MyDoor1,MyDoor2,MyDoor3
MyDoor1 impelments onoff,alarm{
open(){"推着开"}
close(){"拉着关"}
}
MyDoor2 implements onoff,alarm{
open(){""}
close(){""}
}
门加上报警的功能alarm




四、面向对象设计原则,
---设计模式（23）




在实际开发中，我们想要更加深入的了解面向对象的思想，
就必须熟悉前人总结过的面向对象思想设计的原则。


面向对象设计的原则的核心：可重用，可扩展，高内聚，低耦合
（1）单一职责原则（Single-Resposibility Principle）


其实就是开发人员所说的“高内聚，低耦合“。也就是说，
每个类应该只有一个职责，对外只提供一种功能，
而引起类变化的原因也只有一个，在设计模式中，
所有的设计模式都遵循这一原则。
request,response,httpCreator,
httpAccessprocessor
一个类只负责自己的事情，其他的类的功能，可以去使用其他类的功能




（2）开闭原则（Open-Closed principle）
一个软件、一套系统在开发完成后，当有增加或修改需求时，应该对拓展代码打开，对修改原有代码关闭。
这是面向对象设计中，最重要最核心的原则，是其他原则的根本


其核心思想是：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。
开放封闭原则主要体现在两个方面1、对扩展开放，意味着有新的需求或变化时，可以对现有代码
进行扩展，以适应新的情况。2、对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，
而不要对其进行任何尝试的修改。


（3）里氏替换原则（Liskov-Substituion Principle）


任何父类出现的地方都可以使用子类来代替。
其实也就是说，同一继承体系中的对象应该有共同的行为特征。
A(B b){b.shout();}
(B2 b2){b2.shout();}
多态:


（4）依赖倒转原则（Dependecy-Inversion Principle）


其核心思想：抽象不应该依赖细节，细节应该依赖抽象。


针对接口编程，而不是针对实现编程。
run(bus ){bus.run }


if(01){


}else(02){}


（5）接口分离原则（Interface-Segregation Principle）


其核心思想：不要强迫程序依赖它们不需要的方法。
其实也就是说，一个接口不需要提供太多的行为，
一个接口对外应该只提供一种功能，
不应该把所有的操作都封装到一个接口中。


这里有两点需要说明一下：
GUI：
Listener:负责的事情
mouseListener:
mouseMoMtionListener:


ActionListener:1ge


1.接口定义的小，但是要有限度。
对接口细化可以增加灵活性，但是过度细化则会使设计复杂化。
同时接口的使用率不高，提高了代码的维护成本。
这种极端的体现就是每个接口只含有一个方法，
这显然是不合适的。


2.接口隔离原则和单一原则的区别


共同点：都是尽可能的缩小涉及的范围。


不同点：单一原则主要是指封装性。他针对的是一个类、一个方法，
是从对象的角度考虑的。而接口隔离原则是指类之间的耦合应该
保持的一个度。他针对的是类（对象）和类（对象）之间的关系。
如果说单一原则指的是思想单纯，那么接口隔离指的就是社会关系简单。




（6）迪米特原则（Law of Demeter）
Only talk to your immediate friends。


又叫最少知识原则（Least Knowledge Principle LKP），就是说一个对象应当对其
他对象有尽可能少的了解，不和陌生人说话。
迪米特法则的目的在于降低类之间的耦合。由于每个类尽量减少对其他类的依赖，
因此，很容易使得系统的功能模块相互独立，相互之间不存在依赖关系。


customer 1:n order


customer{
List<order>
List<orderLine>
}
order{
Customer
}
orderLine{
order
Customer
}