Siete principios de diseño del patrón de diseño de Java, la combinación de texto y código para comprender
Siempre que lo hagas, lo mejor es perseguir solo un objetivo que más te importe, y puedes ceder al resto, para que las posibilidades de lograr el objetivo sean altas. Por ejemplo: para hacer esto, lo más importante es aprender experiencia, luego no importa el dinero; para hacer eso, lo más importante es el dinero, luego no importa la cara. Y así. Si haces algo y quieres aprender experiencia, tienes que ganar mucho dinero y tener cara. Es algo tan hermoso que tienes que esperar.
Una aplicación eficiente proviene del manejo de los detalles por parte del programador, así como de la especificación del código, la legibilidad, etc. A menudo se escucha que se utilizan patrones de diseño. Los patrones de diseño tienen siete principios de diseño, y todos los patrones de diseño deben cumplir con estos siete Comience con los grandes principios del diseño . Hoy, lo llevaré a comprender los siete principios del diseño.
¿Cuáles son los siete principios de diseño?
- Principio de responsabilidad única
- Principio de aislamiento de interfaz
- Principio de reversión
- Principio de sustitución de Richter
- Principio de apertura y cierre
- Ley de Dimit
- Principio de reutilización sintético
Por lo general, todos comprenden los primeros seis y no existe un principio de reutilización sintético.
¿Por qué utilizar los siete principios de diseño?
- Reutilización de código (no es necesario escribir el mismo código varias veces);
- Legibilidad (estandarización de la programación, fácil de leer y comprender para otros programadores);
- Extensibilidad (cuando es necesario agregar nuevas funciones, es muy conveniente, también llamado mantenibilidad);
- Fiabilidad (cuando agregamos nuevas funciones, no afectará las funciones originales);
- Hacer que el programa presente las características de alta cohesión y bajo acoplamiento;
Principio de responsabilidad única
Solo hay un estudio de Android en mi computadora, por lo que el proyecto de Android se está ejecutando y eclipse no está instalado, por lo que no hay un proyecto de Java.
Código ordinario:
SingleBean singleBean = new SingleBean();
singleBean.run("小明");
singleBean.run("钢铁侠");
public class SingleBean {
public void run(String title){
Log.i("SingleBean",title+"在看电视..");
}
}
效果图(1.1):
Problemas:
- Aunque no hay ningún problema con el código y no se reporta ningún error, si está escrito así, la clase SingleBean tiene dos lógicas de operación.
- Xiao Ming está viendo la televisión ...
- Iron Man está viendo la televisión ...
Si quiero cambiar la lógica del código ahora, ¿ Xiao Ming está haciendo su tarea?
SingleBean singleBean = new SingleBean();
singleBean.run("小明");
singleBean.run("钢铁侠");
public class SingleBean {
public void run(String title){
Log.i("SingleBean",title+"在写作业..");
}
}
效果图(1.2): Como
puede ver, si escribe de esta manera, el código tendrá un problema
Lo que quiero cambiar es: Xiao Ming está haciendo la tarea, Iron Man está mirando televisión
Modificar el código para cumplir con el principio de responsabilidad única:
Opcion uno:
SingleBean singleBean = new SingleBean();
singleBean.run("小明");
singleBean.run2("钢铁侠");
public class SingleBean {
public void run(String title){
Log.i("SingleBean",title+"在写作业..");
}
public void run2(String title){
Log.i("SingleBean",title+"在看电视..");
}
}
效果图(1.3):
Análisis:
- Aunque aquí no se observa el principio de responsabilidad única, en el método se observa el principio de responsabilidad única.
Opción II:
SingleBean singleBean = new SingleBean();
singleBean.run("小明");
SingleBean2 singleBean2 = new SingleBean2();
singleBean2.run("钢铁侠");
public class SingleBean {
public void run(String title){
Log.i("SingleBean",title+"在写作业..");
}
}
public class SingleBean2 {
public void run(String title){
Log.i("SingleBean",title+"在看电视..");
}
}
análisis:
- La clase se desmonta, aumentando la cantidad de código, beneficios: el código es más legible
效果图(1.4):
para resumir:
- Si el principio de responsabilidad única no se sigue estrictamente en la categoría, se debe seguir el principio de responsabilidad única en el método.
- Reducir la complejidad de la clase, una clase es responsable de una responsabilidad
- Mejorar la legibilidad y mantenibilidad de la clase.
- El código es lo suficientemente simple o muy repetitivo, por lo que puede ir más allá de la clase y seguir el principio de responsabilidad única en el método.
Comprensión simple y cruda:
una clase es responsable de una responsabilidad, ninguna clase es responsable de una responsabilidad. Por
ejemplo, tengo que comer ahora, incluidas las compras, cocinar, comer, lavar los platos, etc. (una clase es responsable de una responsabilidad) en
lugar de tener que comer, simplemente comer, (una clase es responsable de una responsabilidad)
Principio de aislamiento de interfaz
Primero echemos un vistazo al diagrama de caso completo;
事例图(2.1):
- Rojo: Clase A, que implementa los métodos de interfaz method1 (), method4 (), method5 ()
- Amarillo: Tipo B, interfaz de implemento
- Verde: Clase C, implementar los métodos de interfaz method2 (), method3 (), method4 ()
- Púrpura: Clase D, interfaz de implemento
- Azul: Iquarantine, la clase de implementación de aislamiento de interfaz, hay 5 métodos de método1 () a método5 ()
- Flecha negra: indica que el método correspondiente se implementa a través de la clase de implementación
- Flecha gris: el logo implementa directamente la interfaz Iquarantine
Código que viene:
Clase de interfaz:
public interface Iquarantine {
void method1();
void method2();
void method3();
void method4();
void method5();
}
Clase QuarantineA:
public class QuarantineA {
public void run(Iquarantine iquarantine){
iquarantine.method1();
iquarantine.method4();
iquarantine.method5();
}
}
Clase de cuarentena B:
public class QuarantineB implements Iquarantine{
@Override
public void method1() {
Log.i("Quarantine","QuarantineB类 method1()实现");
}
@Override
public void method2() {
Log.i("Quarantine","QuarantineB类 method2()实现");
}
@Override
public void method3() {
Log.i("Quarantine","QuarantineB类 method3()实现");
}
@Override
public void method4() {
Log.i("Quarantine","QuarantineB类 method4()实现");
}
@Override
public void method5() {
Log.i("Quarantine","QuarantineB类 method5()实现");
}
}
Clase QuarantineC:
public class QuarantineC {
public void run(Iquarantine iquarantine){
iquarantine.method2();
iquarantine.method3();
iquarantine.method4();
}
}
Clase QuarantineD:
public class QuarantineD implements Iquarantine{
@Override
public void method1() {
Log.i("Quarantine","QuarantineD类 method1()实现");
}
@Override
public void method2() {
Log.i("Quarantine","QuarantineD类 method2()实现");
}
@Override
public void method3() {
Log.i("Quarantine","QuarantineD类 method3()实现");
}
@Override
public void method4() {
Log.i("Quarantine","QuarantineD类 method4()实现");
}
@Override
public void method5() {
Log.i("Quarantine","QuarantineD类 method5()实现");
}
}
Implementación:
//接口隔离原则
QuarantineA quarantineA = new QuarantineA();
quarantineA.run(new QuarantineB());
QuarantineC quarantineC = new QuarantineC();
quarantineC.run(new QuarantineD());
El método run () de QuarantineA necesita pasar una interfaz Iquarantine, y QuarantineB implementa la interfaz Iquarantine, así que simplemente pase QuarantineB () cuando se ejecuta directamente.
Veamos el resultado:
效果图(1.5):
El problema con este código es obvio:
Incumplimiento del principio de aislamiento de interfaz:
Cuando se implementa la clase QuarantineB, debido a que la clase QuarantineA solo necesita los
métodos method1 (), method4 (), method5 (), method2 () y method3 () son redundantes.
Cuando se implementa la clase QuarantineD , method1 () y method5 () son redundantes
Definición del principio de aislamiento de la interfaz:
- El cliente no debe depender de interfaces que no necesita
- Las dependencias entre clases deben establecerse en la interfaz más pequeña.
Definición y explicación del principio de aislamiento de la interfaz:
- El principio de aislamiento de interfaces es un principio que restringe el uso de interfaces y nos dice que si queremos usar interfaces, la clave es el aislamiento. Aislamiento significa romper el contacto y la comunicación.
- Entonces, cuando usamos la interfaz, ¿qué debemos aislar? "El cliente no debe confiar en la interfaz que no necesita", el aislamiento aquí se refiere al aislamiento del cliente de la interfaz que no necesita, es decir, el cliente no debe usar la interfaz que no necesita.
- "La dependencia entre clases debe establecerse en la interfaz más pequeña", requiere "la interfaz más pequeña", es decir, no hay métodos redundantes en la interfaz, por lo que el aislamiento aquí se refiere al aislamiento de los métodos redundantes .
El principio de aislamiento de la interfaz nos dice que no empaquetemos muchos métodos en una interfaz, lo que hará que la interfaz se vuelva extremadamente hinchada . Debe basarse en las necesidades reales, por lo que solo hay métodos útiles en la interfaz , es decir , debemos refinar nuestra interfaz .
Utilice la interfaz para aislar el código:
Dividido en tres interfaces:
interface IquarantineA {
void method1();
void method5();
}
interface IquarantineB {
void method4();
}
interface IquarantineC {
void method2();
void method3();
}
Clase QuarantineA:
public class QuarantineA {
public void run(QuarantineB quarantineB){
quarantineB.method1();
quarantineB.method4();
quarantineB.method5();
}
}
Clase QuarantineB, implementar IquarantineA, IquarantineB:
public class QuarantineB implements IquarantineA,IquarantineB{
@Override
public void method1() {
Log.i("Quarantine","QuarantineB类 method1()实现");
}
@Override
public void method4() {
Log.i("Quarantine","QuarantineB类 method4()实现");
}
@Override
public void method5() {
Log.i("Quarantine","QuarantineB类 method5()实现");
}
}
Clase QuarantineC:
public class QuarantineC {
public void run(QuarantineD quarantineD){
quarantineD.method2();
quarantineD.method3();
quarantineD.method4();
}
}
Clase QuarantineD, que implementa las interfaces IquarantineB, IquarantineC:
public class QuarantineD implements IquarantineB,IquarantineC{
@Override
public void method2() {
Log.i("Quarantine","QuarantineD类 method2()实现");
}
@Override
public void method3() {
Log.i("Quarantine","QuarantineD类 method3()实现");
}
@Override
public void method4() {
Log.i("Quarantine","QuarantineD类 method4()实现");
}
}
De esta manera, la clase correspondiente implementa el método correspondiente, la interfaz no se hincha y se cumple el principio de aislamiento de la interfaz.
效果图(1.6):
para resumir:
- Evite la contaminación de datos causada por la interfaz,
- Mejorada la flexibilidad del código, una clase implementa múltiples interfaces, por lo que una interfaz inflada se divide en varias interfaces pequeñas y se pueden satisfacer más necesidades a través de diferentes combinaciones de interfaces pequeñas.
- Alta cohesión, alta cohesión es para mejorar las capacidades de procesamiento de interfaces, clases y módulos, y reducir la interacción externa.
Código del principio de responsabilidad única
Código de principio de aislamiento de interfaz
También te puede interesar:
Modelado UML de Android Studio
Ir a la página del catálogo de patrones de diseño / principios de diseño
La originalidad no es fácil, tus me gusta son tu mayor apoyo para mí, por favor, me gusta apoyarlo ~