Parlons brièvement de Java orienté objet

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"

1. Effets spéciaux Java

1. Les gens veulent construire un système qui peut être programmé sans formation professionnelle approfondie et qui doit être en ligne. avec la pratique courante d'aujourd'hui. Par conséquent, même si les gens trouvent que le C++ n'est pas adapté, Java est conçu aussi près que possible du C++ afin que le système soit plus facile à comprendre. Java élimine de nombreuses fonctionnalités rarement utilisées, difficiles à comprendre et déroutantes du C++. À l’heure actuelle, ces fonctionnalités causent bien plus de problèmes que de bien.

En effet, la syntaxe Java est une version « pure » de la syntaxe C++. Il n'y a pas de fichiers d'en-tête, d'arithmétique de pointeur (ni même de syntaxe de pointeur), de structures, d'unions, de surcharge d'opérateurs, de classes de base virtuelles, etc. Cependant, les concepteurs n’ont pas tenté d’éliminer toutes les fonctionnalités inappropriées du C++. Par exemple, la syntaxe de l'instruction switch n'a pas changé en Java. Si vous connaissez le C++, il vous sera facile de convertir en syntaxe Java.

Lorsque Java est sorti, C++ n'était en fait pas le langage de programmation le plus couramment utilisé. De nombreux développeurs utilisent Visual Basic et son environnement de programmation glisser-déposer. Ces développeurs ne trouvent pas Java facile. Il a fallu de nombreuses années pour que l'environnement de développement Java rattrape son retard. Aujourd'hui, l'environnement de développement Java a évolué bien au-delà de celui de la plupart des autres langages de programmation.

Un autre aspect de la simplicité est la petitesse. L’un des objectifs de Java est de prendre en charge le développement de logiciels pouvant s’exécuter de manière indépendante sur de petites machines. L'interpréteur de base et la prise en charge des classes ne représentent qu'environ 40 Ko ; l'ajout de la bibliothèque de classes standard de base et de la prise en charge des threads (essentiellement un micro-noyau autonome) ajoute environ 175 Ko.

À l’époque, c’était un exploit incroyable. Bien entendu, en raison de l’expansion continue, la bibliothèque de classes est déjà assez grande. Il existe désormais une édition Java Micro distincte (JavaMicroEdition) avec une bibliothèque de classes plus petite, adaptée aux appareils embarqués.

2. Orienté objet

L'orienté objet est une méthode de programmation émergente, ou une nouvelle spécification de programmation, son idée de base est d'utiliser des concepts de base tels que les objets, les classes, l'héritage, l'encapsulation et le polymorphisme pour effectuer la programmation. Construire des systèmes logiciels basés sur des choses objectivement existantes (c'est-à-dire des objets) dans le monde réel et utiliser autant que possible la pensée naturelle humaine dans la construction de systèmes.

3. Distribué

Pour les utilisateurs, ce à quoi ils sont confrontés dans un système distribué est simplement un serveur qui fournit les services dont les utilisateurs ont besoin. En fait, ces services sont un système distribué composé de nombreux serveurs derrière lui. le système distribué ressemble à un superordinateur.

4. Robustesse

L'environnement multiplateforme du Web a des exigences particulières pour les programmes, car les programmes doivent s'exécuter de manière fiable sur différents systèmes. Par conséquent, la capacité de créer des programmes robustes a reçu une grande priorité lors de la conception de Java. Afin d'assurer la fiabilité, Java impose des restrictions dans certains domaines clés, obligeant ainsi les programmeurs à détecter les erreurs dès le début du développement du programme. Dans le même temps, les programmeurs n’ont plus à se soucier de la plupart des problèmes les plus courants à l’origine d’erreurs de programmation. Java étant un langage fortement typé, il vérifie le code au moment de la compilation. Bien entendu, quoi qu’il arrive, le code est également vérifié au moment de l’exécution. De nombreux bogues difficiles à suivre sont souvent difficiles à reproduire au moment de l'exécution. Cette situation est presque impossible à produire en Java. Parce que faire en sorte que le programme écrit s'exécute de manière prévisible dans différentes conditions de fonctionnement est l'une des fonctionnalités clés de Java. Pour mieux comprendre la robustesse de Java, analysons les deux principales causes d'échec d'un programme : les erreurs de gestion de la mémoire et les exceptions non gérées (c'est-à-dire les erreurs d'exécution). Dans les environnements de programmation traditionnels, la gestion de la mémoire est une tâche difficile et fastidieuse. Par exemple, en C/C++, le programmeur doit allouer et libérer manuellement toute la mémoire dynamique. Parfois, cela peut causer des problèmes, car le programmeur peut oublier de libérer la mémoire précédemment allouée, ou pire, essayer de libérer de la mémoire qui est encore utilisée par d'autres parties du programme. Java peut essentiellement éliminer ces problèmes en gérant pour vous l'allocation et la désallocation de mémoire (en fait, la libération de mémoire est complètement automatique, car Java assure le garbage collection pour les objets qui ne sont plus utilisés). Les exceptions dans les environnements traditionnels sont souvent provoquées par des erreurs de type « diviser par zéro » ou « fichier introuvable » et doivent être gérées à l'aide de structures à la fois maladroites et difficiles à comprendre. Java aide dans ce domaine en fournissant des capacités de gestion des exceptions orientées objet. Dans un programme Java bien écrit, toutes les erreurs d'exécution peuvent et doivent être gérées par le programme.

5. Sécurité

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.

6. Architecture neutre

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.

7. Portabilité

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.

8. Interprétabilité

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é.

9. Hautes performances

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.

10. Multi-threading

signifie que ce programme (un processus) génère plus d'un thread lorsqu'il est en cours d'exécution.

11. Dynamicness

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 :

Mécanisme de réflexion
1. Opérations de bytecode dynamiques
2. Compilation dynamique ;
3. II, Objet
4. Un objet est une entité utilisée pour décrire des choses objectives dans le système. C'est une unité de base qui constitue le système. Un objet est constitué d'un ensemble de propriétés et d'un ensemble de services qui opèrent sur l'ensemble de propriétés.

L'instanciation d'une classe peut générer des objets. Le cycle de vie d'un objet comprend trois étapes : la génération, l'utilisation et l'élimination.

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.

1. Déclaration de 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.

2. Corps de 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 :

• statique : variable statique (variable de classe)
• finale : constante : variable temporaire, utilisée pour l'archivage d'objets, utilisée pour la sérialisation d'objets
• volatile : variables de contribution pour le partage entre threads simultanés

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.

• static : méthode de classe, peut être appelée directement via le nom de la classe
• abstract : méthode abstraite, pas de corps de méthode
• final : la méthode ne peut pas être remplacée
• native : intégrer du code provenant d'autres langages
• synchronisée : contrôle Accès aux threads à simultanéité multiple

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. .

3. Corps de la méthode

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.

4. Méthode de construction

• La méthode de construction est une méthode particulière. Chaque classe en Java possède une méthode constructeur qui initialise un objet de cette classe.
• Le constructeur a le même nom que le nom de la classe et ne renvoie aucun type de données.
• La surcharge est souvent utilisée pour les constructeurs.
• Le constructeur ne peut être appelé que par le nouvel opérateur

5. Commentaires

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é.

• Commentaires sur la ligne When //
• Commentaires multi-lignes/**/

6. Paramètres implicites et paramètres explicites

(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;
    }
}

• x est un paramètre explicite
• score est un paramètre implicite

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.

7. Méthodes avec paramètres variables

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.

4. Caractéristiques de base de l'orientation objet

1. Encapsulation

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）可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

• private：类中限定为private的成员，只能被这个类本身访问。
• default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
• protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
• public：类中限定为public的成员，可以被所有的类访问。

（2）封装的优点

1. 良好的封装能够减少耦合
2. 类内部的结构可以自由修改
3. 可以对成员变量进行更精确的控制
4. 隐藏信息，实现细节

（3）代码实例

1. 将 id、name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
2. 提供set方法进行赋值，提供get方法进行取值。
3. 赋值方法set中的this的作用是解决显式参数与局部变量同名的问题。

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;
    }
}

2、继承

子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

• Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。
• 继承实现了代码的复用。
• Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。
• 子类不能继承父类中访问权限为private的成员变量和方法。
• 子类可以重写父类的方法，即命名与父类同名的成员变量。

Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：

• 访问父类被隐藏的成员变量
• 调用父类中被重写的方法
• 调用父类的构造函数

3、多态

对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各个子类中具有不同的语义。

Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

• 编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
• 运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

4、重载

• 方法重载是让类以统一的方式处理不同数据类型的手段。
• 一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
• 返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。

5、重写

• 子类对父类的方法进行重新编写。如果在子类中的方法与其父类有相同的的方法名、返回类型和参数表，我们说该方法被重写 (Overriding)。
• 如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
• 子类函数的访问修饰权限不能低于父类的。

五、对象间的四种关系

1、依赖

依赖关系表示一个类依赖于另一个类的定义。例如，一个人(Person)可以买车(car)和房子(House)，Person类依赖于Car类和House类的定义，因为Person类引用了Car和House。与关联不同的是，Person类里并没有Car和House类型的属性，Car和House的实例是以参量的方式传入到buy()方法中去的。一般而言，依赖关系在Java语言中体现为局域变量、方法的形参，或者对静态方法的调用。 

2、关联

关联(Association）关系是类与类之间的联接，它使一个类知道另一个类的属性和方法。关联可以是双向的，也可以是单向的。在Java语言中，关联关系一般使用成员变量来实现。

3. Agrégation

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.

4. La relation Combinaison

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!