OOAD
什么是
OOAD?
面向对象的分析与设计
,
使用面向对象的思想对一个系统的分析与设计
UML:
什么是
UML?
统一的建模语言
,
什么是建模
?
将客观事物图形化
,
比如盖楼房
,
首先要把地基打好
统一指的是什么
?
在计算机领域有很多的图形语言
,
这样就需要一个标准
,UML
就是这样的一个标准
,
建模就是将需求用图的方式表达出来
UML
的组成
:
1.
元素
:
角色
,
用例
2.
图形
3.
扩展机制
:
扩展基本元素功能的机制
图形分类
:
静态图
,
动态图
静态图
:
类图
(
描述类与类之间关系的图
),
对象图
,
部署图
(
拓扑结构
),
组件图
,
用例图
(
从客户的角度来描述系统的整个功能
)
动态图
:
协作图
(
按空间的交互图
),
序列图
(
时序图
,
描述多个对象按时间的交互过程
),
活动图
(
描述业务流程
,
也能做一个操作的建模
),
状态图
(
描述单个的对象
,
或者是单个的子系统的状态变化
)
类图
:
类图
,
描述类与类之间关系的图
例子
:
图书管理系统
1.
利用
OO
的思想找对象
:
如
:
图书管理员
,
借书人
,
库存管理人员
,
书籍等等
2.
把他们抽象出来
:
找到与业务有关系的对象和对象的属性
3.
形成类
,
画出类图来
4.
实例并建立实例间的通讯
类之间的关系
:
1.
继承
2.
实现
3.
关联
4.
依赖
5.
聚合
6.
组合
什么是关联
?
类的属性使用的是另一个类的引用或者是对象
什么是依赖
?
除了属性
,
其他地方使用了另一个类的对象
,
引用
,
属性
,
方法就叫
A
类依赖
B
类
/**
*
知识点
:
*
关联
*
程序目标
:
* java
文件说明
:
* A.java
* B.java
* Test.java:
*
让
A
和
B
关联起来
,
让
A
类调用
B
类的方法
,
让
B
类使用
A
类的方法
*/
package MY.module01.leitu.guanlian;
public class Test {
public static void test(){
A a=new A();
B b=new B();
a.setB(b);
b.setA(a);
a.getB().bf();
b.getA().af();
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Test.test();
}
}
package MY.module01.leitu.guanlian;
public class A {
private B b;
public A() {
super();
// TODO Auto-generated constructor stub
}
public A(B b) {
super();
// TODO Auto-generated constructor stub
this.b = b;
}
public B getB() {
return b;
}
public void setB(B b) {
this.b = b;
}
public void af(){
System.out.println("A's af()");
}
}
package MY.module01.leitu.guanlian;
public class B {
private A a;
public B() {
super();
// TODO Auto-generated constructor stub
}
public B(A a) {
super();
// TODO Auto-generated constructor stub
this.a = a;
}
public A getA() {
return a;
}
public void setA(A a) {
this.a = a;
}
public void bf(){
System.out.println("B's bf()");
}
}
/**
*
知识点
:
*
依赖的三种情况
*
程序目标
:
* java
文件
:
* A.java
* B.java
*
一个类的方法去使用另一个类的元素
*/
package MY.module01.leitu.yilai;
public class A {
public void a1(B b){
int rst=b.add(1,2);
System.out.println(rst);
}
public void a2(){
B b=new B();
int rst=b.add(1,2);
System.out.println(rst);
}
public void a3(){
int rst=B.add2(10,20);
System.out.println(rst);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
A a=new A();
a.a1(new B());
a.a2();
a.a3();
}
}
package MY.module01.leitu.yilai;
public class B {
public int add(int i,int j){
return i+j;
}
public static int add2(int i,int j){
return i+j;
}
}
什么是聚合
?
比如说同学聚会
,
有很多的同学聚集在一起
,
但是
,
缺少几个也没有什么关系
什么是组合
?
比如说人
,
有心脏
,
肝
,
肺
,
组成为一个人
,
如果少了其中的一部分
,
就会死掉
,
谁也离不开谁
静态图
:
用例图
从客户的角度来描述系统的整个过程
组成
:
角色
,
用例
,
关联
角色之间的关系
:
继承关系
,
依赖关系
例如
:
客户是一个角色
,
客户分为大客户
,
小客户
,
这是继承关系
借书人和图书管理员就是依赖关系
用例的关系
:
包含
,
扩展关系
例如
:
借书功能
:
登陆
,
查询等
,
这个是包含
静态图
:
部署图
整个系统的软硬件拓扑结构
如
:CPU,eclipes
等
静态图
:
组件图
表示物理的实现
,
实现指的是代码
,
这个用的少
动态图
:
序列图
按时间的先后顺序描述对象之间的交互
/**
*
知识点
:
*
模拟序列图的执行
*
程序目标
:
* java
文件
:
* Client.java:
调用
MainController
类的方法
* MainController.java:
这个方法中调用了
Service
类的方法
* Service.java:
这个类的方法调用了另一个类的方法
* DAO.java:
这个类的方法调用自身的一个方法
,
这叫反身消息
*/
package MY.module01.leitu.xulietu;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MainController m=new MainController();
m.f();
}
}
package MY.module01.leitu.xulietu;
public class MainController {
public void f(){
Service s=new Service();
s.f();
}
}
package MY.module01.leitu.xulietu;
public class Service {
public void f(){
DAO d=new DAO();
d.genName();
}
}
package MY.module01.leitu.xulietu;
public class DAO {
public void genName(){
System.out.println("hello");
f();
}
private void f(){
System.out.println("dao's shi fan shen");
}
}
动态图
:
活动图
可以有分之的判断
动态图
:
状态图
可以看到对象的状态变化
设计模式
:
为什么要设计
?
1.
软件的复用
2.
软件的维护
开闭原则
:
对高层的修改关闭
,
对低层的扩展开放
模板方法
:
它实现了开闭原则
/**
*
知识点
:
*
开
-
闭原则
:
模板方法
*
程序目标
:
* java
文件
:
* CET6.java:
高层的逻辑
,
只开发了给低层用的方法
,
听
,
说
* ConcretCET6.java:
这里来实现听
,
说
* TestCET6.java
*/
package MY.module01.sjms.kbyz;
public class TestCET6 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
CET6 c=new ConcretCET6();
c.passCET6();
}
}
package MY.module01.sjms.kbyz;
public abstract class CET6 {
//
高层业务逻辑
public final void passCET6(){
listen();
say();
}
//
提供给低层实现的业务
abstract protected void listen();
abstract protected void say();
}
package MY.module01.sjms.kbyz;
public class ConcretCET6 extends CET6{
@Override
protected void listen() {
// TODO Auto-generated method stub
System.out.println("listen");
}
@Override
protected void say() {
// TODO Auto-generated method stub
System.out.println("say");
}
}
里氏代换原则
:
任何父类适用的地方
,
子类一定适用
,
子类可以当父类用
策略模式
:
实现了里氏代换原则
,
解决了可选算法的问题
什么是策略模式
?
针对共同的问题
,
提供解决方案或指导原则或好坏结果
/**
*
知识点
:
*
里氏代换原则
:
策略模式
*
程序目标
:
*
打折的例子
,
涉及到可选算法的问题
* java
文件
:
* Context.java:
打折的方法和设置折扣的方法
,
和
DisCount
为关联关系
*
这里体现了里氏代换原则
,
子类当父类用
* DisCount.java:
打折算法抽象类
* dis1.java:
打折算法
1
* dis2.java:
打折算法
2
* Client.java:1.
设置折扣率
,2.
打折
*/
package MY.module01.sjms.celuemoshi;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Context c=new Context();//
算法选择器
// c.setD(new dis2());
c.setD(new dis1());//
选择折扣
c.getprice(100);//
打折
}
}
package MY.module01.sjms.celuemoshi;
public class Context {
private DisCount d;
public void setD(DisCount d) {
this.d = d;
}
public void getprice(double price){
System.out.println(d.discout(price));
}
}
package MY.module01.sjms.celuemoshi;
public class dis1 extends DisCount{
@Override
public double discout(double price) {
// TODO Auto-generated method stub
return price*0.8;
}
}
package MY.module01.sjms.celuemoshi;
public class dis2 extends DisCount{
@Override
public double discout(double price) {
// TODO Auto-generated method stub
return price;
}
}
package MY.module01.sjms.celuemoshi;
public abstract class DisCount {
public abstract double discout(double price);
}
依赖倒转原则
:
什么是依赖倒转原则
?
要依赖抽象
,
不要依赖具体实现
这句话是什么意思呢
?
抽象指的是什么
?
具体实现指的又是什么
?
谁要依赖抽象
?
一个程序要按照高层的设计思路来实现具体的程序功能
,
抽象就是高层
,
具体实现就是为了完成高层的一个目标而写的程序代码
,
高层就是战略
,
低层是战术
,
高层是整体目标
,
低层是目标的实现
,
高层是思想
,
低层是行为
什么是倒转
?
这个名字的含义是什么
?
以往的过程式编程注重的是具体的功能实现方法
,
也就是低层
,
它决定了高层
,
这样是不合理的
,
所以要将这个错误的方式扭转过来
,
取名叫依赖倒转原则
三种依赖
(
耦合
)
关系的种类
:
零耦合
:
不可能
具体耦合
:
具体的类和类之间的联系
抽象耦合
:
高层抽象类与类之间的联系
如何实现依赖倒转原则呢
?
三种模式
:
第一
,
工厂方法模式
第二
,
模板方法模式
第三
,
迭代子模式
接口隔离原则
:
使用多个专门的接口要比使用一个总的接口要好
比如
:
人类
(
接口
)
学生
(
具体类
)
老师
(
具体类
)
学生老师类
(
具体类
):
这个类要想拥有学生和老师的方法就很麻烦了
,
所以
,
需要再添加两个接口
,
学生接口和老师接口
组合聚合复用原则
:CARP
将其他对象的功能融合到新的对象里
,
如果其中一个对象死掉了
,
另一个对象也不能用了
,
那么这种情况叫组合
,
反之
,
叫聚合
/**
*
知识点
:
*
依赖关系
,
组合聚合复用
,
里氏代换原则结合
这是聚合
*
程序目标
:
*
例子
:
人学习技能
* People.java:
人
具体类
* Actor.java:
技能类
接口
* Student.java:
技能类
具体类
学习方法
* Teacher.java:
技能类
具体类
教书方法
* Test.java:
让人具备学习和教书的方法
,
并使用这些能力
*/
package MY.module01.sjms.CARP.t1;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Actor a=new Student();
Actor b=new Teacher();
People p=new People();
p.studyJineng(a);
p.studyJineng(b);
p.useJineng();
}
}
package MY.module01.sjms.CARP.t1;
public interface Actor {
void jineng();
}
package MY.module01.sjms.CARP.t1;
public class Teacher implements Actor{
public void jineng() {
// TODO Auto-generated method stub
System.out.println("theach....");
}
}
package MY.module01.sjms.CARP.t1;
public class Student implements Actor{
public void jineng() {
// TODO Auto-generated method stub
System.out.println("study..");
}
}
package MY.module01.sjms.CARP.t1;
import java.util.ArrayList;
import java.util.List;
public class People {
private String name;
private int age;
private List<Actor>list;
public People(){
list=new ArrayList<Actor>();
}
public void studyJineng(Actor a){
list.add(a);
}
public void useJineng(){
for(Actor a:list){
a.jineng();
}
}
}
迪米特法则
(LoD):
最少知识原则
:
1.
尽量减少耦合
:
类与类之间的访问减少
,
利用的资源少些
2.
对远程对象的访问最好用粗粒度接口来实现
3.
不要和陌生人说话
,
只和直接认识的人联系就好了
什么是远程对象
?
什么是粗粒度接口
?
这个远程对象系统外的对象
,
如果有一个朋友圈和一些陌生人
,
陌生人就属于系统外的对象
,
就是远程对象
,
其中有一个人是这个朋友圈的同时也认识这些陌生人
,
那么如果朋友圈中的其他人想与陌生人联系
,
需要通过他来实现
,
这个他就是门面对象
,
这个对象需要通过一个接口来实现
,
而且这个接口设计的要和这个对象合适
/*
*
知识点
:
*
迪米特法则
(
最少知识原则
):
门面模式
*
程序目标
:
* Computer.java:
看成远程对象
* Lamp.java:
看成远程对象
* Office.java:
看成远程对象
* People.java:
人
,
看成朋友圈
* WorkOffFacade.java:
门面对象
*/
package MY.module01.sjms.Lod.t1;
public class People {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
WorkOffFacade w=new WorkOffFacade();
w.closeWorkOff();
}
}
package MY.module01.sjms.Lod.t1;
//
门面对象
public class WorkOffFacade {
public void closeWorkOff(){
new Computer().closeComputer();
new Lamp().closeLamp();
new Office().closeOther();
}
}
package MY.module01.sjms.Lod.t1;
public class Computer {
public void closeComputer(){
System.out.println("closeComputer");
}
}
package MY.module01.sjms.Lod.t1;
public class Lamp {
public void closeLamp(){
System.out.println("closeLamp");
}
}
package MY.module01.sjms.Lod.t1;
//
相当于远程对象
public class Office {
public void closeOther(){
System.out.println("closeOther");
}
}