Résumé des fonctionnalités Java

1. Héritage (mot clé : extends) : (classe parent enfant)
1. Améliorer la réutilisabilité du code.
2. Créer une relation entre les classes. Ce n’est qu’avec cette relation que nous pouvons avoir les caractéristiques du polymorphisme.

1.1 Variables
Si une variable membre non privée (privée) portant le même nom apparaît dans la classe parent enfant, la classe enfant doit accéder à la variable dans cette classe, l'utiliser, et l'enfant la classe doit accéder au même nom dans la classe parent. Pour les variables, utilisez super.
L'utilisation de super est presque la même que celle de ceci.
Ceci représente une référence à un objet de cette classe.
Une référence à l'objet de classe parent représenté par super.

1.2 Fonctions dans la sous-classe
Lorsqu'une fonction exactement identique à la classe parent apparaît dans la sous-classe,
Lorsque l'objet de la sous-classe appelle la fonction, le contenu de la fonction de la sous-classe sera courir. Tout comme la fonction de la classe parent est remplacée.

Cette situation est une autre caractéristique des fonctions : réécriture (écrasement)

Lorsqu'une sous-classe hérite de la classe parent, elle hérite des fonctions de la classe parent dans la sous-classe, mais bien que la sous-classe ait cette fonction, mais le contenu de la fonction n'est pas cohérent avec la classe parent. Dans ce cas, il n'est pas nécessaire de définir une nouvelle fonction. Utilisez plutôt la fonction de remplacement pour conserver la définition de fonction de la classe parent et réécrire le contenu de la fonction. .

Notes sur l'écrasement :
1. Lorsqu'une sous-classe écrase une classe parent, il faut s'assurer que les autorisations de la sous-classe sont supérieures ou égales aux autorisations de la classe parent avant de pouvoir l'écraser , sinon la compilation échouera. (Si vous n'écrivez pas le modificateur d'autorisation, l'autorisation par défaut se situe entre privée et publique.)
2. Statique ne peut remplacer que statique.

Surcharge et réécriture :
Surcharge : regardez uniquement la liste des paramètres de la fonction du même nom.
Réécriture : le nom de la méthode et le type de retour dans les classes enfant et parent doivent être exactement les mêmes. (C'est-à-dire : le type de retour et le nom de la méthode () doivent être les mêmes)

1.3 Constructeur dans les sous-classes.
Lors de l'initialisation d'un objet de sous-classe, le constructeur de la classe parent s'exécutera également. En effet, le constructeur de la sous-classe a une instruction implicite super() dans la première ligne par défaut

Pourquoi les sous-classes doivent ; accéder au constructeur dans la classe parent.
Étant donné que les sous-classes de données de la classe parent peuvent être obtenues directement, lorsque tous les objets de sous-classe sont créés, vous devez d'abord vérifier comment la classe parent initialise les données. Par conséquent, lors de l’initialisation de l’objet, la sous-classe doit d’abord accéder au constructeur de la classe parent. Si vous souhaitez accéder au constructeur spécifié dans la classe parent, vous pouvez le spécifier en définissant manuellement la super instruction.

Remarque : L'instruction super doit être définie dans la première ligne du constructeur de sous-classe.

Conclusion :
Tous les constructeurs de la sous-classe accéderont par défaut au constructeur de la classe parent avec des paramètres vides.
Parce que la première ligne de chaque constructeur de la sous-classe aura un super();
Lorsqu'il n'y a pas de constructeur avec des paramètres vides dans la classe parent, la sous-classe doit spécifier manuellement les exigences sous la forme d'un super instruction. Accédez au constructeur dans la classe parent.
Bien sûr : la première ligne du constructeur de la sous-classe peut également spécifier manuellement cette instruction pour accéder au constructeur de cette classe. Il y aura au moins un constructeur dans la sous-classe qui accède au constructeur de la classe parent. (Comme this() et super() ne peuvent être placés que dans la première ligne du constructeur, un seul d'entre eux peut exister dans le constructeur.)

Remarque : ne l'utilisez jamais pour obtenir le autre Les fonctions de la classe sont héritées pour simplifier le code. Il doit y avoir une relation entre les classes avant de pouvoir en hériter. L'affiliation est un .
2.finale : finale. comme modificateur.
2.1 Les classes, fonctions et variables peuvent être modifiées.
2.2 Les classes modifiées par final ne peuvent pas être héritées. Afin d'éviter l'héritage, évitez de remplacer les fonctions par des sous-classes.
2.3 Les méthodes modifiées par final ne peuvent pas être remplacées.
2.4 Une variable modifiée par final est une constante à laquelle une valeur ne peut être attribuée qu'une seule fois. Elle peut modifier soit des variables membres, soit des variables locales. Lors de la description des choses, lorsque certaines données apparaissent, les valeurs​​sont fixes. Afin d'améliorer la lisibilité, ces valeurs​​sont nommées. Facile à lire. Cette valeur n'a pas besoin d'être modifiée, la modification finale est donc ajoutée. En tant que constante : la convention d'écriture des constantes est constituée de toutes les lettres majuscules si elles sont constituées de plusieurs mots. Les mots sont reliés par _. (ex : final double PI = 3.14 ; final int SET_ON = 1 ;)
2.5 Lorsqu'une classe interne est définie à un emplacement local dans la classe, elle ne peut accéder qu'aux variables locales modifiées par final.

3. Abstraction :
3.1 Les méthodes abstraites doivent être dans des classes abstraites.
3.2 Les méthodes abstraites et les classes abstraites doivent être modifiées par le mot-clé abstract. (abstract class class name { abstract void method name (); })
3.3 Les classes abstraites ne peuvent pas utiliser new pour créer des objets. Parce que cela ne sert à rien d’appeler des méthodes abstraites.
3.4 Pour utiliser les méthodes abstraites dans une classe abstraite, toutes les méthodes abstraites doivent être réécrites par la sous-classe puis l'objet de la sous-classe peut être appelé. Si une sous-classe ne couvre que certaines méthodes abstraites, alors la sous-classe reste une classe abstraite.
Similitudes et différences entre les classes générales et les classes abstraites : Il n'y a pas beaucoup de différence entre les classes abstraites et les classes générales. Vous pouvez décrire les choses comme vous voulez les décrire, mais il y a des choses incompréhensibles à leur sujet. Ces parties indéterminées, qui sont aussi la fonction de la chose, ont besoin d'apparaître explicitement. Mais le sujet ne peut être défini. Représenté par des méthodes abstraites.
Les classes abstraites ont une fonction abstraite de plus que les classes ordinaires. Autrement dit, les méthodes abstraites peuvent être définies dans des classes.
Les classes abstraites ne peuvent pas avoir de méthodes d'instance.
Spécial : les méthodes abstraites n'ont pas besoin d'être définies dans une classe abstraite. Cela empêche uniquement la classe de créer des objets.
4. Modèle de conception de modèle :
Lors de la définition d'une fonction, une partie de la fonction est déterminée, mais une partie de celle-ci est incertaine, et la partie déterminée utilise la partie incertaine, alors la partie incertaine sera utilisée Partiellement exposée. Ceci est fait par les sous-classes de cette classe.
5. Interface :
La compréhension initiale peut être considérée comme une classe abstraite spéciale. Lorsque les méthodes d’une classe abstraite sont abstraites, alors la classe peut être représentée sous la forme d’une interface.
　class : utilisé pour définir les classes
　interface : utilisé pour définir les interfaces. Une interface est aussi un type. Des fichiers de classe peuvent être générés.

Lors de la définition d'une interface, le format présente :
1. Définitions communes dans les interfaces : constantes, méthodes abstraites. L'émergence des interfaces incarne « l'héritage multiple » sous une autre forme, c'est-à-dire « implémentations multiples ».
　2. Les membres de l'interface ont des modificateurs fixes.
Constante : public static final
Méthode : public abstract
Rappelez-vous : tous les membres de l'interface sont publics.
Interface : Il n'est pas possible de créer des objets car il existe des méthodes abstraites. Il doit être implémenté par une sous-classe. Ce n'est qu'après que la sous-classe a réécrit toutes les méthodes abstraites de l'interface que la sous-classe peut être instanciée. Sinon, la sous-classe est une classe abstraite.
　par exemple : interface Inter
　{
　　//Ce n'est pas grave si les modificateurs public static final et public abstract sont manquants, car les membres de l'interface ont des modificateurs fixes. Mais il est préférable d’écrire pendant le développement pour améliorer la lisibilité.
public static final int SET_ON = 1;
public abstract void show();
}
//Utiliser les implémentations d'interface
class Test implémente Inter (){} //Vous devez remplacer la méthode abstraite montre pour créer un objet
　}
class InterfaceDemo
　{
public static void main(String[] args)
　　{
　　Test t = new Test();
System.out.println(t.SET_ON);

Règles d'exposition externe.

L'interface est l'extension fonctionnelle du programme.

Les interfaces peuvent être utilisées pour plusieurs implémentations.

Il existe une relation d'implémentation entre les classes et les interfaces, et une classe peut hériter d'une classe et implémenter plusieurs interfaces en même temps.

Il peut y avoir une relation d'héritage entre les interfaces.

6. Polymorphisme :

Définition : Formes d'existence multiples d'un certain type de chose.
par exemple : chats et chiens parmi les animaux
Le type correspondant de l'objet chat est le type chat
Chat x = new cat(); En même temps, le chat est aussi une sorte d'animal , et on peut aussi l'appeler chat pour animaux.
Animal y = new cat();
Animal est le type parent extrait des éléments spécifiques des chats et des chiens.
La référence du type parent pointe vers l'objet sous-type.
6.1. Réflexion du polymorphisme :
La référence de la classe parent pointe vers son propre objet sous-classe.
La référence de la classe parent peut également recevoir son propre objet sous-classe.
par exemple : Classe parent Nom de référence de la classe parent = new subclass();//Type de promotion. Transformation vers le haut. Pour utiliser les fonctions uniques de la sous-classe, vous devez downcast : sous-classe nouveau nom de référence de sous-classe = (sous-classe) nom de référence de la classe parent d'origine
Mots clés : instanceof déterminer le type de référence
par exemple : if (une instance de Cat) // Déterminez si a est un type de chat.
6.2. Prérequis au polymorphisme :
Il doit y avoir une relation entre les classes. Soit hériter, soit implémenter.
Il y a généralement une condition préalable : les sous-classes doivent remplacer (réécrire).

6.3. Avantages du polymorphisme :
L'émergence du polymorphisme a grandement amélioré l'évolutivité des programmes.
6.4. Inconvénients du polymorphisme :
Améliore l'évolutivité, mais vous ne pouvez utiliser que les références de la classe parent pour accéder aux membres de la classe parent.

6.5 Caractéristiques des fonctions membres non statiques en polymorphisme :
Au moment de la compilation : Voir s'il existe une méthode appelante dans la classe à laquelle appartient la variable de référence. Si tel est le cas, la compilation réussit ; sinon, la compilation échoue.
Au moment de l'exécution : vérifiez s'il existe une méthode à appeler dans la classe à laquelle appartient l'objet.
Un résumé simple est le suivant : lorsqu'une fonction membre est appelée de manière polymorphe, regardez à gauche lors de la compilation et à droite lors de l'exécution.
6.6 Caractéristiques des variables membres en polymorphisme :
Peu importe lors de la compilation ou de l'exécution, référez-vous au côté gauche (la classe à laquelle appartient la variable de référence.)
Caractéristiques des fonctions membres statiques en polymorphisme :
Peu importe Pour la compilation et l'exécution, reportez-vous au côté gauche (static lui-même peut être appelé directement).

7.object : C'est la classe parente directe ou indirecte de tous les objets, le Dieu légendaire.
Ce qui est défini dans cette classe doit être les fonctions que possèdent tous les objets.
Règles d'accès aux classes internes :
1. Les classes internes peuvent accéder directement aux membres des classes externes, y compris les classes privées.
2. Pour accéder à une classe interne, une classe externe doit créer un objet de classe interne.

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!