1. Descripción general de los patrones de diseño de fábricas.
■¿Cuál es el patrón de diseño de fábrica?
Factory Pattern es uno de los patrones de diseño más utilizados en el desarrollo.
Pertenece a un patrón creacional (el patrón singleton es un tipo de patrón creacional), y este patrón nos permite 在创建对象时不会直接暴露创建逻辑，而是通过使用一个共同的接口来完成对象的创建.
工厂模式可以分为三种，分别是简单工厂模式、工厂方法模式以及抽象工厂模式(Los dos últimos modos se basan
en el primer modo), explicamos principalmente el modo de fábrica simple.
■¿Por qué utilizar el modo de fábrica?
De hecho, el patrón de diseño de la fábrica es un patrón abstraído de la realidad.
我们在Java中，习惯要用什么对象，就去找它的类去new,主要其实并不好, el grado de acoplamiento entre clases será relativamente alto, y en realidad no solo vamos al taller de producción a comprar algo si es necesario, en nuestras vidas, es más como una tienda o centro comercial para comprar el Los productos correspondientes se compran en la línea de producción y se llevan a la tienda, luego le dicen al jefe el nombre del producto que desea comprar y el jefe se lo proporcionará.
由商店来管理这些对象，我们不关心这些商品的生产细节。
■Ventajas del patrón de diseño de fábrica
➢Si la persona que llama quiere crear un objeto, puede obtener el objeto específico en la fábrica siempre que sepa su nombre (es decir, diferentes etiquetas); ➢Es
altamente escalable. Si quiere agregar un producto (es decir, , un objeto específico), solo necesita expandir la clase Factory (es decir,
agregar diferentes etiquetas y agregar objetos correspondientes a diferentes etiquetas);
➢ Proteger la implementación específica del producto, la persona que llama solo se preocupa por la interfaz del producto y no necesita preocuparse por la implementación interna;
➢ La programación orientada a interfaz incorpora la programación orientada a objetos;
2. demostración
1. Utilice una interfaz unificada para gestionar diferentes clases.
public class FactoryDemo1 {
public static void main(String[] args) {
Fruit apple = new Apple();
Fruit banane = new Banane();
apple.eat();
banane.eat();
}
}
interface Fruit{
void eat();
}
class Apple implements Fruit{
public void eat() {
System.out.println("苹果真好吃");
}
}
class Banane implements Fruit{
public void eat() {
System.out.println("香蕉真好吃");
}
}
2. Utilice un taller de producción de objetos de clase unificada para gestionar la producción de objetos.
public class FactoryDemo2 {
public static void main(String[] args) {
FruitFatory fatory = new FruitFatory();
Fruit apple = fatory.getApple();
Fruit banane = fatory.getBanane();
apple.eat();
banane.eat();
}
}
class FruitFatory{
public Fruit getApple() {
return new Apple();
}
public Fruit getBanane() {
return new Banane();
}
}
interface Fruit{
void eat();
}
class Apple implements Fruit{
public void eat() {
System.out.println("苹果真好吃");
}
}
class Banane implements Fruit{
public void eat() {
System.out.println("香蕉真好吃");
}
}
3. Utilice una fábrica para producir varias frutas diferentes.
public class FactoryDemo3 {
public static void main(String[] args) {
Fruit apple = FruitFatory.getApple();
Fruit banane = FruitFatory.getBanane();
apple.eat();
banane.eat();
}
}
class FruitFatory{
public static Fruit getApple() {
return new Apple();
}
public static Fruit getBanane() {
return new Banane();
}
}
interface Fruit{
void eat();
}
class Apple implements Fruit{
public void eat() {
System.out.println("苹果真好吃");
}
}
class Banane implements Fruit{
public void eat() {
System.out.println("香蕉真好吃");
}
}
4. Se pueden construir diferentes objetos usando un método de fábrica.
public class FactoryDemo4 {
public static void main(String[] args) {
Fruit apple = FruitFatory.getFruit("apple");
Fruit banane = FruitFatory.getFruit("banane");
apple.eat();
banane.eat();
}
}
class FruitFatory{
public static Fruit getFruit(String fruitName) {
if("apple".equalsIgnoreCase(fruitName)) {
return new Apple();
}else if("banane".equalsIgnoreCase(fruitName)) {
return new Banane();
}else {
return null;
}
}
}
interface Fruit{
void eat();
}
class Apple implements Fruit{
public void eat() {
System.out.println("苹果真好吃");
}
}
class Banane implements Fruit{
public void eat() {
System.out.println("香蕉真好吃");
}
}
5. La versión definitiva añade reflexión.
/src/lession14/entidad
public interface Fruit {
void eat();
}
public class Pear implements Fruit{
@Override
public void eat() {
System.out.println(" 梨真好吃 ");
}
}
public class Banane implements Fruit{
public void eat() {
System.out.println(" 香蕉真好吃 ");
}
}
public class Apple implements Fruit{
public void eat() {
System.out.println(" 苹果真好吃 ");
}
}
/**
*
* 想让你的工厂直接不需要进行频繁的更改，它也可以顺利的生产出
* 我们想要的对象！
*
*/
public class FactoryDemo5 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Fruit apple = FruitFatory.getFruit("apple");
Fruit banane = FruitFatory.getFruit("banane");
Fruit pear = FruitFatory.getFruit("pear");
apple.eat();
banane.eat();
pear.eat();
}
}
class FruitFatory{
public static Fruit getFruit(String className) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<?> classObj = Class.forName("lession14.entity."+initClassName(className));
return (Fruit) classObj.newInstance();
}
public static String initClassName(String className) {
StringBuilder sb = new StringBuilder();
return sb.append((className.charAt(0)+"").toUpperCase()).append(className.substring(1).toLowerCase()).toString();
}
}
En Demo2, ya podemos construir objetos de clase específicos a través de una clase de fábrica, pero aún necesitamos operarlo como llamar a un método, y diferentes objetos tienen diferentes nombres de método. ¿Podemos optimizarlo aún más? En Demo3, usamos directamente un método unificado
. para obtener diferentes objetos, simplemente juzgue el nombre dentro del método y luego obtenga el objeto especificado a través de nuevo o reflexión.
En este patrón, la clase de fábrica es la clave de todo el patrón. Contiene la lógica de juicio necesaria (como decidir qué clase específica de objetos se debe crear en función de la información proporcionada por el mundo exterior). Al usarlo, los usuarios pueden crear directamente las instancias requeridas según la clase de fábrica sin saber cómo se crean y organizan estos objetos. Propicio para la optimización de toda la arquitectura del software.
Sin embargo, las deficiencias del patrón de fábrica simple también se reflejan en su clase de fábrica: dado que la clase de fábrica concentra la lógica de creación de todas las instancias, no es buena para la "alta cohesión". Además, cuando el número de categorías de productos específicas en el sistema continúa aumentando, es posible que sea necesario modificar la clase de fábrica en consecuencia y la escalabilidad no es muy buena. Es más problemático realizar llamadas específicas.