软件构造复习的一些知识

复习用，所以可能有的部分就是按照自己能理解的写的，且没有顺序。
接口：
interface Out
{
void example1();
}

用类来实现接口，关键词implements
public class A implements Out
{
public void example1(){
…
}

}

public static void main(String[] args)
{
Out o = new A();
0.example1();
}

SRP:单一责任原则
OCP:开放/封闭原则
LSP:Liskov替换原则
ISP:接口隔离原则
DIP:依赖转置原则

委托（4-2P36）
一个对象请求另一个对象的功能
1）临时性的
2）永久性的
class RealPrinter {
void print() {
System.out.println(“The Delegate”);
}
}
class Printer {
RealPrinter p = new RealPrinter();\Printer调用了RealPrinter来使用它的print
void print() {
p.print();
}
}
Printer printer = new Printer();
printer.print();
一个类不需要继承另一个类的全部方法，可以通过委托机制调用部分方法，

几种设计模式
面向可复用性的
结构型模式
1）**Adapter：**解决接口不匹配：通过委托delegation完成
如图Client要用到LegacyRectangle

解决：
interface Shape {\把用户要用的接口暴露
void display(int x1, int y1, int x2, int y2);
}
class Rectangle implements Shape {\适配器：实现这个接口：调用用户想要使用的LegacyRectangle
void display(int x1, int y1, int x2, int y2) {
new LegacyRectangle().display(x1, y1, x2-x1, y2-y1);
}
}
class LegacyRectangle {
void display(int x1, int y1, int w, int h) {…}
}
class Client {\客户端
Shape shape = new Rectangle();
public display() {
shape.display(x1, y1, x2, y2);
}
}

2）**Decorator：**在对象的现有方法中动态添加/覆盖行为：同时使用子类型和委托
Decorator
3）**Facade：**为大量代码提供了一个简化的接口。4-3P31
行为类模式
4）Strategy：允许在运行时动态地选择一系列算法中的一个。
public interface PaymentStrategy{
public void pay(int amout);
}
public class StrategyA implements PaymentStartegy{
private String s1;
public StrategyA(String s1){
this.s1 = s1;
}
@Override
pay(int amount){
…
}
}
public class StrategyB implements PaymentStartegy{
private String s1;
private String s2;
public StrategyA(String s1, String s2){
this.s1 = s1;
this.s2 = s2;
}
@Override
pay(int amount){
…
}
}
public class ShoppingCart {\委托（临时的）
…
public void pay(PaymentStrategy paymentMethod){
int amount = calculateTotal();
paymentMethod.pay(amount);
}
}
在用户使用的时候如
ShoppingCart cart = new ShoppingCart();
cart.pay(new StrategyB(“aa”));
5)**Template method：**如框架,做事情的步骤一样，但具体方法不同,使用继承和重写实现。白盒框架。4-3P47
6）**Iterator：**按顺序访问对象的元素，而不公开其底层表示
Iterator

可维护性的设计模式
创建型模式
1)**Factory method pattern：**创建对象，而不指定要创建的确切类。每一类工厂只是创建某一种类型下的一个或多个产品。
Factory method pattern
2)**Abstract factory pattern：**每个工厂创建一类产品
Abstract factory pattern
结构模式
1）**Proxy：**加载一个代理的对象，真正用到这个对象的时候再去加载他。通过一个接口选择真实对象还是代理对象。
Proxy
行为模式
1）Observer： 5-2P35
Observer
2）**Visitor：**通过一个统一的接入点完成对不同的类的访问
Visitor

状态模式State-based programming：
State Pattern 5-3P18
Memento Pattern记住对象的历史状态，以便于“回滚”5-3P23
包含的类：
Orginator创建备忘录
Memento备忘录
Caretaker集合类存储备忘录
语法驱动的构造： Grammar-based construction
x::=y z
x::=y*
x::=y|z
用非终结符匹配更多的字符串，如图，.的前后都能匹配多种字符互传

但是这里匹配了非法的字符串 http://./，改变

但是太复杂了，所以可以用更多的操作符来完成：
x::= y? x是y或者是空字符串（0到1个y）
x::=y+ 等于x::= y y*(1到多个y)
x ::= [a-c] 等于x ::= ‘a’ | ‘b’ | ‘c’（选一个）
x ::= [^a-c] 等于x ::= ‘d’ | ‘e’ | ‘f’ | …（除了a-c选一个）
所以上一个例子可以写成：
ur1::=‘http://‘hostname’/’
hostname ::=word ‘.’ word
word :: =[a-z]+
#判断：root :: = ‘a’+ ‘b’* +‘c’?
aabcc错
bbbc错
aaaaaaa对
abc对
abab错
aac对
正则语法：左侧是非终结符，右侧没有非终结符
如下图不是

一些操作符
. 任何单个字符
\d [0-9]
\D [^0-9]
\s 任何空格字符，包括空格，制表符，换行符
\S 非\s
\w [a-zA-Z_0-9]
\W [^\w]
5-3P89
在Java中使用正则表达式
替换：

匹配：

提取：

断言Assertions
用在程序员写程序的阶段，用来检验假设是否成立运行阶段不用assertions
assert x>= 0:“x is” + x;
如果x=-1
则断言失败并出现错误消息x is -1
断言检测不变量等，可以用来检测前置条件和后置条件是否满足
默认情况下断言关闭，通过-ea选项开启
Assertions涵盖程序的正确性问题，处理不应该发生的情况
Exception健壮性,处理预料到可以发生的不正常情况
public方法的参数尽量用异常进行检测来保证健壮性

测试策略
并发
并发的程序是如何通信的：1.共享内存2.消息传递
进程只能通过1进行通信。
创建线程
1.从Thread类派生子类（不推荐）
2.从Runnable接口构造Thread对象。7-1P28

时间切片由OS自动调度
写在前面的线程不一定先执行

最后结果：如5，6，10，30，不会得如1，2

并发的错误很难debug，print语句甚至会导致bug消失所以不能通过print来把bug显示出来（因为print语句时间很长，改变时间切片情况）