1. Patrón de diseño singleton
- Patrón de diseño singleton: asegúrese de que la clase tenga solo un objeto en la memoria.
- ¿Cómo asegurarse de que la clase tenga solo un objeto en la memoria?
(1) Controle la creación de clases y evite que otras clases creen objetos de esta clase. Eso es privatizar la constructora.
private
(2) Defina un objeto de esta clase en esta clase.
Singleton s;
(3) Proporcionar métodos de acceso público.
public static Singleton getInstance(){return s} - Hay dos formas de escribir un solo caso:
(1) Chino hambrientoDesarrollo de esta manera。
public static void main(String[] args) {
/*
* Singleton s1=Singleton.s;
* Singleton.s =null;
* Singleton s2=Singleton.s;
* //如果下面设置public属性，
* 此时两个对象一个是调用了Single的成员变量，
* 一个是设置成了null。这样对象会进行修改
*/
//使用饿汉式创建对象,此时我们才分为一个对象
Singleton s1=Singleton.getSingleton();
Singleton s2=Singleton.getSingleton();
System.out.println(s1==s2);
}
class Singleton{
//1.私有构造方法，其他类不能访问该构造方法
private Singleton() {
}
//2.创建本类对象，如果该处使用public方式的话，会出现
private static Singleton s =new Singleton();
//3.对外提供公共访问发给发
public static Singleton getSingleton() {
//获取实例
return s;
}
}
El resultado de salida es: Verdadero. Porque es el mismo objeto en este momento.
(2) Hombre vago Entrevista escribiendo de esta manera
No cree un objeto primero, solo créelo cuando el usuario lo necesite. El propósito es ahorrar espacio
class Singleton{
//懒汉式,单例的延迟加载模式
//1,私有构造函数
private Singleton () {
}
//2,声明一个本类的引用
private static Singleton s;
//3,对外提供公共的访问方法
public static Singleton getSingleton() {
if (s==null) {
s=new Singleton();
}
return s;
}
}
Este método tiene ciertos defectos. Será seguro cuando se acceda a él por varios hilos y se crearán varios objetos.
¿Cuál es la diferencia entre hombre hambriento y hombre perezoso?
- El estilo hambriento es espacio para el tiempo (porque el espacio de la memoria se abre tan pronto como aparece), y el estilo perezoso es tiempo para el espacio. (Necesito juzgar)
- En el acceso de subprocesos múltiples, el hombre hambriento no creará varios objetos, mientras que el hombre perezoso puede crear varios objetos.
(3) La tercera forma: el
propósito es muy claro, siempre que no cambiemos el valor de s.
class Singleton {
private Singleton() {
}
public static final Singleton s = new Singleton();
//final是最终的意思,被final修饰的变量不可以被更改
}
2. Patrón de diseño decorativo
public static void main(String[] args) {
// TODO Auto-generated method stub
SmartStudent smartStudent =new SmartStudent(new Student());
smartStudent.code();
}
}
interface Coder{
public void code();
}
class Student implements Coder{
@Override
public void code() {
System.out.println("JavaSE");
}
}
class SmartStudent implements Coder{
//1.获取被装饰类的引用
private Student student;
//2.在构造方法中传入被装饰类的对象
public SmartStudent(Student student) {
this.student = student; //获取学生引用
}
//3.对原有的功能进行升级
@Override
public void code() {
student.code();
System.out.println("数据库");
System.out.println("SSH");
}
La ventaja del patrón de diseño decorativo es que el acoplamiento no es fuerte y el cambio de la clase decorada no tiene nada que ver con el cambio de la clase decorativa.
Tres, modo de diseño de plantilla (plantilla)
- Resumen de patrones de diseño de plantillas
El modo del método de plantilla es definir el esqueleto de un algoritmo y retrasar el algoritmo específico a las subclases para implementar
- pros y contras
ventaja
- Usando el modo de método de plantilla, mientras se define el esqueleto del algoritmo, se pueden implementar de manera flexible algoritmos específicos para satisfacer las necesidades flexibles de los usuarios
Desventaja
- Si se modifica el esqueleto del algoritmo, debe modificar el
caso de la clase abstracta (calcular un programa para que se ejecute durante un período de tiempo)
public class Demo1_Template {
public static void main(String[] args) {
Demo demo =new Demo();
System.out.println(demo.getTime());
}
}
abstract class GetTime{
public final long getTime() {
long start=System.currentTimeMillis();
Code();
long end=System.currentTimeMillis();
return end-start;
}
public abstract void Code();
}
class Demo extends GetTime{
@Override
public void Code() {
for (int i = 0; i < 100000; i++) {
System.out.println("x");
}
}
}
4. Modelo de fábrica simple
También llamado patrón de método de fábrica estática, define una clase de fábrica específica responsable de crear instancias de algunas clases
ventaja:
El cliente no necesita ser responsable de la creación de objetos, aclarando así las responsabilidades de cada clase.
Desventajas:
Esta clase de fábrica estática es responsable de la creación de todos los objetos. Si se agregan nuevos objetos o se crean algunos objetos de diferentes formas, la clase de fábrica debe modificarse constantemente, lo que no favorece el mantenimiento posterior.
Caso:
Paso 1: crear una interfaz
public abstract class Animal {
public abstract void eat();
}
Paso 2: escriba clases de perros y gatos para implementar métodos de interfaz con animales
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
Paso 3: Implementar la fábrica (el usuario crea objetos)
public class AnimalFactory {
//用于创建对象
//public static Dog createDog() {
// return new Dog();
//}
//public static Cat createCat() {
// return new Cat();
//}
//但是该工厂会定义很多方法，需要创建很多对象。复用性太差
//改进2.0版本
public static Animal createAnimal(String name) {
if ("dog".equals(name)) {
return new Dog();
}
else if ("cat".equals(name)) {
return new Cat();
}else {
return null;
}
}
}
Paso 4: haz la prueba
public class Test {
public static void main(String[] args) {
//Dog d =AnimalFactory.createDog();
Dog dog =(Dog) AnimalFactory.createAnimal("dog");
dog.eat();
}
}
El patrón de diseño de fábrica simple tiene un inconveniente obvio: cuando no tenemos objetos que la fábrica debería tener, se devolverán objetos vacíos y habrá excepciones de puntero.
Cinco, el modelo del método de fábrica
Visión de conjunto:
La clase de fábrica abstracta en el patrón del método de fábrica es responsable de definir la interfaz para crear objetos, y la creación de objetos concretos se implementa mediante clases concretas que heredan la fábrica abstracta.
ventaja
El cliente no necesita ser responsable de la creación de objetos, aclarando así las responsabilidades de cada clase. Si se agregan nuevos objetos, solo es necesario agregar una clase específica y una clase de fábrica específica, lo que no afecta el código existente y es fácil de mantener posteriormente. Para mejorar la escalabilidad del sistema
Desventaja
Necesita escribir código adicional, aumentar la carga de trabajo
Caso:
Paso 1: crear una interfaz animal
public abstract class Animal {
public abstract void eat();
}
Paso 2: crea una clase de entidad para implementar métodos de interfaz
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
Paso 3: Defina el método de fábrica
public interface Factory {
public Animal createAnimal();
}
Paso 4: abre una fábrica para realizar una fábrica de gatos y una fábrica de perros
public class CateFactory implements Factory {
@Override
public Animal createAnimal() {
return new Cat();
}
}
public class DogFactory implements Factory {
@Override
public Animal createAnimal() {
return new Dog();
}
}
hacer pruebas:
public class TEST {
public static void main(String[] args) {
DogFactory dogFactory =new DogFactory();
Dog dog =(Dog) dogFactory.createAnimal();
dog.eat();
CateFactory cateFactory =new CateFactory();
Cat cat =(Cat) cateFactory.createAnimal();
cat.eat();
}
}