Cet article vous apporte des connaissances pertinentes sur java. Il présente principalement les problèmes liés à l'orientation objet Java, y compris les caractéristiques de base de l'orientation objet, la relation entre les objets, etc. J'espère qu'il sera utile à tout le monde.
Apprentissage recommandé : "Tutoriel Java"
2. Orienté objet
3. Distribué
4. Robustesse
Java a annulé les pointeurs puissants mais dangereux et les a remplacés par des références. Étant donné que les pointeurs peuvent effectuer des opérations de déplacement, les pointeurs peuvent pointer vers n'importe quelle zone mémoire, que cette zone soit disponible ou non, car il s'avère que cette adresse mémoire peut stocker des données importantes ou être occupée par d'autres programmes, et l'utilisation de pointeurs l'est également. il est facile pour les tableaux de sortir des limites.
Mécanisme de récupération de place : les programmeurs ne sont pas tenus de contrôler directement le recyclage de la mémoire, et le garbage collector récupère automatiquement la mémoire inutilisée en arrière-plan. Empêchez le programme d'oublier de recycler à temps, provoquant des fuites de mémoire. Évitez les erreurs de programme lors du recyclage de la mémoire de la bibliothèque de classes principale du programme, provoquant des pannes du système.
Mécanisme de gestion des exceptions : le mécanisme d'exception Java repose principalement sur les cinq mots-clés try, catch, enfin, throw et throws.
Conversion de type forcée : la conversion forcée ne peut réussir que si les règles de conversion forcée sont respectées.
Java utilise le cryptage à clé publique (PKC) lors de la transmission du bytecode.
Fournit des mécanismes de sécurité à quatre niveaux dans l'environnement d'exécution : vérificateur de bytecode - chargeur de classe - disposition de la mémoire d'exécution - restrictions d'accès aux fichiers.
Le compilateur génère un format de fichier objet neutre en termes d'architecture, qui est un code compilé qui peut s'exécuter sur de nombreux processeurs tant qu'il existe un système d'exécution Java. Le compilateur Java réalise cette fonctionnalité en générant des instructions de bytecode indépendantes d'une architecture informatique spécifique. Un bytecode bien conçu peut non seulement être facilement interprété et exécuté sur n’importe quelle machine, mais peut également être rapidement traduit en code machine local.
Le bytecode est neutre en termes de structure et n'a rien à voir avec la structure informatique.
La plus grande caractéristique du langage Java est sa prise en charge de la portabilité. La soi-disant portabilité signifie que le même programme peut être déployé arbitrairement entre différents systèmes d'exploitation, ce qui réduit la difficulté de développement si vous le souhaitez. pour obtenir un contrôle de portabilité en Java, vous vous appuyez principalement sur la JVM (Java Virtual Machine). La machine virtuelle Java est un ordinateur simulé par logiciel et matériel. Tous les programmes peuvent être exécutés à condition qu'ils soient pris en charge par la machine virtuelle Java, et différentes versions de JVM existent sur différents systèmes d'exploitation, afin d'activer la portabilité.
Le droit d'auteur appartient à l'auteur. Pour une réimpression commerciale, veuillez contacter l'auteur pour obtenir une autorisation. Pour une réimpression non commerciale, veuillez indiquer la source.
Certaines personnes disent que Java est compilé. Étant donné que tout le code Java doit être compilé, .java ne peut pas être exécuté sans compilation. Certains disent aussi que Java est interprété. Étant donné que le code Java ne peut pas être exécuté directement après la compilation, il est interprété et exécuté sur la JVM, il est donc interprété.
Le compilateur juste à temps peut surveiller les codes fréquemment exécutés et optimiser ces codes pour augmenter la vitesse. Une optimisation plus complexe consiste à éliminer les appels de fonction (c'est-à-dire l'inline). Le compilateur juste à temps sait quelles classes ont été chargées. L'inline peut être utilisée si des fonctions spécifiques ne seront pas remplacées en fonction de l'ensemble de classes actuellement chargé. Les optimisations peuvent également être annulées si nécessaire.
signifie que ce programme (un processus) génère plus d'un thread lorsqu'il est en cours d'exécution.
Java est essentiellement un langage statique, pas un langage dynamique. La caractéristique remarquable des langages dynamiques est que la structure du programme ou le type de variable peut être modifié lorsque le programme est en cours d'exécution. Les langages dynamiques typiques incluent Python, Ruby, Javascript, etc. Java n'est pas un langage dynamique, mais Java a un certain degré de dynamique, qui se reflète dans les aspects suivants :
Lorsqu'il n'y a aucune référence à un objet, l'objet devient un objet inutile. Le garbage collector de Java analyse automatiquement la zone de mémoire dynamique des objets, collecte et libère les objets non référencés en tant que déchets. Lorsque le système manque de mémoire ou appelle System.gc() pour exiger un garbage collection, le thread de garbage collection s'exécute de manière synchrone avec le système.
3. Classe
Une classe est une collection d'objets avec les mêmes attributs et méthodes. Elle fournit une description abstraite unifiée pour tous les objets appartenant à la classe et comprend deux parties principales : les attributs et les méthodes. Dans les langages de programmation orientés objet, une classe est une unité de programme indépendante. Elle doit avoir un nom de classe et comprendre deux parties principales : les attributs et les méthodes.
L'implémentation de la classe en Java se compose de deux parties : la déclaration de classe et le corps de la classe.
[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]{……}Parmi eux, les modificateurs public, abstract et final décrivent les attributs de la classe, className est le nom de la classe, superclassName est le nom de la classe parent de la classe et interfaceNameList est la liste des interfaces implémentées par la classe.
class className{
[public | protected | private ] [static] [final] [transient] [volatile] type variableName;//成员变量
[public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList]{
statements
}//成员方法
}La signification du qualificatif de variable membre :
L'implémentation de la méthode comprend également deux parties : la déclaration de la méthode et le corps de la méthode.
La déclaration de méthode comprend le nom de la méthode, le type de retour et les paramètres externes. Le type des paramètres peut être un type de données simple ou un type de données composite (également appelé type de données de référence).
Pour les types de données simples, Java implémente le transfert de valeur. La méthode reçoit la valeur du paramètre, mais ne peut pas modifier la valeur de ces paramètres. Si vous souhaitez modifier la valeur d'un paramètre, utilisez un type de données référence, car le type de données référence transmet à la méthode l'adresse des données en mémoire, et l'opération sur les données dans la méthode peut modifier la valeur des données. .
Le corps de la méthode est l'implémentation de la méthode, qui comprend la déclaration des variables locales et toutes les instructions Java légales. La portée des variables locales déclarées dans le corps de la méthode se trouve à l'intérieur de la méthode. Si la variable locale porte le même nom qu'une variable membre de la classe, la variable membre de la classe est masquée.
Afin de distinguer les paramètres des variables membres de la classe, nous devons utiliser ceci. ceci est utilisé dans une méthode pour faire référence à l'objet actuel, et sa valeur est l'objet qui a appelé la méthode. La valeur de retour doit être cohérente avec le type de retour, ou exactement la même, ou une sous-classe de celui-ci. Lorsque le type de retour est une interface, la valeur de retour doit implémenter l'interface.
Les commentaires en Java sont utilisés pour expliquer votre code. Les commentaires Java ne seront pas exécutés, vous pouvez donc ajouter des commentaires à volonté.
(1) Les paramètres explicites sont les paramètres entre parenthèses du nom de la méthode.
(2) Le paramètre implicite est le champ d'instance de la classe appelée dans la méthode de classe. Le champ d'instance appelé est le paramètre implicite.
(3) Exemple de code
package com.nezha.javase;
public class Test1107 {
private int score;
/**
* x为显式参数
* score为隐式参数
* @param x
*/
public void addScore(int x){
int temp = this.score + x;
score += temp;
}
}Si vous ajoutez ceci devant le paramètre implicite, le paramètre implicite sera plus clair.
Il est recommandé d'ajouter cet opérateur devant le paramètre implicite. Cet opérateur représente cette classe.
Avant jdk5, chaque méthode Java avait un nombre fixe de paramètres. Cependant, la version actuelle fournit un moyen d'utiliser des paramètres variables.
Prenons comme exemple le sud le plus couramment utilisé.
System.out.println("获奖编号："+i);println appelle en interne
public PrintStream printf(String format, Object ... args) {
return format(format, args);
}Object...Le type de paramètre est exactement le même que Object[], ce qui signifie...cette méthode de déclaration peut être utilisée pour recevoir le même type de tableau, mais il n'y a pas de taille fixe du tableau, car cela est possible Paramètres variables.
Les points de suspension ici... font partie du code Java qui indique que cette méthode peut recevoir n'importe quel nombre d'objets.
En fait, la méthode printf reçoit deux paramètres, l'un est la chaîne de format et l'autre est le tableau Object[], qui stocke tous les paramètres (si les paramètres sont des types basiques, la boxe automatique les convertira en objets).
Le compilateur doit convertir chaque appel en printf pour lier les arguments à un tableau et les mettre automatiquement en boîte si nécessaire.
L'encapsulation consiste à masquer autant que possible les détails internes de l'objet, à former une frontière avec l'extérieur et à ne conserver que des interfaces et des méthodes limitées pour interagir. avec le monde extérieur. Le principe de l'encapsulation est d'empêcher des parties autres que l'objet d'accéder et de manipuler à volonté les propriétés internes de l'objet, empêchant ainsi le monde extérieur d'endommager les propriétés internes de l'objet.
（1）可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。
（2）封装的优点
（3）代码实例
package com.nezha.javase;
public class Student {
//将 id、name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
private Integer id;
private String name;
private Integer age;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。
Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：
对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各个子类中具有不同的语义。
Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。
依赖关系表示一个类依赖于另一个类的定义。例如，一个人(Person)可以买车(car)和房子(House)，Person类依赖于Car类和House类的定义，因为Person类引用了Car和House。与关联不同的是，Person类里并没有Car和House类型的属性，Car和House的实例是以参量的方式传入到buy()方法中去的。一般而言，依赖关系在Java语言中体现为局域变量、方法的形参，或者对静态方法的调用。
关联(Association）关系是类与类之间的联接，它使一个类知道另一个类的属性和方法。关联可以是双向的，也可以是单向的。在Java语言中，关联关系一般使用成员变量来实现。
La relation d'agrégation (agrégation) est un type de relation d'association et est une relation d'association forte. L'agrégation est la relation entre un tout et un individu. Par exemple, la relation entre la catégorie automobile et la catégorie moteur, la catégorie pneu et d’autres catégories de pièces est la relation entre le tout et l’individu. Comme les relations d'association, les relations d'agrégation sont également implémentées via des variables d'instance. Or, les deux classes impliquées dans la relation d'association sont au même niveau, tandis que dans la relation d'agrégation, les deux classes sont à des niveaux inégaux, l'une représentant le tout et l'autre représentant la partie.
Composition (Composition) est un type de relation d'association, qui est une relation plus forte que la relation d'agrégation. Cela nécessite que l'objet représentant le tout dans une relation d'agrégation ordinaire soit responsable de représenter le cycle de vie d'une partie de l'objet, et la relation de combinaison ne peut pas être partagée. L'objet représentant le tout doit être responsable du maintien en vie de l'objet partiel et, dans certains cas, de l'anéantissement de l'objet responsable de la partie. Un objet représentant un tout peut transmettre un objet représentant une partie à un autre objet, qui est responsable du cycle de vie de cet objet. Autrement dit, l'objet représentant la pièce ne peut être combiné qu'avec un seul objet à chaque instant, et ce dernier est exclusivement responsable du cycle de vie. Les pièces ont le même cycle de vie que l’ensemble.
Apprentissage recommandé : "Tutoriel d'apprentissage Java"
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
