设计模式篇-----工厂设计模式，单例设计模式，适配器模式

   一：简单工厂设计模式

   所谓的简单工厂设计模式，简单来说就是用来实例化具有共同接口的类，工厂模式也可以动态的决定该实例化哪一个类，不必实现知道要实例化哪个类。

   举一个简单的例子：猫，狗，猪他们都具有吃的这个属性，因此我们可以提炼出一个接口，让他提供抽象的方法eat()，每一种动物到底吃什么，我们可以创建具体的类实现这个接口并实现接口中的方法，然而在具体使用时，如果在我们不知道要实例化哪个类的情况下，就可以选择简单工厂设计模式。

   具体实现如下：

   创建一个接口，对外提供吃的方法：

public interface Animal {//创建动物接口，提供吃的方法
    public abstract void eat();
}

   创建三个类去实现接口：

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");//根据实际情况，具体实现接口中的方法
    }
}

public class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("猫吃小鱼");//根据实际情况，具体实现接口中的方法
    }
}

public class Tiger implements Animal {
    @Override
    public void eat() {
        System.out.println("老虎吃肉");//根据实际情况，具体实现接口中的方法
    }
}

  创建工厂，提供根据传递的参数创建对象的静态方法：

public class Factory {
    public static Animal createAnimal(String name){
        //在工厂中提供静态方法，根据传递的参数，动态的选择实例化哪个类
        if("tiger".equalsIgnoreCase(name)){
            return new Tiger();
        }else if("cat".equalsIgnoreCase(name)){
            return new Cat();
        }else if("dog".equalsIgnoreCase(name)){
            return new Dog();
        }else{
            return null ;
        }
    }
}

   测试：

public class TestFactory {
    public static void main(String[] args) {
        Animal animal1 = Factory.createAnimal("Dog");//根据传递的参数，创建dog实例
        animal1.eat();
        System.out.println("**********");
        Animal animal2 = Factory.createAnimal("Tiger");//根据传递的参数，创建tiger实例
        animal2.eat();
        System.out.println("**********");
        Animal animal3 = Factory.createAnimal("Cat");//根据传递的参数，创建cat实例
        animal3.eat();
    }
}

   结果：

狗吃骨头
**********
老虎吃肉
**********
猫吃小鱼

    二：单例设计模式

   所谓的单利设计模式，即对外不可以创建任意多的对象，能创建且只能创建一个对象的设计模式，叫做单例设计模式。因为频繁的创建对象，回收对象会造成系统性能的下降。

  单例实现的具体步骤：

   1：私有化构造方法：这样在外界就不可以通过new随意创建对象了

   2：在类的内部提供一个已经创建好了的对象

   3：在类的内部提供一个对外可以访问到的获得本类对象的静态方法

   具体实现如下：

public class Single {
    private Single(){//私有化构造方法，保证对外不能随意创建对象
                                                                                                    
    }
                                                                                                
    public static Single s=new Single();//仅提供创建 一个已经创建好了的唯一对象
                                                                                                
    public  static Single getInatance(){//提供对外可以访问本类对象的静态方法
        return s;
    }
                                                                                                
    public static void main(String[] args) {
        Single s=Single.getInatance();
        //通过类名.静态方法的形式创建唯一的对象s
        Single ss = Single.getInatance();
        //通过类名.静态方法的形式创建唯一的对象ss
        System.out.println("两个对象的值相等吗？"+(ss==s));
        //true  通过验证两个对象的值相等
        System.out.println("两个对象的地址相等？"+ss.equals(s));
        //true  通过验证两个对象的地址相等，因此ss和s是一个对象，从而达到了单例模式的要求
                                                                                                    
    }
}

   结果：

两个对象的值相等吗？true
两个对象的地址相等？true

   三：适配器模式

   所谓的适配器模式，就是根据需要，选择性的实现接口中的方法的过程。如果一个类实现一个接口，则这个类必须实现这个接口的所有方法，然而根据具体的情况，我们并不需要所有的方法为我们提供服务，可能只是其中的几个，这时我们可以采用适配器模式。

   适配器模式的实现原理：通过创建一个中间类，空实现接口中的所有方法，让具体的实现类继承这个中间类，就可以选择性的实现其中的方法了。

   具体的实现如下：

public class Adapter extends B{
    @Override
    public void a() {//选择实现B类中的a方法
        // TODO Auto-generated method stub
        super.a();
    }
}
class B implements A{//通过添加一个中间类，使得本来应是实现接口所有方法的类，只实现其中几个也好使。
    public void a(){}
    public void b(){}
    public void c(){}
    public void d(){}
    public void e(){}
}
interface A{//创建接口，提供抽象的方法
    public abstract void a();
    public abstract void b();
    public abstract void c();
    public abstract void d();
    public abstract void e();
}

   Java中的设计模式还有很多，这里只是简单的介绍了三个，介绍的可能还不够深刻，但随着我们学习的深入还会学习到更多的设计模式，继续加油吧