Nous avons essayé de définir des classes. Définir une classe, c'est créer un nouveau type. Une fois la classe en place, nous construisons ensuite des objets du type correspondant. De plus, chaque type doit également avoir une interface claire que les utilisateurs peuvent utiliser.
Nous pouvons utiliser d'autres objets dans la définition d'une nouvelle classe. C'est la composition. La combinaison est l’un des moyens de base pour parvenir à la réutilisabilité des programmes en Java.
Combinaison avec "has-a"
Un objet est une donnée membre d’un autre objet. Par exemple, regardons l’exemple de lampe de poche rechargeable mentionné précédemment :
La batterie, la lumière LED, le bouton... dans une lampe de poche rechargeable peuvent tous être un objet. Nous pouvons définir une classe Battery pour définir et générer des objets batterie. Dans la définition de classe de la lampe de poche rechargeable, un objet batterie peut être utilisé comme membre de données pour représenter l'état de la partie batterie.
Nous définissons une classe de batterie ci-dessous et utilisons la puissance pour représenter sa puissance. Une batterie peut être chargée (chargeBattery) et utilisée (useBattery). Nous utilisons des objets de type Battery comme données membres dans la définition suivante de la classe Torch :
Copiez le code comme suit :
classeBatterie
{
Charge vide publiqueBatterie (double p)
{
si (cette.puissance < 1.) {
ceci.puissance = ceci.puissance + p;
}
}
utilisation booléenne publiqueBatterie (double p)
{
si (this.power >= p) {
ceci.puissance = ceci.puissance - p;
renvoie vrai ;
}
autre {
cette.puissance = 0,0 ;
renvoie faux ;
}
}
double puissance privée = 0,0 ;
}
classeTorche
{
/**
* 10 % de puissance par heure d'utilisation
* avertissement en cas de panne de courant
*/
activation du vide public (heures int)
{
booléen utilisable ;
utilisable = this.theBattery.useBattery( heures*0.1 );
if (utilisable != vrai) {
System.out.println("Plus utilisable, il faut charger !");
}
}
/**
* 20 % de puissance par heure de charge
*/
frais publics nuls (int heures)
{
this.theBattery.chargeBattery( heures*0,2 );
}
/**
* composition
*/
Batterie privée theBattery = new Battery();
}
Le nouveau ci-dessus alloue de la mémoire pour l’objet Battery et est indispensable.
Nous définissons la classe Battery. La classe Torch utilise un objet de type Batterie (theBattery) comme donnée membre. Dans la méthode de Torch, nous implémentons la fonctionnalité (fonctionnalité) fournie par la classe Battery en manipulant l'interface de l'objet Battery.
Nous disons qu'un objet Torch a (a-a) un objet Battery. La relation ci-dessus peut être exprimée comme suit :
has-a : La lampe de poche a une batterie (notez la connexion en forme de losange ci-dessus)
Grâce à la combinaison, nous pouvons réutiliser le code lié à la batterie. Si nous avons d’autres classes qui utilisent Battery, comme des téléphones portables et des calculatrices, nous pouvons y combiner des objets Battery. Cela élimine le besoin d’écrire des fonctions associées distinctes pour chaque classe.
Nous pouvons ajouter une classe Test pour voir l’effet réel :
Copiez le code comme suit :
Test de classe publique
{
public static void main (String[] arguments)
{
Torche aTorch = new Torch();
System.out.println("Charge : 2 heures");
aTorch.charge(2);
System.out.println("Première mise sous tension : 3 heures");
aTorch.turnOn(3);
System.out.println("Deuxième mise sous tension : 3 heures");
aTorch.turnOn(3);
}
}
Le résultat de l'exécution du programme ci-dessus :
Chargement : 2 heures
Première mise sous tension : 3 heures
Deuxième mise sous tension : 3 heures
Plus utilisable, faut charger !
Nous utilisons les fonctions fournies par l'objet batterie par combinaison, comme détecter si la batterie est épuisée (en fonction de la valeur de retour de useBattery()).
type de base
De HelloWorld à l'orienté objet, nous appelons les types de base int, float, double, boolean, etc. (types primitifs), qui sont des classes spéciales. Nous pouvons comprendre un entier comme un objet de type int. Le type int peut avoir des interfaces d'opération telles que l'affectation, l'addition et la soustraction. Les types ordinaires peuvent être considérés comme des extensions des types de base. Nous avons vu des types primitifs en tant que membres de données, paramètres de méthode, valeurs de retour de méthode et variables automatiques à l'intérieur des méthodes. Des objets naturels et courants, tels que des objets de classe Batterie et Torche, peuvent également être utilisés dans ces endroits.
En langage C, les types de données disponibles sont (essentiellement) prédéfinis, tels que int et float. En Java, en plus d'utiliser ces types de données prédéfinis, nous pouvons également personnaliser les types de données souhaités via des classes, puis les utiliser via des combinaisons. Mais il existe des différences entre les types de base et les types ordinaires. Les types de base sont souvent utilisés et occupent une petite quantité d'espace mémoire. Par conséquent, en Java, par souci d'efficacité, ces types de base ont des méthodes de gestion de mémoire différentes des types ordinaires (c'est-à-dire des classes personnalisées). Par exemple, les types de base se verront allouer de l'espace mémoire une fois déclarés, tandis que les types ordinaires doivent utiliser le nouveau mot-clé pour allouer de l'espace mémoire.
Java fournit des types communs correspondants pour chaque type de base. Par exemple, le type de base int correspond au type Integer. Si un objet d'un type de base est converti en une variable de type commun correspondante, le type dit de base devient un type au sens général (il n'y a plus de différence dans la gestion de la mémoire).
De cette façon, nous comprenons mieux le concept Java selon lequel « tout est un objet ».
Résumer
combinaison, a-un
type de base