table des matières
Trois caractéristiques de l'orientation objet (encapsulation, héritage, polymorphisme)
La signification du mot-clé this
Caractéristiques après variables de membre d'héritage
Caractéristiques après la méthode du membre d'héritage
L'espace de classe parent est généré par des objets de sous-classe
Troisièmement, le polymorphisme
Conditions d'existence du polymorphisme:
Pour le langage Java , tout est un objet. Les objets du monde réel sont incarnés de manière abstraite dans le monde de la programmation Un objet représente une opération spécifique. Chaque objet constitue enfin une conception de programme complète, ces objets peuvent exister indépendamment ou hérités d'autres objets. Grâce à l'interaction entre les objets, les informations sont transmises pour réaliser le développement du programme.
Qu'est-ce qu'une classe?
Une classe est une abstraction d'objets utilisée pour décrire les caractéristiques et les comportements communs d'un groupe d'objets. Les variables membres et les méthodes membres peuvent être définies dans une classe. Les variables membres sont utilisées pour décrire les caractéristiques de l'objet et sont également appelées attributs. Les méthodes membres sont utilisées pour décrire le comportement de l'objet et sont appelées méthodes en abrégé.
public class Student {
//成员变量
private String name;//姓名
private int age;//年龄
//成员方法
//学习的方法
public void study(){
System.out.println("好好学习，天天向上");
}
//吃饭的方法
public void eat(){
System.out.println("干饭人干饭时间");
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//封装私有变量
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 Student(String name, int age) {
this.name = name;
this.age = age;
}
//无参构造函数
public Student() {
}
Qu'est-ce qu'un objet?
public static void main(String[] args) {
//创建对象
Student stu1=new Student("张三",9);
Student stu2=new Student("李四",9);
//使用对象访问类中的成员
stu1.setAge(18);
stu1.eat();
stu2.setName("赵四");
stu2.study();
}Trois caractéristiques de l'orientation objet (encapsulation, héritage, polymorphisme)
Un paquet
Encapsulation: Encapsulation est un principe important de l'approche orientée objet Il a deux significations: la. Première est de combiner tous les attributs de l'objet et tous les services pour former une unité indépendante indivisible (c.l'objet); deuxième Cette le sens est aussi appelé dissimulation d'informations, c'est-à-dire dissimuler autant que possible les détails internes de l'objet, former une frontière vers l'extérieur et ne conserver qu'une interface externe limitée pour entrer en contact avec l'extérieur.
1. Utilisez le mot-clé private pour modifier les variables membres
2. Fournissez une paire de méthodes getXxx et de méthodes SetXxx pour les variables membres auxquelles il faut accéder.
public class Student {
//私有成员变量
private String name;//姓名
private int age;//年龄
//提供供外界访问的公有方法
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;
}
}Modificateur d'accès
La signification du mot-clé this
- Cela représente la référence (valeur d'adresse) de l'objet actuel de la classe, c'est-à-dire la référence de l'objet lui-même.
- La méthode est appelée par quel objet, ceci dans la méthode représente quel objet. Autrement dit, qui appelle, cela représente qui.
Les variables encapsulent la valeur actuelle, les méthodes encapsulent le code et le comportement, et les classes encapsulent les deux pour fournir un ensemble d'états et de fonctions en même temps. L'interface encapsule les méthodes.
Deuxièmement, l'héritage
Héritage: l' héritage est une technique qui permet aux utilisateurs de créer de nouvelles classes sur la base d'une classe. La nouvelle classe hérite automatiquement des attributs et des caractéristiques de comportement de l'ancienne classe et peut avoir certaines caractéristiques supplémentaires ou certaines restrictions.
Héritage : la sous - classe hérite des propriétés et des comportements de la classe parente, de sorte que la sous-classe ait les mêmes propriétés et comportements que la classe parente. Les sous-classes peuvent accéder directement aux propriétés et aux comportements non privés de la classe parent.
Améliorez la réutilisabilité du code. La relation entre classe et classe est la prémisse du polymorphisme .
class 父类{
···
}
class 子类 extends 父类{
···
}Caractéristiques après variables de membre d'héritage
Si des variables membres avec des noms différents apparaissent dans la classe parente de la sous-classe, l'accès au code n'a aucun effet.
Si une variable membre avec le même nom apparaît dans la classe parente de la sous-classe, vous devez accéder aux variables membres non privées de la classe parente dans la sous-classe, et vous devez utiliser le mot-clé super pour modifier les variables membres de la classe parente .
class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
//访问父类中的num
System.out.println("Fu num=" + super.num);
//访问子类中的num
System.out.println("Zi num=" + this.num);
}
}Caractéristiques après la méthode du membre d'héritage
Si une méthode membre avec un nom différent apparaît dans la classe parente de la sous-classe, l'accès au code n'a aucun effet.
Si une méthode membre du même nom apparaît dans la sous-classe et la classe parente, alors il y a un remplacement de méthode (Override)
Réécriture de méthode: la méthode qui apparaît dans la sous-classe est exactement la même que la classe parent (le type de valeur de retour, le nom de la méthode et la liste de paramètres sont les mêmes), et l'effet de couverture apparaîtra. La déclaration reste inchangée et réimplémentée.
//父类
class Fu {
public void show() {
System.out.println("Fu show");
}
}
//子类
class Zi extends Fu {
//子类重写了父类的show方法
public void show() {
System.out.println("Zi show");
}
}
//测试类ExtendsDemo
public class ExtendsDemo{
public static void main(String[] args) {
Zi z = new Zi();
// 子类中有show方法，只执行重写后的show方法
z.show(); // Zi show
}
}Le sens de super et ça
- super: représente l'identifiant de l'espace de stockage de la classe parent, qui ne peut apparaître que dans la méthode (comprendre la référence de la classe parent)
- this: représente la référence de l'objet courant (qui l'appelle au nom de qui).
L'espace de classe parent est généré par des objets de sous-classe
Chaque fois que vous créez un objet de sous-classe, initialisez d'abord l'espace de classe parent, puis créez l'objet de sous-classe lui-même. L'objectif est que l'objet de la sous-classe contienne son espace de classe parent correspondant, de sorte qu'il puisse inclure les membres de sa classe parente. Si les membres de la classe parente ne sont pas modifiés en privé, la sous-classe peut utiliser les membres de la classe parente à volonté. Le code est reflété dans l'appel de méthode de construction de la sous-classe, la méthode de construction de la classe parent doit être appelée en premier.
Troisièmement, le polymorphisme
Polymorphisme: l' objet doit répondre à la réception d'un message. Différents objets peuvent produire des résultats complètement différents lorsqu'ils reçoivent le même message. Ce phénomène est appelé polymorphisme.
Conditions d'existence du polymorphisme:
- 1. Il existe une relation d'héritage
- 2. La méthode doit être réécrite
- 3. La référence de la classe parent pointe vers la classe enfant
//子类的引用 指向——> 子类
父类类型 变量名 = new 子类对象;
变量名.方法名();Type parent: fait référence à l'objet de sous-classe hérite du type parent ou implémente le type d'interface parent. Le polymorphisme est le polymorphisme des méthodes et il n'y a pas de polymorphisme dans les attributs.
//抽象的父类
public abstract class Animal {
public abstract void eat();
}
//子类Cat
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
}
//子类Dog
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}
//测试类Test
public class Test {
public static void main(String[] args) {
// 多态形式，创建对象
Animal a1 = new Cat();
// 调用的是 Cat 的 eat
a1.eat();
// 多态形式，创建对象
Animal a2 = new Dog();
// 调用的是 Dog 的 eat
a2.eat();
}
}Dans le code polymorphe, les règles d'accès pour les méthodes membres sont les suivantes: voir qui est nouveau, utiliser celui qui est le premier et rechercher s'il n'y en a pas.