学习设计模式之前，我们要知道为什么需要设计模式？想想你在初中、高中时是怎么做数学题的？每遇到一个难题，你不需要重头开始思考解决方法，而是有一定的解题“套路”。设计模式就像是解题的“套路”，一个好的“套路”应该适用于大多数题目，设计模式也是如此，一个好的设计模式不仅可以解决目前的问题，还可以很好地应对将来的变化。对于Java而言，只有运用好设计模式才能迈进J2EE的门槛。用一句话概括：设计模式就是为了提高代码的复用性，降低程序的耦合。
A. 创建模式
1. 单例模式（Singleton）
单例模式的目的是保证一个类只有一个实例，并且提供一个接口使用该实例。
最佳实践：建立目录；建立数据库连接。
一般单例模式通常有两种形式：饿汉式、懒汉式。
//饿汉式，在类的加载阶段就会创建该类的实例对象
public class girlFriend {
private String name;
private girlFriend(String name){
this.name = name;
}
private static girlFriend gf = new girlFriend("gf");
public static girlFriend getInstance(){
return gf;
}
}
//懒汉式，在类的初始化阶段创建该类的实例对象
public class girlFriend {
private String name;
private girlFriend(String name) {
this.name = name;
}
private static girlFriend gf = null;
public static synchronized girlFriend getInstance() {
if(gf == null){
gf = new girlFriend("gf");
}
return gf;
}
}
懒汉式和饿汉式的区别：
- 创建对象时机不同。
- 懒汉式是线程不安全的，需要加锁；饿汉式是线程安全的。
2. 工厂模式（Factory）
工厂模式用于创建实例对象，一般有三种形式：简单工厂模式、工厂模式、抽象工厂模式。
最佳实践：对象创建需要重用；未知该类需要创建多少子类对象
①简单工厂模式：核心工厂根据不同参数创建不同的对象（直接生产产品）。
public class simpleFactory {
public static product createProduct(int type) {
if(type == 1) {
return new product1();
} else if(type == 2){
return new product2();
}
return null;
}
public static void main(String[] args) {
product product1 = simpleFactory.createProduct(1);
product1.print();
}
}
abstract class product{
public abstract void print();
}
class product1 extends product{
public void print(){
System.out.println("产品1");
}
}
class product2 extends product{
public void print(){
System.out.println("产品2");
}
}
②工厂模式：核心工厂的子类决定生产产品。核心工厂只需要定义创建对象的接口，这样可以使类的实例化延迟到其子类。
public class factory {
public static void main(String[] args) {
productFactory p1f = new product1Factory();
product p = p1f.getProduct();
p.print();
}
}
interface product{
void print();
}
interface productFactory{
product getProduct();
}
class product1 implements product{
public void print(){
System.out.println("产品1");
}
}
class product2 implements product{
public void print(){
System.out.println("产品2");
}
}
class product1Factory implements productFactory{
@Override
public product getProduct(){
return new product1();
}
}
class product2Factory implements productFactory{
@Override
public product getProduct(){
return new product2();
}
}
③抽象工厂模式：具体工厂类可以创建多个对象。
public class factory {
public static void main(String[] args) {
specificFactory sf = new specificFactory();
Computer legion = sf.getLegionComputer();
Phone apple = sf.getApplePhone();
legion.print();
apple.print();
}
}
//产品1->电脑
interface Computer{
void print();
}
class legion implements Computer{
@Override
public void print() {
System.out.println("legion");
}
}
//产品2->手机
interface Phone{
void print();
}
class apple implements Phone{
@Override
public void print() {
System.out.println("apple");
}
};
//抽象工厂
interface abstractFactory{
Computer getLegionComputer();
Phone getApplePhone();
}
//具体工厂
class specificFactory implements abstractFactory{
@Override
public Computer getLegionComputer() {
return new legion();
}
@Override
public Phone getApplePhone() {
return new apple();
}
}
3. 建造者模式（Builder）
建造者模式适用于将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的对象，解耦过程与产品。
经典的Builder模式用Builder接口定义如何创建复杂对象，用Director类构建最后的复杂对象，即组装最后成品。
最佳实践：创建属性很多的复杂对象，以下代码实现（最佳实践中并没有使用到Director类构建最后的对象，而是通过链式结构控制构建过程；也没有单独定义Builder接口，而是使用静态内部类代替Builder接口的实现类。这也说明了设计模式不是原封不动地套用，需要开发者在实践中具体问题具体分析）。
// Person类->含有很多字段的复杂对象
class Person {
private String name;
private int age;
private String gender;
private String address;
private String phone;
private String email;
private int id;
private String password;
private String city;
private String state;
private Person(){}
public static class personBuilder{ // 静态内部类，代替了Builder接口的实现类
Person p = new Person();
public personBuilder setInfo(String name, int age, String gender){
p.name = name;
p.age = age;
p.gender = gender;
return this;
}
public personBuilder setAddress(String address){
p.address = address;
return this;
}
public personBuilder setPhone(String phone){
p.phone = phone;
return this;
}
public personBuilder setAccount(int id, String password, String email, String state){
p.id = id;
p.password = password;
p.email = email;
p.state = state;
return this;
}
public personBuilder setCity(String city){
p.city = city;
return this;
}
public Person build(){
return p;
}
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
", address='" + address + '\'' +
", phone='" + phone + '\'' +
", email='" + email + '\'' +
", id=" + id +
", password='" + password + '\'' +
", city='" + city + '\'' +
", state='" + state + '\'' +
'}';
}
}
public class Builder{
public static void main(String[] args) {
//链式结构构建对象，代替Director类功能
Person p = new Person.personBuilder()
.setInfo("wistain", 22, "male")
.setAccount(1, "123", "123456@qq.com", "在职")
.build();
System.out.println(p);
}
}
