Object oriented Programming with Java
1.0.0
¡Bienvenido al almacenamiento de programación orientado al objeto con Java ! Proporciona un recurso integral para explorar y aprender programación orientada a objetos a través del lenguaje Java.
La programación orientada al objeto (OOP - OOP - Programación orientada a OOP) es un modelo de programación popular que se usa ampliamente en el desarrollo de software. Se basa en los conceptos de "objetos", que son entidades que combinan datos (atributos) y métodos (comportamientos). OOP se centra en el diseño de software basado en objetos interactivos, en lugar del proceso y la lógica como en la programación de programación de procedimientos.
La programación orientada al objeto se basa en 4 principios básicos, a saber: empaque, herencia, polimorfismo y abstracto. Cada uno de estos principios proporciona un enfoque para resolver problemas en el desarrollo de software y ayudar a administrar el código fuente de manera más efectiva.
1. Encapsulación : este es el concepto de ocultar los detalles de la implementación interna del objeto, lo que evita que los usuarios accedan directamente a los datos dentro. El embalaje ayuda a proteger los datos y el comportamiento del objeto de la intervención no deseada y proporciona una interfaz unificada para interactuar con el objeto.
// Lớp Employee (Nhân viên) chứa các thuộc tính: tên, tuổi, lương
public class Employee {
// Các biến dữ liệu riêng tư để ngăn chặn truy cập trực tiếp từ bên ngoài lớp
private String name ;
private int age ;
private double salary ;
// Constructor (hàm tạo) để khởi tạo các giá trị của đối tượng
public Employee ( String name , int age , double salary ) {
this . name = name ;
this . age = age ;
this . salary = salary ;
}
// Các phương thức getter để truy cập các biến dữ liệu
public String getName () {
return name ;
}
public int getAge () {
return age ;
}
public double getSalary () {
return salary ;
}
// Các phương thức setter để cập nhật giá trị của các biến dữ liệu
public void setName ( String name ) {
this . name = name ;
}
public void setAge ( int age ) {
this . age = age ;
}
public void setSalary ( double salary ) {
this . salary = salary ;
}
}
// Lớp Main để thực thi mã
public class Main {
public static void main ( String [] args ) {
// Tạo đối tượng của lớp Employee
Employee emp = new Employee ( "John Doe" , 30 , 50000 );
// Truy cập và cập nhật thông qua các phương thức getter và setter
System . out . println ( "Employee name: " + emp . getName ());
emp . setSalary ( 55000 );
System . out . println ( "Updated salary: " + emp . getSalary ());
}
} En este ejemplo, el name las variables, age y salary están marcados como private , lo que significa que no se puede acceder directamente desde el exterior del Employee . En su lugar, getName() , getAge() , getSalary() , setName() , setAge() y setSalary() se proporcionan para acceder y actualizar el valor de estas variables, asegurando el empaque.
2. Herencia (herencia): la herencia permite que una nueva capa herede las propiedades y métodos de una capa existente. Esta nueva capa puede agregar o modificar los componentes de herencia para satisfacer sus propias necesidades, ayudando a reutilizar y expandir el código fuente de manera efectiva.
// Lớp cơ sở (hay lớp cha): Employee
public class Employee {
private String name ;
private int age ;
// Constructor của lớp Employee
public Employee ( String name , int age ) {
this . name = name ;
this . age = age ;
}
// Getter và Setter
public String getName () {
return name ;
}
public void setName ( String name ) {
this . name = name ;
}
public int getAge () {
return age ;
}
public void setAge ( int age ) {
this . age = age ;
}
// Phương thức để hiển thị thông tin
public void displayInfo () {
System . out . println ( "Name: " + name + ", Age: " + age );
}
}
// Lớp dẫn xuất (hay lớp con): Manager kế thừa từ Employee
public class Manager extends Employee {
private double salary ;
// Constructor của lớp Manager
public Manager ( String name , int age , double salary ) {
super ( name , age ); // Gọi constructor của lớp cơ sở (lớp cha)
this . salary = salary ;
}
// Phương thức mới của lớp Manager
@ Override
public void displayInfo () {
// Gọi phương thức displayInfo của lớp cơ sở (lớp cha)
super . displayInfo ();
System . out . println ( "Salary: " + salary );
}
}
public class Main {
public static void main ( String [] args ) {
// Tạo đối tượng Manager
Manager manager = new Manager ( "Alice Johnson" , 42 , 75000 );
manager . displayInfo (); // Hiển thị thông tin của Manager
}
}Employee es una clase base, que contiene información básica como el nombre y la edad.Manager es la clase de derivada del Employee y agrega el atributo salary .Manager utiliza la palabra clave extends para heredar de la clase Employee . Constructor del Manager llamado super(name, age) ; Para inicializar las propiedades heredadas de la clase Employee .displayInfo() se sobrescribe en la clase Manager para agregar más información sobre el salario y llame displayInfo() de la clase base para mostrar la información básica.3. Polimorfismo : el polimorfismo es la capacidad por la cual se pueden usar diferentes clases a través de la misma interfaz. El método se puede definir en una capa base y se reemplaza por los métodos del mismo nombre en las clases de derivados, lo que permite que los objetos se procesen a través de la interfaz común sin conocer su tipo de datos específico.
En Java, el polimorfismo se expresa a través del método de sobrepasar y recargar el método (sobrecarga del método).
class Animal {
void speak () {
System . out . println ( "Animal speaks" );
}
}
// Lớp Dog (chó) kế thừa lớp Animal (động vật)
class Dog extends Animal {
// Lớp Dog ghi đè phương thức speak() của lớp cha
@ Override
void speak () {
System . out . println ( "Dog barks" );
}
}
// Lớp Cat (mèo) kế thừa lớp Animal (động vật)
class Cat extends Animal {
// Lớp Dog ghi đè phương thức speak() của lớp cha
@ Override
void speak () {
System . out . println ( "Cat meows" );
}
}
public class Main {
public static void main ( String [] args ) {
Animal myAnimal = new Animal ();
Animal myDog = new Dog ();
Animal myCat = new Cat ();
myAnimal . speak (); // Prints "Animal speaks"
myDog . speak (); // Prints "Dog barks"
myCat . speak (); // Prints "Cat meows"
}
} En este ejemplo, el método speak() se sobrescribe en las capas de Dog y Cat . Al llamar al método speak() en el objeto del niño, Java determina qué método se llamará al momento de la ejecución, dependiendo del tipo de objeto que viene la variable de referencia.
class Printer {
// In chuỗi
void print ( String data ) {
System . out . println ( "String: " + data );
}
// In số nguyên
void print ( int data ) {
System . out . println ( "Integer: " + data );
}
// In số thực
void print ( double data ) {
System . out . println ( "Double: " + data );
}
}
public class Main {
public static void main ( String [] args ) {
Printer printer = new Printer ();
// Gọi phương thức print nạp chồng
printer . print ( "Hello, World!" );
printer . print ( 123 );
printer . print ( 98.76 );
}
}Printer tiene tres versiones del método print , cada uno procesando un tipo de datos específico: String , int y double .print , Java determinará la versión apropiada basada en el tipo de datos del argumento de transmisión.El polimorfismo también se expresa claramente a través del mecanismo de uso de la interfaz. La interfaz en Java es una forma de lograr un polimorfismo más alto, lo que permite que una capa implementa muchas interfaces y una interfaz que puede ser implementada por diferentes capas.
Supongamos que tenemos una interfaz CanFly y dos capas Bird y Airplane implementan esta interfaz:
interface CanFly {
void fly ();
}
class Bird implements CanFly {
public void fly () {
System . out . println ( "The bird flaps its wings to fly." );
}
}
class Airplane implements CanFly {
public void fly () {
System . out . println ( "The airplane turns on its engines to fly." );
}
}
public class TestPolymorphism {
public static void main ( String [] args ) {
CanFly myBird = new Bird ();
CanFly myAirplane = new Airplane ();
myBird . fly (); // Output: The bird flaps its wings to fly.
myAirplane . fly (); // Output: The airplane turns on its engines to fly.
}
}CanFly define el método fly() sin proporcionar el cuerpo del cuerpo.Bird como Airplane implementan el método fly() a su manera.myBird como myAirplane se hacen referencia a través de la interfaz CanFly , y al llamar al método fly() , el polimorfismo nos permite no preocuparnos por el objeto del objeto; Solo sabemos que pueden volar.4. Abstracción : Resumen permite a los programadores centrarse en lo que hace un objeto sin importarle cómo hacerlo. Crea una clase base que describe una interfaz general que implementarán las clases de derivados, simplificando la gestión de la complejidad del sistema.
En Java, el resumen se puede hacer de dos maneras:
La clase abstracta es un objeto que no se puede crear y puede contener métodos abstractos sin cuerpo.
abstract class Animal {
// Phương thức trừu tượng
abstract void makeSound ();
// Phương thức bình thường
void breathe () {
System . out . println ( "Breathing..." );
}
}
class Dog extends Animal {
// Triển khai phương thức trừu tượng trong lớp con
void makeSound () {
System . out . println ( "Bark" );
}
}
public class Main {
public static void main ( String [] args ) {
Animal myDog = new Dog ();
myDog . makeSound (); // In ra "Bark"
myDog . breathe (); // In ra "Breathing..."
}
}Animal es una capa abstracta con métodos abstractos makeSound() .Dog es una clase hereditaria de Animal y debe proporcionar un despliegue específico para el método abstracto makeSound() .La interfaz (interfaz) solo puede contener métodos abstractos sin implementación.
interface Vehicle {
void start ();
void stop ();
}
class Car implements Vehicle {
public void start () {
System . out . println ( "Car starting" );
}
public void stop () {
System . out . println ( "Car stopping" );
}
}
class Bike implements Vehicle {
public void start () {
System . out . println ( "Bike starting" );
}
public void stop () {
System . out . println ( "Bike stopping" );
}
}
public class Main {
public static void main ( String [] args ) {
Vehicle myCar = new Car ();
Vehicle myBike = new Bike ();
myCar . start (); // In ra "Car starting"
myCar . stop (); // In ra "Car stopping"
myBike . start (); // In ra "Bike starting"
myBike . stop (); // In ra "Bike stopping"
}
} Aquí, Vehicle es una interfaz que define dos métodos abstractos: start() y stop() . Las capas de Car y Bike implementan esta interfaz y proporcionan una implementación específica para cada método.
Semejanza:
Diferencias:
| Clase abstracta | Interfaz | |
|---|---|---|
| Objetivo | - A menudo se usa cuando las subclases tienen muchas funciones comunes y necesitan un lugar común para colocar el código que puede reutilizarse. -Ayuda a definir un patrón básico para el subconjunto, asegúrese de que toda la subclass herede que siga un diseño común. | - A menudo se usa para definir un contrato para una función sin cuidar. - Ideal para funciones que se pueden implementar muy diferentes. - Bueno para la definición de métodos de recopilación que una clase puede realizar. |
| Despliegue | - Puede contener métodos abstractos (sin cuerpo) y métodos no abstractos (con cuerpo). - Las clases abstractas también pueden contener campos de datos y constructores. | - Inicialmente, solo permite la definición de métodos abstractos sin cuerpo. - Desde Java 8 en adelante, la interfaz también permite la definición de métodos corporales a través de métodos predeterminados y métodos estáticos. |
| Multi -herencia | - Una clase solo puede heredar de una sola capa abstracta. - Esto limita la flexibilidad de la multi -herencia como en la interfaz. | - Java permite que una capa realice múltiples interfaces al mismo tiempo, proporcionando una forma de herencia múltiple. |
| Mandíbula | - Puede haber restricciones, ayudando a establecer las condiciones iniciales para la clase. | - No hay constructor. |
| Campo de datos | - A diferencia de la interfaz, las clases abstractas pueden tener campos de datos que no son estadísticas y finales. - El Sub -Lape puede tener atributos separados heredados de la capa abstracta. | - La interfaz no admite el campo de datos no es estática y final. - Todas las variables declaradas en la interfaz se consideran automáticamente la final estática pública. |
La programación orientada a objetos ofrece muchas ventajas sobresalientes en el desarrollo de software, lo que lo convierte en uno de los principales modelos de diseño y programación en la industria de la tecnología de la información. Estas son las ventajas:
Código de reutilización : OOP permite a los programadores reutilizar el código fuente a través del mecanismo de herencia. La capa del niño puede heredar las características de la clase de padre sin reescribir ese código. Esto ayuda a reducir el trabajo de programación, minimizar posibles errores y acelerar el desarrollo de software.
Fácil de mantener y corregir errores : la estructura de empaque en OOP ayuda a ocultar los detalles de la implementación, solo proporcionando la interfaz (interfaz) necesaria para los usuarios. Esto facilita el mantenimiento y la actualización del sistema, porque cambiar dentro de un objeto no afecta a otros objetos.
Modelado práctico : OOP permite la programación modelar entidades reales en forma de objetos de software, lo que hace que el código fuente sea más fácil de entender y administrar. El uso de objetos como realizar datos y comportamientos en el mundo real ayuda a desarrollar software para ser más intuitivo y más cercano al programador.
Expansión : gracias a la capacidad de heredar y empacar, OOP es fácil de expandir. Se puede crear una nueva capa con herencia de una o más capas que existen sin afectar esas capas. Esto ayuda al sistema a crecer de manera flexible y a adaptarse a las nuevas necesidades rápidamente.
Seguridad : el embalaje no solo ayuda a ocultar los detalles de implementación, sino que también proporciona una capa de seguridad. Los datos dentro de un objeto están protegidos del acceso directo externo, asegurando la integridad y la seguridad de los datos.
Java es uno de los lenguajes de programación más populares utilizados para enseñar programación orientada a objetos por razones plausibles.
Java es un lenguaje orientado al objeto puro , lo que significa que todo en Java es objeto o clase. Los conceptos como la herencia, el empaque, el polimorfismo y el resumen están completamente integrados en el lenguaje. Esto ayuda a los alumnos a acceder y practicar fácilmente los principios de OOP naturalmente durante la programación.
Java tiene una sintaxis clara y fácil de entender. La sintaxis de Java se basa en C/C ++, pero ha eliminado algunas características complejas como el cursor directo, lo que lo convierte en un lenguaje ideal para enseñar a los principiantes. La eliminación de estas características complejas ayuda a los alumnos a centrarse en comprender los conceptos centrales de OOP sin estar empantanado en detalles confusos.
Java es una base de idiomas independiente , puede ejecutarse en cualquier sistema operativo con la máquina virtual Java (JVM). Esto significa que los programas Java pueden desarrollarse e implementarse constantemente en diferentes plataformas sin cambiar el código. Esta flexibilidad es ideal para el entorno de aprendizaje, donde los estudiantes y los maestros pueden usar una variedad de hardware y software.
Mientras usa este archivo para el aprendizaje, debe seguir el principio de arreglo mencionado a continuación. Lea los elementos de acuerdo con las reglas de arriba a abajo, las primeras partes serán la base del próximo contenido. Particularmente para el apéndice que puede referir en cualquier momento, contiene algunos libros que uso para diseñar este archivo.
Para sincronizar y ser fácil de controlar, la capa principal contiene el método principal para ejecutar el código como el mismo que el contenido de la lección. Otras clases en la lección para ilustrar. Por ejemplo, la lección sobre la interfaz está en
Interface.javatiene clases:Movable,Trackable,Drone,Interface, las clasesMovable,TrackableyDronetienen el efecto de interpretar las clases de conocimiento de la lección eInterfacepara ejecutar código de las clases anteriores.
Este elemento es casi el mismo orden que mi almacenamiento: estructura de datos y algoritmo que usa C/C ++ , excepto que está escrito en el lenguaje Java. Habrá algunas diferencias entre los dos idiomas, los lectores pueden compararlos ellos mismos.
Java es tanto un lenguaje de programación como una traducción (e interpretada . En Java, el código fuente se traduce en ByTecode, que es indicadores binarios simples que funcionan como el código de computadora para las computadoras. Sin embargo, a diferencia de C o C ++, Java's ByTecode no es el código de la máquina nativa para cualquier procesador específico, sino para una máquina virtual Java (JVM), una plataforma común para todos los sistemas para todos los sistemas.
Este bytecode fue traducido y ejecutado por la máquina virtual Java como si fuera un código de máquina nativo. JVM funciona como un sistema operativo activo para administrar los comandos de memoria y procesamiento, asegurando la seguridad y el móvil del código. Todas las características del lenguaje Java están claramente definidas, independientemente del sistema específico del sistema básico, lo que ayuda a Java a poder ejecutar homogéneos en muchas plataformas diferentes sin edición de código.
JVM proporciona un entorno de cumplimiento seguro, donde realiza funciones similares a un sistema operativo. Gestiona la memoria, ejecutando comandos basados en pilas y procesamiento de tipos de agua. Esto minimiza los riesgos de seguridad y aumenta la estabilidad de la aplicación.
Si se parece a C y C ++ en términos de sintaxis, Java no es un descendiente directo de C o la próxima versión de C ++. Java tiene más en común con los idiomas dinámicos como SmallTalk y Lisp en lugar de C. La similitud solo se detiene en la sintaxis externa como usar muchos aparatos ortopédicos y semicolons. Java hereda la filosofía de C de un buen idioma que debería ser compacto, fácil de recordar pero expandir el vocabulario a través de los paquetes de clase Java.
Los lenguajes de script como Perl, Python y Ruby son muy populares porque son adecuados para aplicaciones seguras y en red. Sin embargo, la mayoría de los lenguajes de script no están diseñados para una programación seria a gran escala. A menudo no son adecuados para proyectos grandes o complejos debido a la estructura del programa suelto y al sistema de datos simples.
Java proporciona una plataforma segura para desarrollar marcos de mayor nivel e incluso otros idiomas, combinando simplicidad y características de Java que permite un desarrollo rápido y fácil de aplicaciones. Java también ha aprendido de las características de SmallTalk y las mejora, especialmente en el uso del conjunto de pruebas de código de byto para garantizar la precisión del código de campaña, ayudando a mejorar el rendimiento y garantizar la seguridad que SmallTalk.
Java está diseñado para ser un lenguaje seguro, no solo en contra de los errores de software, sino también en problemas comunes en el diseño y la programación. Java ofrece muchas capas protectoras, desde la prueba de seguridad del código antes de correr hasta la forma en que se carga el cargador de clase, un mecanismo de carga de bytecode de la interpretación de Java, creando un "muro" en torno a clases poco confiables. Estas características son la base de políticas de seguridad de alto nivel, permitiendo o no permitiendo varios tipos de actividades en cada aplicación.
Java comienza desde un "tablero blanco" y, por lo tanto, puede evitar características complejas o controvertidas en otros idiomas. Por ejemplo, Java no permite que los programadores regeneran a los operadores (como + heno), no hay dinero que procese dinero como macros o declaraciones #define, cosas que a menudo se usan en otros idiomas para respaldar la dependencia de la plataforma.
Java también proporciona una estructura de paquete clara para organizar archivos de clase, ayudando al proceso de compilación para manejar algunas funciones de la herramienta tradicional de fabricación de fabricación de manera efectiva. Toda la información de tipo de datos se conserva en las clases de Java compiladas, sin la necesidad de archivos de título de origen en exceso como en C/C ++. Esto hace que el código Java sea más fácil de leer y menos contexto.
Java solo apoya la herencia (cada clase tiene solo una clase de "padre") pero permite la herencia de muchas interfaces. La interfaz en Java, similar a la capa abstracta en C ++, identifica el comportamiento de un objeto sin defender su ejecución. Este es un mecanismo poderoso que permite al desarrollador definir un "contrato" del comportamiento del objeto que se puede usar y hacer referencia de forma independiente a cualquier ejecución específica de objetos.
Java elimina el uso de cursores que pueden referirse a cualquier área de memoria y agregar automáticamente la recolección de basura y el segmento de alto nivel. Estas características ayudan a eliminar muchos problemas relacionados con la seguridad, la conversión y la optimización que otros idiomas a menudo encuentran. En Java, los sujetos ya no usados recuperarán automáticamente la memoria, minimizarán los errores de gestión de memoria manual.
Java no usa el cursor tradicional, sino que es una referencia más ajustada y más segura. Se accede a los sujetos en Java, a excepción de los tipos primitivos, a través de la referencia. Esto permite crear estructuras de datos complejas de forma segura en un tipo de datos sin riesgos relacionados con el cursor en C/C ++.
Java está diseñado para manejar los errores de una manera inteligente y efectiva, gracias al fuerte mecanismo de gestión de excepciones. En Java, los errores no solo se capturan y procesan en un lugar específico en el programa a través del bloque de código "Catch", sino que también se empaquetan en excepciones. Cada uno de estos objetos trae información sobre la causa del error, lo que facilita a los programadores comprender y manejar correctamente los errores. La traducción de Java requiere el método para declarar las excepciones que puede surgir o manejarlas de inmediato. Esto ayuda a llevar la información de error al mismo nivel con otra información, como el tipo de datos de retorno o el método del método. De este modo, al programar, puede predecir y prepararse para posibles situaciones, asegurando que su aplicación opere más estable y más segura.
En la programación y el desarrollo de software, la convención de nombres es una colección de reglas para seleccionar nombres de variables, mandíbulas, clases y otros objetos en el código fuente. La convención de identificación hace que el código fuente sea más fácil de leer, fácil de entender y más fácil de mantener. Mi almacenamiento cumple estrictamente con esta convención, mencionada a continuación.
Clase: El nombre de la clase siempre comienza con la letra impresa (Pascalcase). Si el nombre de la clase consta de muchas palabras, cada palabra también debe comenzar con impresión floral. Por ejemplo: Student , Car , ColorChooser .
Interfaz: Al igual que la clase, el nombre de la interfaz también usa Pascalcase. A menudo, el nombre de la interfaz comenzará con letras mayúsculas como I o usará el tonto/sufijo como able o ible para describir la característica, como Runnable , Accessible .
El método del método siempre comienza en letras normales y sigue camelcase. El nombre del método suele ser los verbos o frases verbales que describen la acción que realiza el método. Por ejemplo: getName() , calculateTotalWidth() .
El nombre de la variable también debe comenzar con letras normales y seguido de Camelcase. El nombre de la variable debe ser claro y describir el valor que representan. Por ejemplo: height , numberOfStudents .
Un ejemplo de la clase Dog :
package com . example . animals ;
/**
* A generic Dog class that can be used as a base class for specific breeds.
*/
public class Dog {
private String name ;
private int age ;
/**
* Constructor for Dog class.
*
* @param name The name of the dog.
* @param age The age of the dog.
*/
public Dog ( String name , int age ) {
this . name = name ;
this . age = age ;
}
/**
* Returns the name of the dog.
*
* @return The name of the dog.
*/
public String getName () {
return name ;
}
/**
* Sets the name of the dog.
*
* @param name New name for the dog.
*/
public void setName ( String name ) {
this . name = name ;
}
/**
* Returns the age of the dog.
*
* @return The age of the dog.
*/
public int getAge () {
return age ;
}
/**
* Sets the age of the dog.
*
* @param age New age for the dog.
*/
public void setAge ( int age ) {
this . age = age ;
}
/**
* Provides a string representation of the dog.
*
* @return A string describing the dog's details.
*/
@ Override
public String toString () {
return "Dog[name=" + name + ", age=" + age + "]" ;
}
}| Indicaciones de acceso | público | Protegido | por defecto | Privado | |
|---|---|---|---|---|---|
| Junto con el paquete | Dentro de la clase | Tener | Tener | Tener | Tener |
| Subcontratación | Tener | Tener | Tener | No | |
| Otra clase | Tener | Tener | Tener | No | |
| Paquete diferente | Subcontratación | Tener | Tener | No | No |
| Otra clase | Tener | No | No | No | |
Unified Modeling Language (UML) es una herramienta de modelado gráfico estándar, diseñada para dibujar, describir y documentos sobre diferentes aspectos del software de aplicación. Es especialmente útil en el campo de la programación orientada a objetos, porque proporciona una forma intuitiva de mostrar clases, objetos y relaciones entre ellos. UML incluye muchos tipos diferentes de diagramas, pero en el contexto de la programación orientada a objetos, el diagrama de clases (diagramas de clases) y el diagrama interactivo (diagramas de interacción) son los dos tipos más utilizados.
UML permite a los programadores describir la estructura del sistema utilizando diagramas de clase. Este diagrama muestra clases en el sistema, atributos, sus métodos y, lo más importante, la relación entre clases como herencia, vinculación, síntesis y combinación. Esto ayuda a los programadores a comprender y diseñar el sistema de manera más sistemática.
Una vez que se ha completado el diagrama UML, se puede usar como base para escribir el código fuente. En OOP, la transferencia del diagrama de capa al código fuente (generalmente Java, C#o C ++) es bastante directa, debido a la similitud entre los conceptos descritos en UML y la estructura de la capa en estos lenguajes de programación.
UML ayuda a definir claramente las relaciones entre los objetos, resaltar la forma de comunicación e interacción entre ellos a través del diagrama de secuencia (diagramas de secuencia) y diagrama de colaboración (diagramas de colaboración). Esto ayuda a los programadores a comprender el flujo de datos y el control en la aplicación.
Antes de comenzar a escribir códigos, UML ayuda al grupo de desarrollo puede detectar y corregir problemas de diseño. La unidad en el uso de UML también ayuda a los miembros en el grupo a comprender fácilmente las ideas de los demás, aumentando así la eficiencia de la coordinación de trabajo.
UML proporciona documentos completos para el software, que es muy útil en la etapa de mantenimiento y actualización de software. Un buen diagrama UML puede ayudar a las nuevas personas que participan en el proyecto a capturar rápidamente la estructura y la función del sistema.
El diagrama de clases (diagrama de clases) es uno de los tipos de diagramas utilizados en UML y juega un papel importante en el modelado del sistema de software. El diagrama de clases proporciona una visión general de la estructura de una aplicación al mostrar las capas del sistema, sus atributos y métodos, y la relación entre esas capas. Estas relaciones pueden incluir: enlace (asociación), herencia (herencia), aplicación (realización), dependencia, agresión, composición.
Una clase representa un concepto que incluye estado (atributo) y comportamiento (método). Cada atributo tiene un tipo. Cada método tiene una firma. El nombre de la clase es la única información obligatoria.
Considere el siguiente ejemplo:
Este diagrama UML corresponde al Animal de clase en el código de la siguiente manera:
public class Animal {
// Các thuộc tính của lớp
public String name ; // Biến thành viên công khai cho tên
private int age ; // Biến thành viên riêng tư cho tuổi
private String species ; // Biến thành viên riêng tư cho loài
// Phương thức getter cho thuộc tính name
public String getName () {
return name ;
}
// Phương thức setter cho thuộc tính name
public void setName ( String name ) {
this . name = name ;
}
} Los símbolos + , - y # y # y # y los nombres de métodos en una capa indican el nivel de capacidad de acceso del atributo y el método. Específicamente:
+ indica el atributo o método de público (público).- indicando las propiedades o métodos de privacidad (privado).# indica la propiedad o el método de protección (protegido).
Flyable con un método fly() , la clase Bird puede ejecutar esta interfaz implementando el método fly() .School puede tener muchos objetos de la clase Teacher , pero los maestros aún existen independientemente de la escuela.House puede contener muchos objetos de la Room . Cuando se cancele la House , las Room también serán canceladas.| Herencia | Recolectar | |
|---|---|---|
| Definir | - La herencia es un mecanismo en el que una capa (llamada Sub -Lape) puede heredar la naturaleza y el método de otra capa (llamada clase principal). - Permita que la subdivisión reutilice el código del padre sin reescribir. - correspondiente a la relación "is-a". | - El elemento es una forma de relación "ahí" entre dos capas. - Indica una relación en la que un objeto puede contener o referirse a otros objetos, pero los dos sujetos pueden existir de forma independiente. - correspondiente a la relación "ha-a". |
| Objetivo | - Reutilice el código y mejore el módulo de la aplicación. - También apoya el polimorfismo, lo que permite que el método del niño pueda sobrescribir o expandir el método de la clase principal. - Por ejemplo: la clase Animal tiene un método Move (), las clases de pájaros y peces pueden heredar animal y usar o anular el método Move () para adaptarse a su naturaleza móvil. | - Representar la relación entre objetos, donde los objetos pueden tener una relación parcial entre sí, pero no dependiendo completamente entre sí. - Ayuda a mejorar la flexibilidad en la estructura de datos y administrar objetos complicados. - Por ejemplo, la capa cuadrada puede tener objetos de la capa puntual. Cada cuadrado consta de cuatro objetos de la capa puntual (que indica los vértices) pero los puntos pueden existir independientemente sin el pico del cuadrado. |
| Dependencia | - La subclasa depende en gran medida de la clase del padre porque usa directamente las propiedades y métodos del padre. | - Los sujetos relevantes pueden existir independientemente; No dependen fuertemente juntos. |
| Capacidad | - Expandir o personalizar la capa del padre. - Modelado de la relación descentralizada. | - Administrar objetos asociados. - Modelado de relaciones físicas. |
Considere el siguiente ejemplo:
Implementar este diagrama UML en Java es el siguiente:
public class Person {
private String name ;
private int age ;
private Address address ; // Liên kết sử dụng lớp Address
public Person ( String name , int age , Address address ) {
this . name = name ;
this . age = age ;
this . address = address ;
}
// Getter và Setter cho các thuộc tính
public String getName () {
return name ;
}
public void setName ( String name ) {
this . name = name ;
}
public int getAge () {
return age ;
}
public void setAge ( int age ) {
this . age = age ;
}
public Address getAddress () {
return address ;
}
public void setAddress ( Address address ) {
this . address = address ;
}
}
// Định nghĩa lớp Student kế thừa từ Person
public class Student extends Person {
public Student ( String name , int age , Address address ) {
super ( name , age , address );
}
}
// Định nghĩa lớp Teacher kế thừa từ Person
public class Teacher extends Person {
public Teacher ( String name , int age , Address address ) {
super ( name , age , address );
}
}
// Định nghĩa lớp Staff kế thừa từ Person
public class Staff extends Person {
public Staff ( String name , int age , Address address ) {
super ( name , age , address );
}
}
// Định nghĩa lớp Address
public class Address {
private String street ;
private String city ;
private String country ;
public Address ( String street , String city , String country ) {
this . street = street ;
this . city = city ;
this . country = country ;
}
// Getter và Setter cho các thuộc tính
public String getStreet () {
return street ;
}
public void setStreet ( String street ) {
this . street = street ;
}
public String getCity () {
return city ;
}
public void setCity ( String city ) {
this . city = city ;
}
public String getCountry () {
return country ;
}
public void setCountry ( String country ) {
this . country = country ;
}
}
// Định nghĩa lớp Department chứa Teacher và Course
public class Department {
private String name ;
private List < Teacher > teachers ; // Aggregation
private List < Course > courses ; // Composition
public Department ( String name ) {
this . name = name ;
this . teachers = new ArrayList <>();
this . courses = new ArrayList <>();
}
// Phương thức thêm giáo viên và khóa học
public void addTeacher ( Teacher teacher ) {
teachers . add ( teacher );
}
public void addCourse ( Course course ) {
courses . add ( course );
}
}
// Định nghĩa lớp Course
public class Course {
private String courseName ;
private List < Teacher > teachers ; // Association
public Course ( String courseName ) {
this . courseName = courseName ;
this . teachers = new ArrayList <>();
}
public void addTeacher ( Teacher teacher ) {
teachers . add ( teacher );
}
}
// Định nghĩa interface Maintainable
public interface Maintainable {
void maintain ();
}
// Định nghĩa lớp School
public class School implements Maintainable {
private String name ;
private List < Department > departments ; // Composition
public School ( String name ) {
this . name = name ;
this . departments = new ArrayList <>();
}
public void addDepartment ( Department department ) {
departments . add ( department );
}
// Triển khai phương thức từ interface Maintainable
@ Override
public void maintain () {
System . out . println ( "Maintaining the school facilities..." );
// Logic bảo trì cơ sở vật chất có thể được thực hiện ở đây
}
}
