Java語法回顧大結局之設計模式
讀了那麼多年的書讓我明白一個道理。人要穩重，不要想到啥就做啥。做一行越久即使你不會，幾年之後慢慢的你也會了，加上一點努力你或許你能成爲別人眼中的專家。
設計模式簡介
通過很多類抽取出來的一個模型，即設計模式。
設計模式一般分爲三種：
創建型：創建對象。工廠模式，單例模式。
結構型：對象間的關係。裝飾模式。
行爲型：對象能夠做什麼。模板模式。- 工廠模式（簡單工廠模式，工廠方法模式）
- 單例模式（餓漢式，懶漢式)
- 裝飾模式
- 模板方法模式
工廠模式
比如說，我們現在有很多動物類，貓，狗，豬...而這些動物有相同的行爲，eat()。抽取一個共同的父類。動物。簡單工廠模式
需求，有一個動物類，動物類中包括，狗，貓……同樣，動物都具備吃的方法。Animal
|--Dog
|--Cat
AnimalFactory
public static Animal createAnimal(String type){
if("dog".equals(type)){
return new Dog();
}else if("cat".equals(type)){
return new Cat();
}else {
return null;
}
}
動物類
public abstract class Animal {
//讓具體子類去實現
public abstract void eat();
}動物的子類（狗和貓）
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨頭");
}
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("貓吃老鼠");
}
}動物的工廠類
public class AnimalFactory {
//工廠類，我不希望你創建我的對象，所以把構造方法私有化
private AnimalFactory() {
}
//創建狗的對象
// public static Dog createDog() {
// // Dog d = new Dog();
// // return d;
// return new Dog();
// }
//創建貓的對象
// public static Cat createCat() {
// return new Cat();
// }
//在實際開發中有一個原則：對修改關閉，對擴展開發，所以我們不能把創建對象寫死。通過傳參方式
//創建以後未知的對象。
public static Animal createAnimal(String type) {
if ("dog".equals(type)) {
return new Dog();
} else if ("cat".equals(type)) {
return new Cat();
} else {
return null;
}
}
}動物類的測試類
public class Test {
public static void main(String[] args) {
// Dog dog = new Dog();
// Cat cat = new Cat();
// dog.eat();
// cat.eat();
//通過抽象類來實現
// Animal a = new Dog();
// a.eat();
// a = new Cat();
// a.eat();
// 通過工廠類來實現，創建對象交個工廠類，讓他來初始化一些操作。
// Dog dog = AnimalFactory.creatDog();
// dog.eat();
//面向對象的設計原則：開閉原則。對修改關閉，對擴展開放。所以我們還要改一下動物的工廠類
// Object dog = AnimalFactory.obj("dog");注意返回的不是obj對象，需要修改動物工廠類
Animal dog = AnimalFactory.creatAnimal("dog");
dog.eat();
//但是我們發現這還不是工廠模式，這只是一步步趨向工廠模式
}
}工廠方法模式
工廠方法模式：
Animal
|--Dog
|--Cat
|--Pig
AnimalFactory
|--DogFactory
|--CatFactory
|--PigFactory動物類
public abstract class Animal {
public abstract void eat();
}動物子類——狗
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨頭");
}
}動物工廠類
public abstract class AnimalFactory {
private AnimalFactory() {
}
//只提供一個創建工廠類的方法，讓其子類去實現這個工廠類
public abstract Animal creatAnimal();
}動物工廠類的子類——狗
public class DogFactory extends AnimalFactory {
@Override
public Animal creatAnimal() {
return new Dog();
}
}動物類的測試類
public class Test {
public static void main(String[] args) {
//通過new狗的工廠類，拿到動物工廠類的對象
AnimalFactory af = new DogFactory();
Animal dog = af.creatAnimal();
dog.eat();
//以此類推，可以通過af動物工廠類去new其他動物的工廠類。
}
}單例模式
就是指類在內存中只能有一個對象。
舉例：windows的打印服務，網站計數器
應用：線程池，數據庫連接池
面試題：請寫出一個單例設計模式。
單例模式的基本要求：
類在內存中只能有一個對象。
A:外界不能夠隨意創建對象。把構造方法私有
B:類本身要創建一個對象。
C:通過公共的方式提供給別人。單例模式之餓漢式
餓漢式：類加載就創建對象(開發用)餓漢式代碼測試
public class Student {
// 把構造方法私有，是爲了不讓外界隨意創建
private Student() {
}
//但是類本身需要創建一個對象
// 爲了不讓外界通過類名直接訪問s成員變量，就加私有
private static Student s = new Student();
// 提供公共的方式讓別人使用
// 爲了讓外界能夠直接通過類名訪問該方法，需要對該方法加靜態
public static Student getStudent(){
// return new Student(); //不能在這裏new Student，那樣就有問題了。
return s;
}
//提供一個方法做測試，看地址值是否一樣。
public void show() {
System.out.println(s.toString());
}
}
public class Test {
public static void main(String[] args) {
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
s1.show();//內存地址值是一樣的。
s2.show();
System.out.println(s1==s2);//true
}
}單例模式之懶漢式
public class Teacher {
private Teacher() {
}
//初始值爲null
private static Teacher t = null;
//這只是面試時用，實際開發時不用，因爲它會引起線程安全問題。
public synchronized static Teacher getTeacher(){
// t1,t2,t3三個線程過來了
// 如果t是null的時候，才創建對象
if (t == null) {
//t1進來了,CPU的執行權就被t2搶到了,同理t3
t = new Teacher();
}
return t;
}
}
public class TeacherTest {
public static void main(String[] args) {
Teacher t1 = Teacher.getTeacher();
Teacher t2 = Teacher.getTeacher();
System.out.println(t1 == t2);// true
t1.show();
t2.show();
}
}裝飾模式
對類原有的功能進行了修飾或者擴充。裝飾設計模式。
A:被裝飾的抽象事物 Phone
B:具體的事物 PhoneImpl
實現Phone接口，具體實現類
C:裝飾類 PhoneDecorate
實現Phone接口,調用實現。
private Phone phone;
public PhoneDecorate(Phone phone) {
this.phone = phone;
}
@Override
public void call() {
this.phone.call(); // 具體的手機打電話功能
}
Phone(接口)
|--PhoneImpl(具體實現類)
|--PhoneDecorate(抽象類)
|--ColorPhoneDecorate(具體裝飾類)
|--GuangGaoPhoneDecorate(具體裝飾類)抽象的手機類
public interface Phone {
public abstract void call();
}手機的實現類
public class PhoneImpl implements Phone {
@Override
public void call() {
System.out.println("手機打電話");
}
}手機抽象裝飾類
public abstract class PhoneDecorate implements Phone {
private Phone p;
public PhoneDecorate(Phone p) {
this.p = p;
}
@Override
public void call() {
this.p.call();
}
}手機裝飾類的實現
//想手機具備什麼樣的功能，你就可以創建什麼樣的類，繼承自裝飾手機類
public class CanLIngPhone extends PhoneDecorate {
public CanLIngPhone(Phone p) {
super(p);
}
@Override
public void call() {
System.out.println("播放彩鈴");
super.call();
}
}手機類的測試類
public class Test {
public static void main(String[] args) {
// PhoneImpl pi = new PhoneImpl();
// pi.call();
// PhoneDecorate phoneDecorate = new PhoneDecorate(new PhoneImpl());
//直接new子類的實現
CanLIngPhone canLIngPhone = new CanLIngPhone(new PhoneImpl());
canLIngPhone.call();
}
}模板方法模式
在此不做贅述，說簡單點，就是相同功能抽取在一起。結束語：至此，Java語法複習完成，接下來，開始學習Android基礎內容。