Object oriented Programming with Java
1.0.0
Bienvenue dans le stockage de programmation orienté Object avec Java ! Il fournit une ressource complète pour explorer et apprendre la programmation orientée objet via le langage Java.
La programmation orientée objet (programmation OOP - OOP - OOP-orientée) est un modèle de programmation populaire largement utilisé dans le développement de logiciels. Il est basé sur les concepts des «objets», qui sont des entités qui combinent à la fois les données (attributs) et les méthodes (comportements). La POO se concentre sur la conception de logiciels basée sur des objets interactifs, au lieu du processus et de la logique comme dans la programmation de programmation procédurale.
La programmation orientée objet est basée sur 4 principes de base, à savoir: emballage, héritage, polymorphisme et abstrait. Chacun de ces principes fournit une approche pour résoudre les problèmes de développement de logiciels et aider à gérer le code source plus efficacement.
1. Encapsulation : Il s'agit du concept de cachette des détails de déploiement interne de l'objet, empêchant les utilisateurs d'accéder directement aux données à l'intérieur. L'emballage aide à protéger les données et le comportement de l'objet contre l'intervention indésirable et fournit une interface unifiée pour interagir avec l'objet.
// 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 ());
}
} Dans cet exemple, name , age et salary des variables sont marqués comme private , ce qui signifie qu'ils ne peuvent pas être directement accessibles à l'extérieur de l' Employee . Au lieu de cela, getName() , getAge() , getSalary() , setName() , setAge() et setSalary() sont fournis pour accéder et mettre à jour la valeur de ces variables, en garantissant l'emballage.
2. Héritage (héritage): l'héritage permet à une nouvelle couche de hériter des propriétés et des méthodes à partir d'une couche existante. Cette nouvelle couche peut ajouter ou modifier les composants de l'héritage pour répondre à ses propres besoins, aidant à réutiliser et à étendre efficacement le code source.
// 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 est une classe de base, contenant des informations de base comme le nom et l'âge.Manager est la classe dérivée de Employee et ajoute l'attribut salary .Manager utilise un mot-clé extends à l'héritage de la classe Employee . Constructeur du Manager appelé super(name, age) ; Pour initialiser les propriétés héritées de la classe Employee .displayInfo() est écrasée dans la classe Manager pour ajouter plus d'informations sur le salaire et appeler displayInfo() de la classe de base pour afficher les informations de base.3. Polymorphisme : le polymorphisme est la capacité par laquelle différentes classes peuvent être utilisées via la même interface. La méthode peut être définie dans une couche de base et est remplacée par les méthodes du même nom dans les classes dérivées, permettant aux objets d'être traités via l'interface commune sans connaître leur type de données spécifique.
En Java, le polymorphisme est exprimé grâce à la méthode de superficie de superficie et de rechargement de la méthode (surcharge de la méthode).
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"
}
} Dans cet exemple, la méthode speak() est écrasée dans les couches Dog et Cat . Lors de l'appel de la méthode speak() sur l'objet de l'enfant, Java détermine quelle méthode sera appelée au moment de l'exécution, selon le type d'objet que la variable de référence vient.
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 dispose de trois versions de la méthode print , chacune traitant un type de données spécifique: String , int et double .print , Java déterminera la version appropriée en fonction du type de données de l'argument de transmission.Le polymorphisme est également clairement exprimé par le mécanisme d'utilisation de l'interface. L'interface dans Java est un moyen d'atteindre un polymorphisme plus élevé, permettant à une couche de déployer de nombreuses interfaces et une interface qui peut être déployée par différentes couches.
Supposons que nous ayons un CanFly d'interface et deux couches Bird et Airplane implémentent cette 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 définit la méthode fly() sans fournir le corps du corps.Bird et Airplane déploient la méthode fly() à leur manière.myBird et myAirplane sont référencés via l'interface CanFly , et lors de l'appel de la méthode fly() , le polymorphisme nous permet de ne pas nous soucier de l'objet de l'objet; Nous savons seulement qu'ils peuvent voler.4. Abstraction : Résumé permet aux programmeurs de se concentrer sur ce qu'un objet fait sans se soucier de la façon de le faire. Il crée une classe de base qui décrit une interface générale que les classes dérivées implémenteront, simplifiant la gestion de la complexité du système.
En Java, le résumé peut être fait de deux manières:
La classe abstraite est un objet qui ne peut pas être créé et peut contenir des méthodes abstraites sans corps.
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 est une couche abstraite avec des méthodes abstraites makeSound() .Dog est une classe héréditaire de Animal et doit fournir un déploiement spécifique pour la méthode abstraite makeSound() .L'interface (interface) ne peut contenir des méthodes abstraites sans déploiement.
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"
}
} Ici, Vehicle est une interface définissant deux méthodes abstraites: start() et stop() . Les couches Car et Bike déploient cette interface et fournissent un déploiement spécifique pour chaque méthode.
Similarité:
Différences:
| Classe abstraite | Interface | |
|---|---|---|
| But | - Souvent utilisé lorsque les sous-classes ont de nombreuses fonctions communes et ont besoin d'un endroit commun pour placer le code qui peut être réutilisé. - Aidez à définir un motif de base pour le sous-jardin, assurez-vous que tout le sous-classe hérite pour suivre une conception commune. | - Souvent utilisé pour définir un contrat pour une fonction sans se soucier. - Idéal pour les fonctions qui peuvent être implémentées très différentes. - Bon pour la définition des méthodes de rassemblement qu'une classe peut effectuer. |
| Déploiement | - Peut contenir à la fois des méthodes abstraites (pas de corps) et des méthodes non abstraites (avec corps). - Les classes abstraites peuvent également contenir des champs de données et des constructeurs. | - Initialement, il ne permet que la définition des méthodes abstraites sans corps. - À partir de Java 8, l'interface permet également la définition des méthodes corporelles via des méthodes par défaut et des méthodes statiques. |
| Multi-historique | - Une classe ne peut hériter qu'à partir d'une seule couche abstraite. - Cela limite la flexibilité de l'héritage multi-historique comme dans l'interface. | - Java permet à une couche d'effectuer plusieurs interfaces en même temps, fournissant une forme multi-historique. |
| Mâchoire | - Il peut y avoir des contraintes, aidant à définir les conditions initiales de la classe. | - Il n'y a pas de constructeur. |
| Champ de données | - Contrairement à l'interface, les classes abstraites peuvent avoir des champs de données qui ne sont pas en statistique et final. - Le sous-placier peut avoir des attributs distincts hérités de la couche abstraite. | - L'interface ne prend pas en charge le champ de données n'est pas statique et définitif. - Toutes les variables déclarées dans l'interface sont automatiquement considérées comme la finale statique publique. |
La programmation orientée objet apporte de nombreux avantages exceptionnels dans le développement de logiciels, ce qui en fait l'un des principaux modèles de conception et de programmation dans l'industrie des technologies de l'information. Voici les avantages:
Code de réutilisation : OOP permet aux programmeurs de réutiliser le code source via le mécanisme de succession. La couche de l'enfant peut hériter des fonctionnalités de la classe père sans réécrire ce code. Cela permet de réduire le travail de programmation, de minimiser les erreurs potentielles et d'accélérer le développement des logiciels.
Erreurs faciles à maintenir et à corriger : la structure d'emballage dans la POO aide à masquer les détails de déploiement, fournissant uniquement l'interface (interface) nécessaire aux utilisateurs. Cela facilite la maintenance du système et la mise à jour, car le changement à l'intérieur d'un objet n'affecte pas d'autres objets.
Modélisation pratique : la POO permet à la programmation de modéliser des entités réelles sous la forme d'objets logiciels, ce qui rend le code source plus facile à comprendre et à gérer. L'utilisation d'objets tels que la réalisation de données et de comportements dans le monde réel aide à développer des logiciels pour devenir plus intuitifs et plus proches du programmeur.
Expansion : grâce à la possibilité d'hériter et d'emballer, la POO est facile à développer. Une nouvelle couche peut être créée avec l'héritage d'une ou plusieurs couches qui existent sans affecter ces couches. Cela aide le système à se développer avec flexion et à s'adapter rapidement à de nouveaux besoins.
Sécurité : l'emballage aide non seulement à masquer les détails de l'implémentation, mais fournit également une couche de sécurité. Les données à l'intérieur d'un objet sont protégées contre l'accès direct externe, assurant l'intégrité et la sécurité des données.
Java est l'un des langages de programmation les plus populaires utilisés pour enseigner la programmation orientée objet pour des raisons plausibles.
Java est un langage orienté objet pur , ce qui signifie que tout dans Java est un objet ou une classe. Des concepts tels que l'héritage, l'emballage, le polymorphisme et le résumé sont complètement intégrés dans le langage. Cela aide les apprenants à accéder et à pratiquer les principes de la POO naturellement lors de la programmation.
Java a une syntaxe claire et facile à comprendre. La syntaxe de Java est basée sur C / C ++, mais a supprimé certaines fonctionnalités complexes telles que le curseur direct, ce qui en fait une langue idéale pour enseigner aux débutants. L'élimination de ces fonctionnalités complexes aide les apprenants à se concentrer sur la compréhension des concepts de base de la POO sans être enlisées dans des détails déroutants.
Java est une fondation de langue indépendante , peut fonctionner sur n'importe quel système d'exploitation avec Java (JVM) Virtual Machine. Cela signifie que les programmes Java peuvent développer et implémenter de manière cohérente sur différentes plates-formes sans modifier le code. Cette flexibilité est idéale pour l'environnement d'apprentissage, où les élèves et les enseignants peuvent utiliser une variété de matériel et de logiciels.
Lors de l'utilisation de ces archives pour l'apprentissage, vous devez suivre le principe de l'arrangement mentionné ci-dessous. Lisez les éléments conformément aux règles de haut en bas, les premières parties seront la base du contenu suivant. En particulier pour l' annexe que vous pouvez vous référer à tout moment, il contient des livres que j'utilise pour concevoir ces archives.
Pour synchroniser et être facile à contrôler, la couche principale contient la méthode principale pour exécuter le code en tant que même que le contenu de leçon. Autres classes dans la leçon à illustrer. Par exemple, la leçon sur l'interface est dans
Interface.javaa des classes:Movable,Trackable,Drone,Interface, les classesDroneMovable,Trackable, ont pour effet d'interpréter les connaissances des leçons et les classesInterfacepour exécuter du code à partir des classes précédentes.
Cet élément est presque le même ordre que mon stockage: structure de données et algorithme à l'aide de C / C ++ , sauf que cela est écrit en langue java. Il y aura quelques différences entre les deux langues, les lecteurs peuvent les comparer eux-mêmes.
Java est à la fois un langage de programmation et une traduction (et interprété . Dans Java, le code source est traduit en bytecode, qui est de simples indicateurs binaires qui fonctionnent comme le code informatique pour les ordinateurs. Cependant, contrairement à C ou C ++, le bytecode de Java n'est pas le code machine natif pour tous les processeurs spécifiques mais pour un Java (JVM) Machine Virtual Machine, une plate-forme commune pour tous les systèmes.
Ce bytecode a ensuite été traduit et exécuté par la machine virtuelle Java comme s'il s'agissait d'un code machine natif. JVM fonctionne comme un système d'exploitation actif dans la gestion des commandes de mémoire et de traitement, assurant la sécurité et le mobile du code. Toutes les caractéristiques de la langue Java sont clairement définies, quel que soit le système spécifique du système de base, aidant Java à pouvoir exécuter homogène sur de nombreuses plates-formes différentes sans modification de code.
JVM fournit un environnement d'application sûre, où il remplit des fonctions similaires à un système d'exploitation. Il gère la mémoire, l'exécution de commandes en fonction des piles et le traitement des types d'eau. Cela minimise les risques de sécurité et augmente la stabilité de l'application.
Qu'il ressemble à C et C ++ en termes de syntaxe, Java n'est pas un descendant direct de C ou de la prochaine version de C ++. Java a plus en commun avec des langues dynamiques comme Smalltalk et Lisp plutôt que C. La similitude ne s'arrête qu'à la syntaxe externe comme en utilisant de nombreux accolades et semi-virages. Java hérite de la philosophie de C d'une bonne langue qui devrait être compacte, facile à retenir, mais élargir le vocabulaire via des packages de classe Java.
Les langages de script tels que Perl, Python et Ruby sont très populaires car ils conviennent aux applications sûres et en réseau. Cependant, la plupart des langages de script ne sont pas conçus pour une programmation sérieuse à grande échelle. Ils ne conviennent souvent pas aux projets grands ou complexes en raison de la structure du programme lâche et du système de données simple.
Java fournit une plate-forme sûre pour développer des cadres de niveau supérieur et même d'autres langues, combinant la simplicité et les fonctionnalités de Java qui permettent un développement rapide et facile d'applications. Java a également appris des caractéristiques de SmallTalk et les améliore, en particulier dans l'utilisation de l'ensemble de tests bytecode pour garantir la précision du code de la campagne, aidant à améliorer les performances et à assurer la sécurité que Smalltalk.
Java est conçu pour être un langage sûr, non seulement contre les erreurs logicielles mais aussi des problèmes courants dans la conception et la programmation. Java propose de nombreuses couches de protection, à partir du test de sécurité du code avant de fonctionner à la façon dont le chargeur de classe est chargé, un mécanisme de charge de bytecode de l'interprétation Java, créant un "mur" autour de classes peu fiables. Ces fonctionnalités sont le fondement des politiques de sécurité de niveau élevé, permettant ou ne permettent pas divers types d'activités sur chaque application.
Java part à partir d'une "planche blanche" et peut donc éviter les caractéristiques complexes ou controversées dans d'autres langues. Par exemple, Java n'autorise pas les programmeurs à régénérer les opérateurs (tels que + Hay -), pas d'argent ne traitant pas de l'argent comme les macros ou les instructions #define, les choses qui sont souvent utilisées dans d'autres langues pour soutenir la dépendance à la plate-forme.
Java fournit également une structure de package claire pour organiser les fichiers de classe, aidant le processus de compilation à gérer efficacement certaines fonctions de l'outil de fabrication traditionnel. Toutes les informations de type de données sont conservées dans les classes Java compilées, sans avoir besoin de fichiers de titre de source excédentaire comme en C / C ++. Cela rend le code Java plus facile à lire et moins de contexte.
Java ne prend en charge que l'héritage (chaque classe n'a qu'une seule classe "père") mais permet l'héritage de nombreuses interfaces. L'interface de Java, similaire à la couche abstraite en C ++, identifie le comportement d'un objet sans défendre son exécution. Il s'agit d'un mécanisme puissant qui permet au développeur de définir un "contrat" du comportement de l'objet qui peut être utilisé et référencé indépendamment à toute exécution d'objet spécifique.
Java élimine l'utilisation des curseurs qui peuvent se référer à n'importe quelle zone de mémoire et ajouter une collection de déchets automatiquement et un segment de haut niveau. Ces fonctionnalités aident à éliminer de nombreux problèmes liés à la sécurité, à la conversion et à l'optimisation que d'autres langues rencontrent souvent. En Java, les sujets non utilisés révèlent automatiquement la mémoire, minimiseront les erreurs de gestion de la mémoire manuelle.
Java n'utilise pas le curseur traditionnel, mais est plutôt une référence plus serrée et plus sûre. Les sujets en Java, à l'exception des types primitifs, sont accessibles par référence. Cela permet de créer des structures de données complexes en toute sécurité dans un type de données sans risques liés au curseur en C / C ++.
Java est conçu pour gérer les erreurs de manière intelligente et efficace, grâce au solide mécanisme de gestion des exceptions. En Java, les erreurs sont non seulement capturées et traitées dans un endroit spécifique du programme via le bloc de code "Catch", mais également emballé dans des exceptions. Chacun de ces objets apporte des informations sur la cause de l'erreur, ce qui permet aux programmeurs de comprendre et de gérer correctement les erreurs. La traduction Java nécessite la méthode pour déclarer les exceptions qu'elle peut survenir ou les gérer immédiatement. Cela aide à amener les informations d'erreur au même niveau avec d'autres informations telles que le type de données de retour ou la méthode de la méthode. Ainsi, lors de la programmation, vous pouvez prédire et préparer des situations possibles, en vous assurant que votre application fonctionnera plus stable et plus sûre.
Dans la programmation et le développement de logiciels, la convention de dénomination est une collection de règles pour sélectionner les noms de variables, mâchoires, classes et autres objets du code source. La convention d'identification rend le code source plus facile à lire, facile à comprendre et plus facile à entretenir. Mon stockage est strictement conforme à cette convention, mentionnée ci-dessous.
Classe: Le nom de classe commence toujours par la lettre imprimée (Pascalcase). Si le nom de classe se compose de nombreux mots, chaque mot doit également commencer par l'impression florale. Par exemple: Student , Car , ColorChooser .
Interface: comme la classe, le nom de l'interface utilise également PascalCase. Souvent, le nom de l'interface commencera par des lettres majuscules telles que I ou utilise le stupide / suffixe comme able ou ible pour décrire la fonctionnalité, telle que Runnable , Accessible .
La méthode de la méthode commence toujours en lettres normales et suit Camelcase. Le nom de la méthode est généralement les verbes ou les phrases verbales décrivant l'action que la méthode effectue. Par exemple: getName() , calculateTotalWidth() .
Le nom de la variable doit également commencer par des lettres normales et suivi de CamelCase. Le nom de la variable doit être clair et décrire la valeur qu'ils représentent. Par exemple: height , numberOfStudents .
Un exemple de la classe 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 + "]" ;
}
}| Indications d'accès | publique | Protégé | défaut | Privé | |
|---|---|---|---|---|---|
| Avec un paquet | À l'intérieur de la classe | Avoir | Avoir | Avoir | Avoir |
| Sous-classe | Avoir | Avoir | Avoir | Ne sont pas | |
| Autre classe | Avoir | Avoir | Avoir | Ne sont pas | |
| Paquet différent | Sous-classe | Avoir | Avoir | Ne sont pas | Ne sont pas |
| Autre classe | Avoir | Ne sont pas | Ne sont pas | Ne sont pas | |
Le langage de modélisation unifiée (UML) est un outil de modélisation graphique standard, conçu pour esquisser, décrire et documenter les différents aspects du logiciel d'application. Il est particulièrement utile dans le domaine de la programmation orientée objet, car il fournit un moyen intuitif de montrer des classes, des objets et des relations entre eux. UML comprend de nombreux types de diagrammes différents, mais dans le contexte de la programmation orientée objet, du diagramme de classe (diagrammes de classe) et du diagramme interactif (diagrammes d'interaction) sont les deux types les plus couramment utilisés.
UML permet aux programmeurs de décrire la structure du système à l'aide de diagrammes de classe. Ce diagramme montre des classes dans le système, les attributs, leurs méthodes et, surtout, la relation entre des classes telles que l'héritage, le lien, la synthèse et la combinaison. Cela aide les programmeurs à comprendre et à concevoir le système plus systématiquement.
Une fois le diagramme UML terminé, il peut être utilisé comme base pour écrire le code source. Dans la POO, le transfert du diagramme de couche au code source (généralement Java, C # ou C ++) est assez direct, en raison de la similitude entre les concepts décrits dans UML et la structure de la couche dans ces langages de programmation.
UML aide à définir clairement les relations entre les objets, à mettre en évidence le mode de communication et l'interaction entre eux à travers le diagramme de séquence (diagrammes de séquence) et le diagramme de collaboration (diagrammes de collaboration). Cela aide les programmeurs à comprendre le flux de données et le contrôle dans l'application.
Avant de commencer à écrire des codes, UML aide le groupe de développement à détecter et à corriger les problèmes de conception. L'unité dans l'utilisation de l'UML aide également les membres du groupe à comprendre facilement les idées de l'autre, augmentant ainsi l'efficacité de la coordination du travail.
UML fournit des documents complets pour le logiciel, ce qui est très utile dans l'étape de maintenance et de mise à niveau du logiciel. Un bon diagramme UML peut aider de nouvelles personnes à participer au projet à capturer rapidement la structure et la fonction du système.
Le diagramme de classe (diagramme de classe) est l'un des types de diagrammes utilisés dans l'UML et il joue un rôle important dans la modélisation du système logiciel. Le diagramme de classe donne un aperçu de la structure d'une application en affichant les couches système, leurs attributs et méthodes et la relation entre ces couches. Ces relations peuvent inclure: lien (association), héritage (succession), application (réalisation), dépendance, aggrée, composition.
Une classe représente un concept qui inclut le statut (attribut) et le comportement (méthode). Chaque attribut a un type. Chaque méthode a une signature. Le nom de classe est la seule information obligatoire.
Considérez l'exemple suivant:
Ce diagramme UML correspond à Class Animal dans le code comme suit:
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 ;
}
} Les symboles + , - et # et # et # et les noms de méthode dans une couche indiquent le niveau de capacité d'accès de l'attribut et la méthode. Spécifiquement:
+ indique l'attribut ou la méthode du public (public).- indiquant les propriétés ou les méthodes de confidentialité (privé).# indique la propriété ou la méthode de protection (protégée).
Flyable avec une méthode fly() , la classe Bird peut exécuter cette interface en déploiement de la méthode fly() .School peut avoir de nombreux objets de la classe Teacher , mais les enseignants existent toujours indépendamment de l'école.House peut contenir de nombreux objets de la Room . Lorsque la House est annulée, les Room seront également annulées.| Héritage | Rassembler | |
|---|---|---|
| Définir | - L'héritage est un mécanisme dans lequel une couche (appelée sous-couche) peut hériter de la nature et de la méthode d'une autre couche (appelée classe parent). - Permettez à la subdivision de réutiliser le code du père sans réécriture. - correspondant à la relation "IS-A". | - L'élément est une forme de relation «là» entre deux couches. - Indique une relation dans laquelle un objet peut contenir ou se référer à d'autres objets, mais les deux sujets peuvent exister indépendamment. - correspondant à la relation "has-a". |
| But | - Réutilisez le code et améliorez le module de l'application. - Soutenez également le polymorphisme, permettant à la méthode de l'enfant de pouvoir écraser ou développer la méthode de la classe parent. - Par exemple: la classe animale a une méthode Move (), les classes d'oiseaux et de poissons peuvent hériter des animaux et utiliser ou remplacer la méthode Move () pour s'adapter à leur nature en mouvement. | - Représentant la relation entre les objets, où les objets peuvent avoir une relation partielle entre elles mais pas complètement dépendante les unes des autres. - Aidez à améliorer la flexibilité de la structure des données et à gérer des objets compliqués. - Par exemple, la couche carrée peut avoir des objets de la couche ponctuelle. Chaque carré se compose de quatre objets de la couche ponctuelle (indiquant les sommets) mais les points peuvent exister indépendamment sans le pic du carré. |
| Dépendance | - La sous-classe dépend fortement de la classe du père car elle utilise directement les propriétés et les méthodes du père. | - Les sujets pertinents peuvent exister indépendamment; Ils ne dépendent pas fortement ensemble. |
| Capacité | - Développez ou personnalisez la couche du père. - Modélisation de la relation décentralisée. | - Gérer les objets associés. - Modélisation des relations physiques. |
Considérez l'exemple suivant:
Le déploiement de ce diagramme UML en Java est le suivant:
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
}
}
