1. Héritage
Lorsqu'un ou plusieurs objets ont des caractéristiques communes, nous pouvons définir leurs caractéristiques communes comme une entité, et laisser ces multiples objets hériter des siennes, ce qui peut réduire la redondance du code. Par exemple, les chiens et les chats partagent le point commun de manger et de travailler, nous pouvons donc définir une classe animale, laisser la classe animale avoir les méthodes de manger et de travailler, puis laisser le chat et le chien hériter de la classe animale, de sorte qu'il y ait sont dans le chat et le chien Manières de manger et de travailler. Si la méthode d'alimentation chez les chats doit encore être améliorée, nous pouvons la réécrire. Si le chat peut encore nager, écrivez une autre méthode de nage.
public abstract class Animal {
abstract void eat();
}
class Dog extends Animal{
void eat(){
System.out.println("吃肉");
}
public void work(){
System.out.println("看家");
}
}
class Cat extends Animal{
void eat() {
System.out.println("吃鱼");
}
public void work(){
System.out.println("抓老鼠");
}
}
public class Test {
public static void main(String[] args) {
show(new Cat());
show(new Dog());
Animal a=new Cat();
a.eat();
Dog d=new Dog();
d.work();
}
public static void show(Animal a) {
a.eat();
if (a instanceof Cat) {//注意instanceof
Cat c = (Cat) a;
c.work();
} else if (a instanceof Dog) {
Dog c = (Dog) a;
c.work();
}
}
}
Résultat :
manger du poisson ,
attraper des souris ,
manger de la viande , faire le
ménage ,
manger du poisson , faire le
ménage
exemple de
Utilisation :
result = object instanceof class
Description :
Si object est une instance de class, l'opérateur instanceof renvoie true. Renvoie false si l'objet n'est pas une instance de la classe spécifiée ou si l'objet est nul.
Cependant, il existe une différence entre l'état compilé et l'état d'exécution de instanceof en Java :
dans l'état compilé, une classe peut être la classe parente, sa propre classe ou une sous-classe de l'objet objet. Dans ces trois cas, Java compile sans erreur.
Dans l'état d'exécution, la classe peut être la classe parente de l'objet objet, sa propre classe, mais pas une sous-classe. Le résultat de result est vrai dans les deux premiers cas et faux dans le dernier. Cependant, lorsque la classe est une sous-classe, la compilation ne signalera pas d'erreur. Le résultat de l'exécution est faux.
2. Interface
Une interface n'est pas une classe, la façon d'écrire une interface est très similaire à une classe, mais elles appartiennent à un concept différent. Une classe décrit les propriétés et les méthodes d'un objet. Une interface contient les méthodes à implémenter par la classe.
À moins que la classe implémentant l'interface ne soit une classe abstraite, la classe définit toutes les méthodes de l'interface.
Une interface ne peut pas être instanciée, mais elle peut être implémentée. Une classe qui implémente une interface doit implémenter toutes les méthodes décrites dans l'interface, sinon elle doit être déclarée comme une classe abstraite. De plus, en Java, les types d'interface peuvent être utilisés pour déclarer une variable, ils peuvent être un pointeur nul, ou être liés à un objet implémenté par cette interface.
public class MammalInt implements Animal{
public void eat(){
System.out.println("Mammal eats");
}
public void travel(){
System.out.println("Mammal travels");
}
public int noOfLegs(){
return 0;
}
public static void main(String args[]){
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}
3. Polymorphisme
Avantages du polymorphisme
- Éliminer la relation de couplage entre les types (la relation de couplage signifie que s'il existe une relation d'interaction et d'influence mutuelle entre deux choses, alors cette relation est appelée "relation de couplage".)
- remplaçabilité
- Évolutivité
- interface
- la flexibilité
- Simplicité#### Avantages du polymorphisme
Trois conditions nécessaires pour que le polymorphisme existe
- hériter
- récrire
- La référence de la classe parent pointe vers l'objet de la classe enfant
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
Résultat :
manger du poisson ,
attraper des souris ,
manger des os , faire le
ménage ,
manger du poisson ,
attraper des souris
Utilisation de super
1. Citation directe ordinaire
super peut faire référence aux propriétés de la classe parent (mais on ne peut pas dire que super pointe vers la classe parent de l'objet courant, ce qui n'est pas rigoureux).
2. La variable membre ou la méthode de la sous-classe a le même nom que la variable membre ou la méthode de la classe parent
class Animal {
public int a=10;
void print(){
System.out.println("I'm Animal");
}
}
class Dog extends Animal{
void print(){
super.print();
System.out.println("I'm Dog");
System.out.println(super.a);
}
}
public class Test {
public static void main(String[] args) {
Animal dog=new Dog();
dog.print();
}
}
结果:
Je suis un animal
, je suis un chien
10
3. Constructeur de référence
-
super (paramètre) : appelle un constructeur dans la classe parent (devrait être la première instruction du constructeur).
-
this (paramètre) : appelle une autre forme de constructeur dans cette classe (devrait être la première instruction du constructeur).
package com.company.animal;
class Animal {
public static void prt(String s) {
System.out.println(s);
}
Animal(){
prt("父类无参构造方法");
}
Animal(String name){
prt("父类有参构造方法"+name);
}
}
class Dog extends Animal{
Dog(){
super();
prt("子类无参构造方法");
}
Dog(String name){
super(name);
prt("子类有参构造方法"+name);
}
Dog(String name,int age){
this(name);
prt("子类相同形参的构造函数"+age);
}
}
public class Test {
public static void main(String[] args) {
Animal dog=new Dog();
dog=new Dog("晨光");
dog=new Dog("狗晨光",1);
}
}
Résultat : La
classe parent n'a pas de méthode de construction de paramètres La
classe enfant n'a pas de méthode de construction de paramètres La
classe parent a la méthode de construction de paramètres Chenguang La
classe enfant a la méthode de construction de paramètres Chenguang La
classe parent a la méthode de construction de paramètres Gou Chenguang
La classe enfant a la méthode de construction de paramètres Classe Gou Chenguang
avec les mêmes paramètres Constructeur 1
Comme vous pouvez le voir dans cet exemple, vous pouvez utiliser super et this pour appeler respectivement le constructeur de la superclasse et d'autres formes de constructeurs dans cette classe.
4. Comment l'utiliser
- référence directe ordinaire
- Les membres participants ont le même nom, utilisez-le pour distinguer
- constructeur de référence
Similitudes et différences entre super et ceci
- super (paramètre): appelle un constructeur dans la classe de base (devrait être la première instruction du constructeur)
- this (paramètre): appelle un autre constructeur formé dans cette classe (devrait être la première instruction du constructeur)
- super : il fait référence à un membre de la classe parent immédiate de l'objet actuel (utilisé pour accéder aux données ou fonctions membres de la classe parent qui sont masquées dans la classe parent immédiate, lorsque la classe de base et la classe dérivée ont les mêmes définitions de membres , tels que : super. nom de variable
super .member fonction nom de données (argument) - ceci : il représente le nom de l'objet actuel (lorsqu'une ambiguïté est susceptible de se produire dans le programme, il doit être utilisé pour indiquer l'objet actuel ; si la classe de participation formelle de la fonction a le même nom que les données membres, il
doit être utilisé pour indiquer le nom de la variable membre) - L'appel à super() doit être écrit dans la première ligne du constructeur de la sous-classe, sinon la compilation échouera. La première instruction de chaque constructeur de sous-classe appelle implicitement
super(). Si la classe parent n'a pas de constructeur sous cette forme, une erreur sera signalée lors de la compilation. - super() est similaire à this(), la différence est que super() appelle le constructeur de la superclasse à partir de la sous-classe, et this() appelle d'autres méthodes de la même classe.
- super() et this() doivent être placés sur la première ligne du constructeur.
- Bien que vous puissiez appeler un constructeur avec this, vous ne pouvez pas en appeler deux.
- This et super ne peuvent pas apparaître dans un constructeur en même temps, car this appellera inévitablement d'autres constructeurs, et d'autres constructeurs auront également des super instructions, donc si la même instruction est dans le même constructeur, elle sera perdue. instruction, le compilateur ne passera pas.
- this() et super() font tous deux référence à des objets, donc ni l'un ni l'autre ne peuvent être utilisés dans un environnement statique. Y compris : variables statiques,
méthodes statiques, blocs d'instructions statiques. - Il s'agit essentiellement d'un pointeur vers cet objet, alors que super est un mot-clé Java.