一、设计原则
1.单一职责原则：所有的对象都应该有单一的职责，它提供的所有的服务也都仅围绕着这个职责。
2.开闭原则：（1）对于扩展是开放的（Open for extension）：模块的行为可以扩展，当应用的需求改变时，可以对模块进行扩展，以满足新的需求。
（2）对于更改是封闭的（Closed for modification）：对模块行为扩展时，不必改动模块的源代码或二进制代码。
3.里式替换原则：里氏替换原则常用来检查两个类是否为继承关系。在符合里氏替换原则的继承关系中，使用父类代码的地方，用子类代码替换后，能够正确的执行动作处理。
4.依赖倒转原则:是指将两个模块之间的依赖关系倒置为依赖抽象类或接口。(在三层架构的设计中，设计的接口，就体现了这一原则)
具体有两层含义：(1)高层模块不应该依赖于低层模块，二者都应该依赖于抽象；
(2)抽象不应该依赖于细节，细节应该依赖于抽象。
5.组合/聚合复用原则：是指要尽量使用组合/聚合而非继承来达到复用目的。另一种解释是在一个新的对象中使用一些已有的对象，使之成为新对象的一部分；新的对象通过向这些对象委托功能达到复用这些对象的目的。
6.接口隔离原则：（1）接口的设计应该遵循最小接口原则，不要把用户不使用的方法塞进同一个接口里。
（2）如果一个接口A继承另一个接口B，则接口A相当于继承了接口B的方法，那么继承了接口B后的接口A也应该遵循上述原则：不应该包含用户不使用的方法。反之，则说明接口A被B给污染了，应该重新设计它们的关系。
7.迪米特法则：一个软件实体应当尽可能少的与其他实体发生相互作用。
二：模式
设计模式：
1.创建型设计模式：
（1）工厂模式：分为简单工厂模式、工厂方法模式、抽象工厂模式。
A.简单工厂模式：（给了用户一个选择，要那个就那个，那个是怎样弄出来的与用户无关（分装））
public class Factory{
public static Sample creator(int which){
//getClass 产生Sample 一般可使用动态类装载装入类。
if (which==1)
return new SampleA();
else if (which==2)
return new SampleB();
}
}
//Sample sampleA=Factory.creator(1);
//不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会
B.工厂方法：
C.抽象工厂：
2.单例模式:
第一种：(延迟加载，在真正需要用到对象的时，才产生；但为保证线程的安全，加了同步，使得不支持高并发)
public class SingleTest(){
private static SingleTest instance;
private SingleTest(){
}
public synchronized static SingleTest getInstance(){
if(null == instance){
instance = new SingleTest();
}
return instance;
}
}
第二种：（预加载方式产生，不管是否使用，都在内存中存在了，线程绝对安全）
public class SingleTest(){
private static SingleTest instance = new SingleTest();
private SingleTest(){
}
public static SingleTest getInstance(){
return instance;
}
}
第三种：（添加了同步锁，既是延迟加载，又支持高并发，而且线程安全-------不过在JDK1.7以前不支持）
public class SingleTest(){
private static SingleTest instance = null;
private SingleTest(){
}
public static SingleTest getInstance(){
if(null == instance){
synchronized(singleTest.class){
if(null == instance){
instance = new SingleTest();
}
}
}
return instance;
}
}
3.原型模式：（深克隆与浅克隆---对于可以进行克隆操作的类需要实现Cloneable接口，与一个对象要可序列化需实现Serializable接口一样）
A.浅克隆：（克隆方法clone()，只克隆了一层对象，对于下层的对象没有进行克隆。即：如果被克隆的这个对象中有引用数据类型，克隆后的对象所指向的还是之前的引用数据类型，这会导致一改则都改的效果）
public class AbstractSpoon implements Cloneable{
String spoonName;
public void setSpoonName(String spoonName) {
this.spoonName = spoonName;
}
public String getSpoonName() {
return this.spoonName;
}
public Object clone() {
Object object = null;
try {
object = super.clone();
} catch (CloneNotSupportedException exception) {
System.err.println("AbstractSpoon is not Cloneable");
}
return object;
}
}
B.深克隆：（在对象的实现克隆的方法中，将对象本身序列化到一个字节数组中，在将这个对象反序列化回来---------这样就将整个对象都进行了克隆）
public Man deepClone(){
try {
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream outObj = new ObjectOutputStream(bo);
outObj.writeObject(this);
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream outIn = new ObjectInputStream(bi);
Man m = (Man)outIn.readObject();
return m;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}