Java基础-设计模式_1

设计模式

1.模板模式Template

• A:模版设计模式概述
  • 模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现
  • 抽象类(abstract)中的抽象方法(abstract)由子类重写,而最终方法(final)不能被子类重写,但可以直接被子类使用.
  • 抽象类中的最终方法不能被子类重写,相当于模板;抽象方法可以在子类中重写,相当于要被模板定型的材料;通常final方法调用abstract方法.
• B:优点和缺点
  • a:优点
    • 使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
  • b:缺点
    • 如果算法骨架有修改的话，则需要修改抽象类
      1,装饰
      2,单例
      3,简单工厂
      4,工厂方法
      5,适配器
      6,模版

2.单例设计模式(Singleton Pattern)

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

• 如何保证类在内存中只有一个对象呢？

  • (1)控制类的创建，不让其他类来创建本类的对象。private
  • (2)在本类中定义一个本类的对象。Singleton s;
  • (3)提供公共的访问方式。 public static Singleton getInstance()

• 单例写法两种：

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

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

  • (2)懒汉式 面试写这种方式。多线程的问题？实际开发中几乎不使用,线程不安全

  •   //懒汉式,单例的延迟加载模式
      class Singleton {
      	//1,私有构造函数
      	private Singleton(){}
      	//2,声明一个本类的引用,但不创建
      	private static Singleton s;
      	//3,对外提供公共的访问方法
      	public static Singleton getInstance() {
      		if(s == null)
      			//线程1,线程2,多线程中可能会创建多个对象,线程不安全
      			s = new Singleton();
      		return s;
      	}
      	
      	public static void print() {
      		System.out.println("11111111111");
      	}
      }
    

  • (3)第三种格式

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

    饿汉式:空间换时间,不管是否后面会用到,都先创建对象;
    懒汉式:时间换空间,先声明对象,不立刻创建对象(延迟加载);线程不安全,开发中不用

3.设计模式(简单工厂模式概述和使用)(了解)

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

5.适配器设计模式

• a.什么是适配器
  • 在使用监听器的时候, 需要定义一个类事件监听器接口.
  • 通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.
  • 适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.
• b.适配器原理
  • 适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.
  • 适配器类需要定义成抽象的,因为创建该类对象,调用空方法是没有意义的
  • 目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.

6.装饰设计模式

* 装饰设计模式优点:
	耦合性不强,被装饰的类的变化与装饰类的变化无关;
	如果采用继承Student的方式,耦合性太强,父类Student变化,子类HeiMaStudent也要跟着变化

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