創建型模式：
創建型模式抽象了實例化過程。他們幫助一個系統獨立於如何創建、組合和表示他的那些對象。一個類創建型模式使用繼承改變被實例化的類。而一個對象創建型模式將實例化委託給另一個對象。
1.工廠模式
這種模式沒必要多講，其實就是接口實現的問題，這種在項目開發中實在是太常見了
Animal
public interface Animal{
public void Jiao();
};
Dog
public class Dog implements Animal(){
@override
public void Jiao(){
System.out.println("旺旺");
}
}
Cat
public class Cat implements Animal(){
@override
public void Jiao(){
System.out.println("喵喵");
}
}
people
public class people(){
public getAnimal(){
//如果在使用中需要添加一個dog，則在get方法中初始化一個dog
Animal animal = new Dog();
animal.Jiao();
}
}
2.抽象工廠
這裏說一下抽象工廠和工廠模式的自己理解的區別：區別就是
抽象工廠無非就是把上面的People變成也有一個接口來實現，但是People會分爲OldPeople和YoungPeople
People
public interface People{
public Animal getAnimal();
};
OldPeople
public class OldPeople implements People(){
@override
public Animal getAnimal(){
Animal animal = new Dog();
animal.Jiao();
}
}
//YongPeople也是一樣，但是年輕人可能就喜歡養貓了
3.建造者(Builder)模式
定義
將一個複雜對象的構造與它的表示分離，使同樣的構建過程可以創建不同的表示，這樣的設計模式被稱爲建造者模式。
其實也很簡單，想象一下我們小時候看的動畫片，變形機器人，'我來組成頭部'，就很好理解了，這個模式只是將這個動作進行了包裝而已，所以外面只會看到‘變形’，而不知道是具體怎麼變的
PersonBuilder
public interface PersonBuilder {
void buildHead();
void buildBody();
void buildFoot();
Person buildPerson();
}
Product
public class Person {
private String head;
private String body;
private String foot;
//省略get set方法
}
ConcreteBuilder
public class ManBuilder implements PersonBuilder {
//這裏強調是男人
Person person;
public ManBuilder() {
person = new Man();
}
public void buildbody() {
person.setBody("我來組成男人身體");
}
public void buildHead() {
person.setFoot("我來組成男人頭部");
}
/**
其餘的類似
**/
}
Dirictor
public class PersonDirector {
//具體的構造在具體的類裏面有實現
public Person constructPerson(PersonBuilder pb) {
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return pb.buildPerson();
}
}
Test
public class Test{
public static void main(String[] args) {
PersonDirector pd = new PersonDirector();
Person person = pd.constructPerson(new ManBuilder());
System.out.println(person.getBody());
System.out.println(person.getFoot());
System.out.println(person.getHead());
}
}
4原型模式
這個模式在一定的場景下是有很好的應用空間的，比如說：預先不知道要產生哪種實體，需要在運行期動態的進行加載，那這時候原型可能就是比較好的選擇，比如有很多顏色的氣球，但是隻有在程序運行到一段時間的時候才知道是哪種顏色，這時候我們就需要原型模式。
原型模式其實也就是運用clone過程的模式，當然clone你可以自己寫，也可以使用java object自帶的clone（淺複製），也可以直接寫到流裏面，然後再讀出來，這就是（深複製），即利用串行化來做深複製：
，深淺複製可以自己查閱，基本原理就是上述的兩種。
（深複製是複製新的一個對象，淺複製是複製一個對象，但是屬性都是引用原對象）
5單例模式
最經典的模式之一，也是各種面試最常見的模式。
單例模式有以下特點：
1、單例類只能有一個實例。
2、單例類必須自己自己創建自己的唯一實例。
3、單例類必須給所有其他對象提供這一實例。
1、單例類只能有一個實例。
2、單例類必須自己自己創建自己的唯一實例。
3、單例類必須給所有其他對象提供這一實例。
public class Singleton {
private static Singleton uniqueInstance = null;
private Singleton() {
// Exists only to defeat instantiation.
}
public static Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
// Other methods...
}
但是說實話個人感覺這個例子其實有很大的侷限性，首先這個例子不是線程安全的，在併發情況下還是有可能會出現多個實例。
所以，有了下面的線程安全的單例
1.餓漢式：
public class SingleTon{
private SingleTon(){};
private static final SingleTon singleTon = new SingleTon();
public getSingleTon(){
return this.singleTon;
}
}
2.懶漢式
public class SingleTon{
private SingleTon(){};
//注意，這裏並沒有final
private static SingleTon singleTon = null;
public synchronized SingleTon getSingleTon(){
if(singleTon==null){
singleTon = new SIngleTon();
}
return singleTon;
}
}
但是，我們注意，這是一個效率極其低下的單例，因爲其在獲得實例的時候是有一個同步鎖的，無疑會導致成爲瓶頸所在，所以，比較好的做法是，這是我認爲一個比較好的實現單例的方法：
public class SingleTon{
private SingleTon() {
}
private static Object lock=new Object();
//注意，這裏並沒有final
private static SingleTon singleTon = null;
public static SingleTon getSingleTon(){
if(singleTon!=null){
return singleTon;
}else{
synchronized(lock){
if(singleTon==null){
singleTon = new SingleTon();
}
}
}
return singleTon;
}
}