20Java语法回顾之设计模式

Java语法回顾大结局之设计模式

读了那么多年的书让我明白一个道理。人要稳重，不要想到啥就做啥。做一行越久即使你不会，几年之后慢慢的你也会了，加上一点努力你或许你能成为别人眼中的专家。

设计模式简介

通过很多类抽取出来的一个模型，即设计模式。
设计模式一般分为三种：
        创建型：创建对象。工厂模式，单例模式。
        结构型：对象间的关系。装饰模式。
        行为型：对象能够做什么。模板模式。

1. 工厂模式（简单工厂模式，工厂方法模式）
2. 单例模式（饿汉式，懒汉式)
3. 装饰模式
4. 模板方法模式

工厂模式

比如说，我们现在有很多动物类，猫，狗，猪...而这些动物有相同的行为，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基础内容。