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