Java --- Chapitre six
Un paquet (Encapsulation)
Présentation du paquet
Qu’est-ce que l’encapsulation ?
L'encapsulation consiste à masquer certaines propriétés et méthodes d'une classe et ne permet pas l'accès direct par des programmes externes. Les propriétés et méthodes définies dans la classe ne sont accessibles que via les méthodes fournies publiquement par la classe. L'encapsulation est l'une des trois principales caractéristiques de l'orientation objet .
Comment utiliser l'encapsulation ?
Exemple :
créer une classe Personne
public class Person {
public String name;//姓名
public int age;//年龄
public String secret;//秘密
public Person(String name,int age,String secret){
this.name=name;
this.age=age;
this.secret=secret;
}
}
Modifier la visibilité des attributs : modifier tous les attributs définis dans la classe en modification privée
public class Person {
private String name;//姓名
private int age;//年龄
private String secret;//秘密
public Person(String name,int age,String secret){
this.name=name;
this.age=age;
this.secret=secret;
}
}
Si vous modifiez directement la valeur de l'âge, une erreur sera signalée.
public class PersonTest {
public static void main(String[] args){
Person p1 = new Person("刘德华",54,"双重人格");
p1.age=30;//报错
}
}
Créer des méthodes getter/setter publiques : pour lire/modifier les valeurs des propriétés
public class Person {
private String name;//姓名
private int age;//年龄
private String secret;//秘密
public Person(String name,int age,String secret) {
this.name=name;
this.age=age;
this.secret=secret;
}
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 String getSecret() {
return secret;
}
public void setSecret(String secret) {
this.secret = secret;
}
}
public class PersonTest {
public static void main(String[] args){
Person p1 = new Person("刘德华",54,"双重人格");
p1.setName("伍六七");
String name = p1.getName();
}
}
Ajouter une instruction de contrôle à la méthode getter/setter : utilisée pour vérifier la validité de la valeur de l'attribut
Dans la classe, ajouter une instruction de vérification à l'attribut correspondant
public int getAge() {
return age;
}
public void setAge(int age) {
if (age < 0) {
System.out.println("年龄不合法,必须大于0");
} else {
this.age = age;
}
}
dans la méthode
public class PersonTest {
public static void main(String[] args){
Person p1 = new Person("刘德华",54,"双重人格");
p1.setAge(-1);
//输出
//年龄不合法,必须大于0
}
}
Pourquoi utiliser l'encapsulation ?
- L'encapsulation augmente la réutilisabilité du code.
Étant donné que l’encapsulation fournit des méthodes publiques pour un accès externe et que les méthodes peuvent être réutilisées, l’encapsulation améliore la réutilisabilité du code. - L'encapsulation améliore la maintenabilité du code.
Lors de la modification du code, seule une partie du code doit être modifiée, mais les autres codes ne seront pas affectés.
Par exemple : l'âge n'est pris en compte que dans le cas de nombres négatifs dans la conception, mais pas dans la vie réelle. L'âge d'une personne n'a généralement pas plus de 200 ans, il est donc nécessaire d'ajouter une couche de vérification.
public void setAge(int age) {
if (age < 0 || age > 200) {
System.out.println("年龄不合法,必须大于0并且小于200");
} else {
this.age = age;
}
}
- L'encapsulation masque les détails d'implémentation spécifiques de la classe et protège la logique d'implémentation du code.
Deux packs (Package)
Présentation du paquet
Qu'est-ce qu'un forfait ?
Un package est un vocabulaire professionnel en Java, et l'essence d'un package est un dossier.
Pourquoi utiliser des packages ?
- Les packages peuvent classer les classes que nous écrivons.
- Peut éviter les conflits de noms
- contrôle d'accès
Comment créer un package ?
grammaire:
package 包名;
Parmi eux, com, ly, chat11 sont respectivement un dossier
La convention de dénomination du nom du package :
- Les noms de packages sont généralement composés de lettres minuscules et de chiffres, et chaque package est séparé par '.'. En d'autres termes, chaque occurrence de '.' est un package.
- Les noms de packages contiennent généralement des préfixes.
- La personne/organisation est généralement org.name
- L'entreprise est généralement l'abréviation du nom de l'entreprise com. ou l'abréviation du nom de l'entreprise cn.
- S'il existe une définition de package dans une classe, alors la première ligne de code valide dans cette classe doit être la définition de package
Comment importer des packages ?
Afin d'utiliser des classes qui ne sont pas dans le même package, vous devez utiliser le mot clé import pour introduire cette syntaxe de classe dans votre programme Java
:
import 包名.类名;
package com.ly.chat11;
//类的全限定名：包名+'.'+类名
import java.util.Scanner;//告诉JVM,到Java.util包下去找一个名为Scanner的类
public class User {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
}
}
Pourquoi importer des packages ?
Étant donné que la JVM ne peut reconnaître que toutes les classes du package actuel, si vous souhaitez utiliser des classes dans d'autres packages que le package actuel, vous devez indiquer à la JVM quelle classe dans quel package utiliser.
Une classe fait référence à deux classes portant le même nom provenant de packages différents en même temps, qui doivent être distinguées par le nom complet de la classe (nom complet de la classe)
Description des packages couramment utilisés :
Java.lang 包
Il appartient au package de développement du langage Java, et les classes de ce package peuvent être utilisées directement sans importer le package. Parce que la JVM introduira automatiquement
les éléments suivants : le système, la chaîne, les mathématiques que nous utilisons souvent
Java.util 包
Il appartient à certaines classes d'utilisation et classes d'outils fournies par Java.
Par exemple : le scanner que nous utilisons souvent
Modificateur d'accès triple
Introduction aux modificateurs d'accès
concept:
Les modificateurs d'accès sont des symboles modificateurs qui contrôlent les autorisations d'accès
Modificateurs d'accès aux classes :
il existe uniquement deux types de modificateurs d'accès pour les classes :
- modificateur public
- Modificateur par défaut (aucun modificateur n'est par défaut)
Le modificateur public modifie une classe pour indiquer que la classe est accessible publiquement.
Le modificateur par défaut modifie la classe, indiquant que la classe n'est accessible que dans le même package
Modificateur d’accès aux membres de classe :
les membres de classe incluent des propriétés de membre et des méthodes de membre.
Les modificateurs d’accès aux membres de classe sont, en d’autres termes, des modificateurs d’accès aux propriétés et méthodes membres.
Quatre mémoire statique
Le champ d'application du modificateur statique :
le modificateur statique ne peut être utilisé que pour modifier les variables membres, les méthodes membres, les blocs de code et les classes internes définies dans la classe (il existe des chapitres spéciaux à expliquer pour les classes internes)
Variables membres modifiées statiques :
les variables membres modifiées statiques sont appeléesvariable de classe. Partagé par tous les membres de la classe
Si la valeur initiale du pays est : "Chine", après modification c'est "Japon", alors la valeur de l'appel est "Japon" qui
n'est pas une variable membre et ne changera pas avec les membres
Si la variable de classe est publique, vous pouvez utilisernom de classe.nom de variableaccès direct à la variable
Bloc de code modifié statique :
Le bloc de code statique modifié est appelé bloc de code statique, qui est exécuté lorsque la JVM enregistre la classe pour la première fois.
Par conséquent, les blocs de code statiques ne peuvent être exécutés qu’une seule fois et sont généralement utilisés dans certains scénarios de configuration du système.
static {
}
Cinq héritages (Héritage)
Introduction à l'héritage
Concept :
Le concept d'héritage est simple mais puissant, lorsque vous souhaitez créer une nouvelle classe et qu'il existe déjà une classe contenant le code requis, vous pouvez dériver la nouvelle classe de la classe existante. De cette façon, vous pouvez réutiliser les champs et les méthodes des classes existantes sans avoir à les écrire (déboguer) vous-même.
Une sous-classe hérite de tous les membres (champs, méthodes et classes imbriquées) de sa classe parent,Les constructeurs ne sont pas membres, ils ne sont donc pas hérités par les sous-classes, mais le constructeur de la superclasse peut être appelé depuis la sous-classe.
Une classe dérivée d'une classe est appelée une sous-classe (elle peut également être une classe dérivée, une classe étendue ou une sous-classe ), et une classe dérivée d'une sous-classe est appelée une superclasse (également appelée classe de base ou classe parent ).
L'héritage est également l'une des trois caractéristiques majeures de l'orientation objet.
Comment utiliser l'héritage ?
grammaire:
publis class 子类名 extends 父类名{
}
Exemple:
public class Person{
public String name;
public String sex;
public int age;
public void eat(){
System.out.println("吃饭");
}
}
public class PersonTest extends Person{
public void show(){
System.out.println(name);
//本类中未定义name变量，但却可以使用，说明name变量是从父类中继承过来的
}
}
Propriétés et méthodes héritées :
Quel que soit le package dans lequel se trouve la sous-classe, la sous-classe hérite de tous les membres publics et protégés (y compris les champs et les méthodes) de la classe parent. Si la sous-classe et la classe parent se trouvent dans le même package, la sous-classe héritera également des membres protégés par le package de la classe parent.
Les sous-classes n'héritent pas des membres privés définis dans la classe parent. Cependant, si la classe parent possède des méthodes qui fournissent un accès public ou protégé au champ, ces méthodes peuvent également être utilisées dans la sous-classe.
Code répétitif :
public class Person{
public String name;
public String sex;
public int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println("吃饭");
}
}
Cours spécifiques aux médecins :
public class Doctor extends Person{
private String professional;
public String getProfessional() {
return professional;
}
public void setProfessional(String professional) {
this.professional = professional;
}
public void cure(){
System.out.println("治病");
}
}
Tester, créer un objet :
public class PersonTest{
public static void main(String[] args) {
Doctor d =new Doctor();
d.setName("Miss");
d.setSex("女");
d.setAge(19);
d.setProfessional("临床");
//优化之后
Person p1 = new Doctor();
p1.setName("Miss");
p1.setSex("女");
p1.setAge(19);
p1.setProfessional("临床");//报错，因为该类不在Person里
//但是我们可以使用强制类型转换
((Doctor)p1).setProfessional("临床");
}
}
La relation entre la sous-classe et la classe parent est une relation est-a, ce qui signifie que si
un objet est affecté à sa référence de classe parent, à ce moment-là, si vous souhaitez appeler la méthode unique de l'objet, vous devez la convertir.
Réécriture de six méthodes (Override)
Introduction à la substitution de méthode
Une méthode membre de la sous-classe a la même signature que la méthode membre de la classe parent (le nom de la méthode plus le nombre et le type de paramètres) et la méthode d'instance du type de valeur de retour remplace la méthode de la classe parent.
Comment utiliser le remplacement de méthode :
La possibilité pour une sous-classe de remplacer une méthode permet à une classe d'hériter d'une classe parent qui se comporte "assez près", puis de modifier le comportement si nécessaire, la méthode de substitution a le même nom, le même numéro et les mêmes types de paramètres que la méthode substituée, et a le même type de retour , la méthode de remplacement peut également renvoyer un sous-type du type renvoyé par la méthode de remplacement, ce sous-type est appelé type de retour covariant.
Exemple:
public Number getScore(){
return 0;
}
Lorsque la sous-classe remplace la méthode de la classe parent, le type de valeur de retour peut être une sous-classe du type de valeur de retour de la méthode de la classe parent.
Le niveau du modificateur d'accès ne peut pas être abaissé lors du remplacement d'une méthode
public Integer getScore(){
return 90;
}
Lors du remplacement de méthodes, vous devrez peut-être utiliser@passer outreà annoter, ce qui indique au compilateur que vous avez l'intention de remplacer la méthode dans la classe parent. Si, pour une raison quelconque, le compilateur détecte que la méthode n'existe pas dans la classe parent, il générera une erreur.
Les nombres que nous avons appris auparavant incluent byte short int long float double type
, puis leur correspondantSous-classes de nombre :Octet Court Entier Long Flottant Double
Sept super mots-clés
concept:
Si le constructeur de la sous-classe n'appelle pas explicitement le constructeur de la classe parent, le compilateur Java insérera automatiquement un appel à la construction sans argument de la classe parent. Si la superclasse n'a pas de constructeur sans argument, vous obtiendrez une erreur de compilation.
La classe d'objet a un constructeur sans argument, donc si la classe d'objet est la seule classe parent, cela ne pose aucun problème.
Exemple 1 : Ni la sous-classe ni la classe parent ne définissent de constructeur
. Classe parent :
public class Person{
public String name;
public Person(){
super();
}
public Number getScore(){
return 0;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Sous-classe :
public class Doctor extends Person{
private String professional;
//如果一个类中没有定义构造方法，那么编译器将会给该类插入一个无参构造方法
public Doctor(){
super();//如果子类构造方法中没有明显调用父类的构造方法，那么编译器会
//自动插入一个父类的无参构造的调用
}
public String getProfessional() {
return professional;
}
public void setProfessional(String professional) {
this.professional = professional;
}
public void cure(){
System.out.println("治病");
}
}
Exemple 2 : La sous-classe a un constructeur défini, mais la classe parent ne définit pas de constructeur
Classe parent :
public class Person{
public String name;
// public Person(){
// super();
// }
public Number getScore(){
return 0;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Sous-classe :
public class Doctor extends Person{
private String professional;
public Doctor(){
super();
}
public Doctor(String name){
super();
this.name = name;
}
public String getProfessional() {
return professional;
}
public void setProfessional(String professional) {
this.professional = professional;
}
public void cure(){
System.out.println("治病");
}
}
Exemple 3 : Il existe des constructeurs définis à la fois dans la sous-classe et dans la classe parent Classe parent
:
public class Person{
public String name;
public Person(String name,String sex){
this.name = name;
this.sex = sex;
}
public Number getScore(){
return 0;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Sous-classe :
public class Doctor extends Person{
private String professional;
public Doctor(String name,String sex){
super(name,sex);
//如果父类中定义了带参构造，并且没有定义无参构造，
//那么必须在子类的带参构造方法中显示的调用父类的带参构造
}
public String getProfessional() {
return professional;
}
public void setProfessional(String professional) {
this.professional = professional;
}
public void cure(){
System.out.println("治病");
}
}
Lorsque vous utilisez super pour appeler le constructeur de la classe parent, ce doit être la première instruction du constructeur
public class Doctor extends Person{
private String professional;
public Doctor(String name,String sex){
//报错，不是第一条语句
System.out.println("abc);
super(name,sex);
}
}
Si votre méthode remplace l'une des méthodes de la classe parent, vous pouvez appeler la méthode remplacée dans la classe parent en utilisant le mot-clé super .
Vous pouvez également utiliser super pour faire référence à des champs masqués (bien que les champs masqués ne soient pas recommandés )
Champ masqué :
classe parent :
public class Person{
protected String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Sous-classe :
public class Doctor extends Person{
private String name;
public Doctor(String name){
this.name = name;
}
}
public class PersonTest{
public static void main(String[] args) {
Doctor d = new Doctor("Mis");
System.out.println(d.getName());
//null
}
}
Si vous souhaitez obtenir le nom correspondant, vous pouvez remplacer la méthode
Sous-classe :
public class Doctor extends Person{
private String name;
public Doctor(String name){
this.name = name;
}
@Override
public String getName() {
return name;
}
}
Que se passe-t-il si vous souhaitez obtenir à la fois les variables de la classe parent et les variables de la sous-classe ?
Sous-classe :
public class Doctor extends Person{
private String name;
public Doctor(String name){
this.name = name;
}
public void show(){
System.out.println(this.name);//访问本类中定义的name变量
System.out.println(super.name);//访问父类中定义的变量
}
}
Si la sous-classe et la classe parent n'ont pas la même variable membre, vous pouvez utiliser this et super pour appeler la variable membre de la classe parent à ce moment-là
.
public class PersonTest{
public static void main(String[] args) {
Doctor d = new Doctor("Mis");
System.out.println(d.getName());
d.show();
}
}
tout est un objet
À l'exception d'Object, qui n'a pas de parent, chaque classe a un et un seul parent direct (héritage unique). En l’absence de toute autre superclasse explicite, chaque classe est implicitement une sous-classe d’Object.
Une classe peut être dérivée d'une autre classe, qui peut être dérivée d'une autre classe, et ainsi de suite, et enfin dérivée de la classe la plus élevée Object. Une telle classe est dite descendante de toutes les classes de la chaîne d’héritage, s’étendant jusqu’à Object.
Toutes les classes sont des sous-classes d'Object. Par conséquent, lors de la création d'un objet, vous devez appeler le constructeur sans argument dans la classe Object, et Object lui-même représente un objet, donc tous les objets sont créés
modificateur final
Champ d'application :
le modificateur final doit être utilisé sur les classes, les variables et les méthodes.
Classe de modification finale :
Vous pouvez déclarer certaines ou toutes les méthodes d'une classe comme finales. L'utilisation du mot-clé final dans une déclaration de méthode indique que la méthode ne peut pas être remplacée par des sous-classes.
C'est exactement ce que fait la classe d'objets : bon nombre de ses méthodes sont définitives.
Si une classe est modifiée par final, cela signifie que la classe est finale, donc cette classe ne peut pas être héritée, car l'héritage consiste à étendre la classe
public final class Person{
public void show(){
System.out.println("这里是最终类里的方法");
}
}
La sous-classe signale directement une erreur
public class Doctor extends Person{
}
méthode de modification finale
Note:Vous pouvez également déclarer la classe entière comme finale, et une classe déclarée finale ne peut pas être sous-classée (héritée). Par exemple : ceci est particulièrement utile
lors de la création de classes immuables telles que la classe String
public class Person{
public final void show(){
System.out.println("这是一个最终方法，不能被重写");
}
}
Signaler directement une erreur
public class Doctor extends Person{
public void show(){
}
}
variable de modificateur final
Lorsque final modifie une variable, la variable doit être initialisée lors de la construction de l'objet.
Les variables modifiées par final sont appelées constantes
public class Doctor extends Person{
private final int number;
public Doctor(){
this.number = 10;
}
}