设计模式

1.装饰设计模式

interface Coder{
  public void code();
}
class Student implements Coder{
  @Override
  public void code(){
    System.out.println("javase");
    System.out.println("javaweb");
  }
}

class HeiMaStudent implements Coder{
  private Student s;//获取到被包装的类的引用
  public ItcastStudent(Student s){//通过构造函数创建对象的时候传入被包装的对象
        this.s=s;
  }
  @Override
  public void code(){  //对其原有功能进行升级
    s.code();
    System.out.println("数据库");
    System.out.println("ssh");
    System.out.println("安卓");
  }
}

2.单例设计模式

* 单例设计模式：保证类在内存中只有一个对象。

* 如何保证类在内存中只有一个对象呢？
* (1)控制类的创建，不让其他类来创建本类的对象。private
* (2)在本类中定义一个本类的对象。Singleton s;
* (3)提供公共的访问方式。  public static Singleton getInstance(){return s}
* 单例写法两种：

* (1)饿汉式 开发用这种方式。

//饿汉式
class Singleton{
   //私有构造函数
   private Singleton(){}
   //创建本类对象
   private static Singleton s=new Singleton();
   //对外提供公共的访问方法
   public static Singleton getInstance(){
        return s;
}
   public static void print(){
    System.out.println("111");
  }
}

* (2)懒汉式 面试写这种方式。多线程的问题？

//懒汉式，单例的延迟加载模式
class Singleton{
  //私有构造函数
  private Singleton(){}
  //声明一个本类的引用
  private static Singleton s;
  //对外提供公共的访问方法
  public static Singleton getInstance(){
     if(s==null)
       //线程1，线程2
         s=new Singleton();
      return s;
}
  public static void print(){
      System.out.println("1111111");
  }
}

* (3)第三种格式

class Singleton{
   private Singleton(){}
   public static final Singleton s=new Singleton();//final是最终的意思，被final修饰的变量不可以被更改
}

3.简单工厂模式概述和使用

* A:简单工厂模式概述
* 又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
* B:优点
* 客户端不需要在负责对象的创建，从而明确了各个类的职责
* C:缺点
* 这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护
* D:案例演示
* 动物抽象类：public abstract Animal { public abstract void eat(); }
* 具体狗类：public class Dog extends Animal {}
* 具体猫类：public class Cat extends Animal {}

* 开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。

public class AnimalFactory{
  private AnimalFactory(){}
  
   //public static Dog createDog(){ return new Dog(); }
   //public static Cat createCat(){ return new Cat();}

//改进
  public static Animal createAnimal(String animalName){
    if("dog".equals(animalName)){}
    else if("cat".equals(animale)){
     }else{
           return null;
      }
  }
}

4.工厂方法模式的概述和使用

* A:工厂方法模式概述
* 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
* B:优点
* 客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
* C:缺点
* 需要额外的编写代码，增加了工作量

* D:案例演示

动物抽象类：public abstract Animal { public abstract void eat(); }
工厂接口：public interface Factory {public abstract Animal createAnimal();}
具体狗类：public class Dog extends Animal {}
具体猫类：public class Cat extends Animal {}
开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦，用工厂方法改进，针对每一个具体的实现提供一个具体工厂。
狗工厂：public class DogFactory implements Factory {
public Animal createAnimal() {…}
        }
猫工厂：public class CatFactory implements Factory {
public Animal createAnimal() {…}
        }