Object oriented Programming with Java
1.0.0
Bem -vindo ao Objeto -armazenamento de programação orientado para o Java ! Ele fornece um recurso abrangente para explorar e aprender a programação orientada ao objeto através da linguagem Java.
Programação orientada para o objeto (OOP - OOP - OOP - Programação orientada a OOP) é um modelo de programação popular que é amplamente utilizado no desenvolvimento de software. É baseado nos conceitos de "objetos", que são entidades que combinam dados (atributos) e métodos (comportamentos). A OOP se concentra no design de software com base em objetos interativos, em vez do processo e lógica, como na programação de programação processual.
A programação orientada ao objeto é baseada em 4 princípios básicos, a saber: embalagem, herança, polimorfismo e abstrato. Cada um desses princípios fornece uma abordagem para resolver problemas no desenvolvimento de software e ajudar a gerenciar o código -fonte de maneira mais eficaz.
1. Encapsulamento : este é o conceito de ocultar os detalhes de implantação interna do objeto, impedindo que os usuários acessem diretamente os dados dentro. A embalagem ajuda a proteger os dados e o comportamento do objeto de intervenção indesejada e fornece uma interface unificada para interagir com o 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 ());
}
} Neste exemplo, o name , age e salary das variáveis são marcados como private , o que significa que eles não podem ser acessados diretamente da parte externa do Employee . Em vez disso, getName() , getAge() , getSalary() , setName() , setAge() e setSalary() são fornecidos para acessar e atualizar o valor dessas variáveis, garantindo a embalagem.
2. Herança (herança): A herança permite que uma nova camada herde as propriedades e métodos de uma camada existente. Essa nova camada pode adicionar ou modificar os componentes da herança para atender às suas próprias necessidades, ajudando a reutilizar e expandir o código -fonte de maneira eficaz.
// 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 é uma classe base, contendo informações básicas como nome e idade.Manager é a classe derivada do Employee e adiciona o atributo salary .Manager usa palavras -chave extends para herdar da classe Employee . O construtor do Manager chamado super(name, age) ; Para inicializar as propriedades herdadas da classe Employee .displayInfo() é substituído na classe Manager para adicionar mais informações sobre o salário e ligue para displayInfo() da classe base para exibir as informações básicas.3. Polimorfismo : O polimorfismo é a capacidade em que diferentes classes podem ser usadas pela mesma interface. O método pode ser definido em uma camada base e é substituído pelos métodos de mesmo nome nas classes derivadas, permitindo que os objetos sejam processados através da interface comum sem conhecer seu tipo de dados específico.
Em Java, o polimorfismo é expresso através do método de excesso de superação sobrepusente e recarregando o método (sobrecarga do 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"
}
} Neste exemplo, o método speak() é substituído nas camadas de Dog e Cat . Ao chamar o método speak() no objeto da criança, o Java determina qual método será chamado no momento da execução, dependendo do tipo de objeto que a variável de referência vem.
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 possui três versões do método print , cada um processando um tipo de dados específico: String , int e double .print , o Java determinará a versão apropriada com base no tipo de dados do argumento de transmissão.O polimorfismo também é claramente expresso através do mecanismo de uso da interface. A interface no Java é uma maneira de obter um polimorfismo mais alto, permitindo que uma camada implante muitas interfaces e uma interface que pode ser implantada por diferentes camadas.
Suponha que tenhamos uma interface CanFly e duas camadas Bird e Airplane implementam esta interface:
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 o método fly() sem fornecer o corpo.Bird quanto Airplane implantam o método fly() à sua maneira.myBird e myAirplane são referenciados pela interface CanFly e, ao chamar o método fly() , o polimorfismo nos permite não nos preocuparmos com o objeto do objeto; Somos só que eles podem voar.4. Abstração : Resumo permite que os programadores se concentrem no que um objeto faz sem se importar com como fazê -lo. Ele cria uma classe base que descreve uma interface geral que as classes derivadas implementarão, simplificando o gerenciamento da complexidade do sistema.
Em Java, o resumo pode ser feito de duas maneiras:
A classe abstrata é um objeto que não pode ser criado e pode conter métodos abstratos sem corpo.
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 é uma camada abstrata com métodos abstratos, makeSound() .Dog é uma classe herdada do Animal e deve fornecer implantação específica para o método abstrato makeSound() .A interface (interface) pode conter apenas métodos abstratos sem implantação.
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"
}
} Aqui, Vehicle é uma interface que define dois métodos abstratos: start() e stop() . As camadas Car e Bike implantam essa interface e fornecem implantação específica para cada método.
Semelhança:
Diferenças:
| Classe abstrata | Interface | |
|---|---|---|
| Propósito | - frequentemente usado quando as subclasses têm muitas funções comuns e precisam de um local comum para colocar o código que pode ser reutilizado. -Ajude a definir um padrão básico para a sub -camada, verifique se toda a sub -classe o herda para seguir um design comum. | - frequentemente usado para definir um contrato para uma função sem se importar. - Ideal para funções que podem ser implementadas muito diferentes. - Bom para a definição de métodos de coleta que uma classe pode executar. |
| Implantação | - pode conter métodos abstratos (sem corpo) e métodos não -abstratos (com corpo). - Classes abstratas também podem conter campos e construtores de dados. | - Inicialmente, ele apenas permite a definição de métodos abstratos sem corpo. - A partir de Java 8, a interface também permite a definição de métodos corporais através de métodos padrão e métodos estáticos. |
| Multi -heritância | - Uma classe só pode herdar de uma única camada abstrata. - Isso limita a flexibilidade da multi -herdância como na interface. | - O Java permite que uma camada execute várias interfaces ao mesmo tempo, fornecendo um formulário de multi -herdância. |
| Mandíbula | - Pode haver restrições, ajudando a definir as condições iniciais para a classe. | - Não há construtor. |
| Campo de dados | - Diferentemente da interface, as classes abstratas podem ter campos de dados que não são estática e final. - O sub -campeão pode ter atributos separados herdados da camada abstrata. | - A interface não suporta o campo de dados não é estática e final. - Todas as variáveis declaradas na interface são consideradas automaticamente a final estática pública. |
A programação orientada ao objeto traz muitas vantagens pendentes no desenvolvimento de software, tornando -o um dos principais modelos de design e programação do setor de tecnologia da informação. Aqui estão as vantagens disso:
Reutilização de código : OOP permite que os programadores reutilizem o código -fonte através do mecanismo de herança. A camada da criança pode herdar os recursos da classe do pai sem reescrever esse código. Isso ajuda a reduzir o trabalho de programação, minimizar possíveis erros e acelerar o desenvolvimento de software.
Fácil de manter e corrigir erros : a estrutura de embalagem no OOP ajuda a ocultar os detalhes da implantação, fornecendo apenas a interface (interface) necessária para os usuários. Isso facilita a manutenção e a atualização do sistema, porque alterar dentro de um objeto não afeta outros objetos.
Modelagem Prática : OOP permite que a programação modele entidades reais na forma de objetos de software, facilitando o entendimento e o gerenciamento do código -fonte. O uso de objetos, como executar dados e comportamentos no mundo real, ajuda a desenvolver software para se tornar mais intuitivo e mais próximo do programador.
Expansão : graças à capacidade de herdar e embalar, o OOP é fácil de expandir. Uma nova camada pode ser criada com herança de uma ou mais camadas que existem sem afetar essas camadas. Isso ajuda o sistema a crescer de maneira flexível e se adaptar a novas necessidades rapidamente.
Segurança : a embalagem não apenas ajuda a ocultar os detalhes da implementação, mas também fornece uma camada de segurança. Os dados dentro de um objeto são protegidos do acesso direto externo, garantindo a integridade e a segurança dos dados.
O Java é uma das linguagens de programação mais populares usadas para ensinar programação orientada a objetos por razões plausíveis.
Java é uma linguagem orientada para o objeto puro , o que significa que tudo em Java é objeto ou classe. Conceitos como herança, embalagem, polimorfismo e abstrato são completamente incorporados à linguagem. Isso ajuda os alunos a acessar e praticar facilmente os princípios OOP naturalmente durante a programação.
O Java tem uma sintaxe clara e fácil -a -entenda. A sintaxe de Java é baseada em C/C ++, mas removeu alguns recursos complexos, como o cursor direto, tornando -o um idioma ideal para ensinar iniciantes. A eliminação desses recursos complexos ajuda os alunos a se concentrar na compreensão dos conceitos principais de OOP sem serem atolados em detalhes confusos.
O Java é uma base de idioma independente , pode ser executada em qualquer sistema operacional com a máquina virtual Java (JVM). Isso significa que os programas Java podem se desenvolver e implementar consistentemente em diferentes plataformas sem alterar o código. Essa flexibilidade é ideal para o ambiente de aprendizado, onde alunos e professores podem usar uma variedade de hardware e software.
Ao usar esse arquivo para aprender, você deve seguir o princípio do arranjo mencionado abaixo. Leia os itens de acordo com as regras de cima para baixo, as primeiras partes serão a base do próximo conteúdo. Particularmente para o apêndice que você pode consultar a qualquer momento, ele contém alguns livros que eu uso para projetar este arquivo.
Para sincronizar e ser fácil de controlar, a camada principal contém o método principal para executar o código da mesma forma que o conteúdo da lição. Outras classes da lição para ilustrar. Por exemplo, a lição sobre interface está na
Interface.javatem classes:Movable,Trackable,Drone,Interface, as classesMovable,TrackableeDronetêm o efeito de interpretar o conhecimento da lição e as classesInterfacepara executar o código das classes anteriores.
Este item é quase o mesmo pedido do meu armazenamento: estrutura de dados e algoritmo usando C/C ++ , exceto que está escrito no idioma Java. Haverá algumas diferenças entre os dois idiomas, os leitores podem compará -los eles mesmos.
Java é uma linguagem de programação e uma tradução (e interpretada . Em Java, o código -fonte é traduzido para o bytecode, que são indicadores binários simples que funcionam como o código do computador para computadores. No entanto, diferentemente de C ou C ++, Java Bytecode não é o código de máquina nativo para um processador específico, mas para um java (JVM) virtual virtual), a Máquina Virtual, a Virtual, a Machine, a Machine, a Machine, para um processador específico, mas para um java (JVM) virtual), a Máquina Virtual, a Máquina Virtual, a Machine, para um processador específico, mas para um java (JVM) virtual), o Código de Mágua, mas para um Java (JVM) virtual, Java), o Código de Máquina de Machine, mas para um Java (JVM) virtual, o Java), o Código de Máquina de Java (JVM).
Este bytecode foi então traduzido e executado pela máquina virtual Java como se fosse um código de máquina nativo. A JVM funciona como um sistema operacional ativo no gerenciamento de comandos de memória e processamento, garantindo a segurança e o celular do código. Todas as características do idioma Java são claramente definidas, independentemente do sistema específico do sistema básico, ajudando a Java a ser capaz de executar homogêneo em muitas plataformas diferentes sem a edição de código.
A JVM fornece um ambiente de aplicação segura, onde executa funções semelhantes a um sistema operacional. Ele gerencia a memória, executando comandos com base em pilhas e processamento de tipos de água. Isso minimiza os riscos de segurança e aumenta a estabilidade do aplicativo.
Seja parecido com C e C ++ em termos de sintaxe, o Java não é um descendente direto de C ou a próxima versão do C ++. Java tem mais em comum com linguagens dinâmicas como SmallTalk e Lisp, em vez de C. A similaridade apenas para na sintaxe externa, como o uso de muitos aparelhos e semicolons. Java herda a filosofia de uma boa linguagem que deve ser compacta, fácil de lembrar, mas expandir o vocabulário por meio de pacotes de classe Java.
Os idiomas de script, como Perl, Python e Ruby, são muito populares porque são adequados para aplicativos seguros e em rede. No entanto, a maioria das linguagens de script não é projetada para programação grave em grande escala. Eles geralmente não são adequados para projetos grandes ou complexos devido à estrutura do programa solta e ao sistema de dados simples.
O Java fornece uma plataforma segura para desenvolver estruturas de nível superior e até outros idiomas, combinando a simplicidade e os recursos do Java que permitem o rápido e fácil desenvolvimento de aplicações. O Java também aprendeu com os recursos do SmallTalk e os melhora, especialmente no uso do conjunto de testes de bytecode para garantir a precisão do código da campanha, ajudando a melhorar o desempenho e garantir a segurança do que o SmallTalk.
O Java foi projetado para ser um idioma seguro, não apenas contra erros de software, mas também problemas comuns no design e programação. O Java oferece muitas camadas de proteção, a partir do teste de segurança do código antes de executar a maneira como o carregador de classe é carregado, um mecanismo de carga de bytecode da interpretação Java, criando uma "parede" em torno de classes não confiáveis. Esses recursos são a base para políticas de segurança de alto nível, permitindo ou não permitir vários tipos de atividades em cada aplicativo.
O Java começa em uma "placa branca" e, portanto, pode evitar recursos complexos ou controversos em outros idiomas. Por exemplo, o Java não permite que os programadores regenere os operadores (como + feno -), sem dinheiro de processamento de dinheiro como macros ou declarações #Define, coisas que geralmente são usadas em outros idiomas para apoiar a dependência da plataforma.
O Java também fornece uma estrutura de pacote clara para organizar arquivos de classe, ajudando o processo de compilação a lidar com algumas funções da ferramenta tradicional feita -feita de maneira eficaz. Todas as informações do tipo de dados são preservadas nas classes Java compiladas, sem a necessidade de excesso de arquivos de título de origem como em C/C ++. Isso facilita a leitura do código Java e menos contexto.
O Java suporta apenas a herança (cada classe tem apenas uma aula de "pai"), mas permite a herança de muitas interfaces. A interface em Java, semelhante à camada abstrata em C ++, identifica o comportamento de um objeto sem defender sua execução. Esse é um mecanismo poderoso que permite ao desenvolvedor definir um "contrato" do comportamento do objeto que pode ser usado e referenciado independentemente a qualquer execução específica do objeto.
O Java elimina o uso de cursores que podem se referir a qualquer área de memória e adicionar coleta automaticamente de lixo e segmento de alto nível. Esses recursos ajudam a eliminar muitos problemas relacionados à segurança, conversão e otimização que outros idiomas geralmente encontram. Em Java, não mais utilizados indivíduos recuperarão automaticamente a memória, minimizarão os erros manuais de gerenciamento de memória.
O Java não usa o cursor tradicional, mas é uma referência mais apertada e segura. Os indivíduos em Java, exceto os tipos primitivos, são acessados por meio de referência. Isso permite a criação de estruturas de dados complexas com segurança em um tipo de dados sem riscos relacionados ao cursor em C/C ++.
O Java foi projetado para lidar com erros de maneira inteligente e eficaz, graças ao forte mecanismo de gerenciamento de exceções. No Java, os erros não são apenas capturados e processados em um local específico no programa através do bloco de código "Catch", mas também embalados em exceções. Cada um desses objetos traz informações sobre a causa do erro, facilitando que os programadores entendam e lidem com erros corretamente. A tradução Java exige que o método declare as exceções de que ele pode surgir ou lidar com eles imediatamente. Isso ajuda a trazer as informações de erro ao mesmo nível com outras informações, como o tipo de dados de retorno ou o método do método. Desse modo, ao programar, você pode prever e se preparar para possíveis situações, garantindo que seu aplicativo opere mais estável e seguro.
Na programação e desenvolvimento de software, a Convenção de Nomeação é uma coleção de regras para selecionar nomes de variáveis, mandíbulas, classes e outros objetos no código -fonte. A Convenção de Identificação facilita a leitura do código -fonte, fácil de entender e mais fácil de manter. Meu armazenamento está em conformidade com esta convenção, mencionada abaixo.
Classe: o nome da classe sempre começa com a letra impressa (PascalCase). Se o nome da classe consistir em muitas palavras, cada palavra também deve começar com a impressão floral. Por exemplo: Student , Car , ColorChooser .
Interface: como a classe, o nome da interface também usa PascalCase. Muitas vezes, o nome da interface começa com letras maiúsculas, como I ou uso o idiota/sufixo, como able ou ible para descrever o recurso, como Runnable , Accessible .
O método do método sempre inicia em letras normais e segue o camelcase. O nome do método geralmente é os verbos ou frases de verbos que descrevem a ação que o método executa. Por exemplo: getName() , calculateTotalWidth() .
O nome da variável também deve começar com letras normais e seguido por camelcase. O nome da variável deve ser claro e descrever o valor que eles representam. Por exemplo: height , numberOfStudents .
Um exemplo da aula 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 + "]" ;
}
}| Indicações de acesso | público | Protegido | padrão | Privado | |
|---|---|---|---|---|---|
| Junto com o pacote | Dentro da classe | Ter | Ter | Ter | Ter |
| Subclass | Ter | Ter | Ter | Não são | |
| Outra classe | Ter | Ter | Ter | Não são | |
| Pacote diferente | Subclass | Ter | Ter | Não são | Não são |
| Outra classe | Ter | Não são | Não são | Não são | |
A Linguagem de Modelagem Unificada (UML) é uma ferramenta de modelagem gráfica padrão, projetada para esboçar, descrever e documentos sobre diferentes aspectos do software de aplicativos. É especialmente útil no campo da programação orientada ao objeto, porque fornece uma maneira intuitiva de mostrar classes, objetos e relacionamentos entre eles. A UML inclui muitos tipos diferentes de diagramas, mas no contexto de programação orientada ao objeto, diagrama de classe (diagramas de classe) e diagrama interativo (diagramas de interação) são os dois tipos mais usados.
A UML permite que os programadores descrevam a estrutura do sistema usando diagramas de classe. Esse diagrama mostra classes no sistema, atributos, seus métodos e, o mais importante, a relação entre classes como herança, ligação, síntese e combinação. Isso ajuda os programadores a entender e a projetar o sistema mais sistematicamente.
Depois que o diagrama UML for concluído, ele pode ser usado como base para escrever código -fonte. Na OOP, a transferência do diagrama da camada para o código -fonte (geralmente Java, C#ou C ++) é bastante direta, devido à semelhança entre os conceitos descritos no UML e a estrutura da camada nessas linguagens de programação.
A UML ajuda a definir claramente as relações entre os objetos, destacar o modo de comunicação e interação entre eles através do diagrama de sequência (diagramas de sequência) e diagrama de colaboração (diagramas de colaboração). Isso ajuda os programadores a entender o fluxo e o controle de dados no aplicativo.
Antes de começar a escrever códigos, a UML ajuda o grupo de desenvolvimento a detectar e corrigir problemas de design. A unidade no uso da UML também ajuda os membros do grupo a entender facilmente as idéias um do outro, aumentando assim a eficiência da coordenação de trabalho.
A UML fornece documentos completos para o software, o que é muito útil no estágio de manutenção e atualização do software. Um bom diagrama UML pode ajudar novas pessoas que participam do projeto a capturar rapidamente a estrutura e a função do sistema.
O diagrama de classe (diagrama de classe) é um dos tipos de diagramas usados no UML e desempenha um papel importante na modelagem do sistema de software. O diagrama de classe fornece uma visão geral da estrutura de um aplicativo exibindo as camadas do sistema, seus atributos e métodos e a relação entre essas camadas. Esses relacionamentos podem incluir: link (associação), herança (herança), aplicação (realização), dependência, agressão, composição.
Uma classe representa um conceito que inclui status (atributo) e comportamento (método). Cada atributo tem um tipo. Cada método tem uma assinatura. O nome da classe é a única informação obrigatória.
Considere o seguinte exemplo:
Este diagrama UML corresponde ao Animal de classe no código da seguinte forma:
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 ;
}
} Símbolos + , - e # e # e # e nomes de métodos em uma camada indicam o nível de capacidade de acesso do atributo e do método. Especificamente:
+ indica o atributo ou método de público (público).- indicando os métodos de propriedades ou privacidade (privado).# indica a propriedade ou método de proteção (protegido).
Flyable com um método fly() , a classe Bird poderá executar essa interface implantando o método fly() .School pode ter muitos objetos da aula Teacher , mas os professores ainda existem independentemente da escola.House pode conter muitos objetos da Room . Quando a House for cancelada, os Room também serão cancelados.| Herança | Juntar | |
|---|---|---|
| Definir | - A herança é um mecanismo no qual uma camada (chamada de sub -camada) pode herdar a natureza e o método de outra camada (chamada de classe pai). - Permita que a subdivisão reutilize o código do pai sem reescrever. - correspondente ao relacionamento "IS-A". | - O elemento é uma forma de relação "lá" entre duas camadas. - indica uma relação em que um objeto pode conter ou se referir a outros objetos, mas os dois sujeitos podem existir independentemente. - correspondente ao relacionamento "Has-A". |
| Propósito | - Reutilize o código e melhore o módulo do aplicativo. - Suporte também o polimorfismo, permitindo que o método da criança possa substituir ou expandir o método da classe pai. - Por exemplo: a classe de animais tem um método move (), as aulas de pássaros e peixes podem herdar animais e usar ou substituir o método move () para se adequar à sua natureza em movimento. | - Representando a relação entre objetos, onde os objetos podem ter um relacionamento parcial entre si, mas não completamente dependentes um do outro. - Ajudar a melhorar a flexibilidade na estrutura de dados e gerenciar objetos complicados. - Por exemplo, a camada quadrada pode ter objetos da camada pontual. Cada quadrado consiste em quatro objetos da camada pontual (indicando os vértices), mas os pontos podem existir independentemente sem o pico do quadrado. |
| Dependência | - A sub -classe depende fortemente da classe do pai porque usa diretamente as propriedades e métodos do Pai. | - Assuntos relevantes podem existir independentemente; Eles não dependem fortemente juntos. |
| Habilidade | - Expanda ou personalize a camada do pai. - Modelando o relacionamento descentralizado. | - Gerenciar objetos associados. - Modelando relacionamentos físicos. |
Considere o seguinte exemplo:
Implantar este diagrama UML em Java é o seguinte:
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
}
}
