Classe abstraite et classe interne
Une classe abstraite
(1) Méthode abstraite
- Décoré par résumé.
- Seule la définition de la méthode, il n'y a pas d'implémentation spécifique (corps de méthode spécifique), c'est-à-dire que même les accolades {} ne se terminent pas directement par un point-virgule.
/**
* 定一个抽象类，动物类的抽象属性与行为
* @author Administrator
*
*/
public abstract class Animal {
//定义两个方法，描述动物吃的食物和叫声的区别
abstract void eat();
abstract void cry();
}
(Deux) classe abstraite
- Décoré par résumé.
- La classe contenant la méthode abstraite doit être une classe abstraite.
- Ne peut pas être instancié.
- Les classes abstraites doivent être héritées.
4.1 La méthode pour la réécrire --------------- devient incomplète pour terminer
4.2 La définition de la classe abstraite dans la classe abstraite --------- n'est pas couramment utilisée.
-
/** * 定一个抽象类，动物类的抽象属性与行为 * @author Administrator * */ public abstract class Animal { //定义两个方法，描述动物吃的食物和叫声的区别 abstract void cry(); abstract String eat(); } -
/** * 动物狗的食物与叫声 */ public class Dog extends Animal { @Override public void cry() { System.out.println("汪汪"); } @Override public String eat() { return "狗吃骨头"; } } -
/** * 动物猫的食物与叫声 */ public class Dog extends Animal { @Override public void cry() { System.out.println("喵喵~"); } @Override public String eat() { return "猫吃鱼"; } } -
/** * 动物模拟器 */ public void play(Animal animal) { System.out.print(animal.eat()); animal.cry(); } } -
/** * 动物模拟器 */ public class Mains { public static void main(String[] args) { Moni moni = new Moni(); moni.play(new Dog()); moni.play(new Cat()); } } - résultat:
(3) La signification des classes abstraites
-
1. Scellez les attributs communs et les méthodes de comportement, ajoutez des modificateurs abstraits à une classe, privatisez les attributs et rendez le comportement public. ----------- Réutilisation du code
-
2. Fournissez un type unifié pour toutes les classes dérivées (sous-classes) ---------- modélisation ascendante.
public class Mains { public static void main(String[] args) { Moni moni = new Moni(); Animal a = new Dog(2);//向上造型 moni.play(new Dog(7)); moni.play(new Cat(6)); a.cry(); a.getAge(); } } //结果显示： 狗吃骨头汪汪~,今年7岁 猫吃小鱼喵喵~，今年6岁 汪汪~,今年2岁 -
3. Peut contenir des méthodes abstraites pour fournir une entrée unifiée pour toutes les classes dérivées. Le comportement des classes dérivées est différent, mais l'entrée est la même
-
-
L'attribut animal (c'est-à-dire l'âge) dans la figure ci-dessus est privatisé, et l'âge est transmis à l'animal.
Deux, classe interne
(1) Classe interne des membres
- Le taux d'application est faible, comprenez-le.
- La classe externe est appelée classe externe externe et la classe interne interne est appelée classe interne interne.
- La classe interne ne sert généralement que la classe externe et n'a pas de visibilité externe.
- Les objets de classe interne sont généralement créés dans des classes externes.
- Les membres de la classe interne qui peuvent accéder directement à la classe externe (y compris les classes privées)
ont une référence implicite à l'objet de classe externe qui l'a créée.
par exemple:Nom de classe externe. - Les méthodes statiques et les variables statiques ne peuvent pas être déclarées dans le corps d'une classe interne.
//成员内部类的演示
public class InnerClassDemo {
public static void main(String[] args) {
A w1 = new A();
//a w2 = new a(); //内部类对外不具备可见性
}
}
class A{
//外部类
int i = 0;
private String name;
a w3 = new a();
class a{
//内部类
int j = 0;
void showname() {
System.out.println(name);
System.out.println(A.this.name);
System.out.println(this.j); //this指的是a对象
}
}
}
(2) Classe interne anonyme
- 1) Si vous souhaitez créer un objet d'une classe (classe dérivée) et que l'objet n'est créé qu'une seule fois, la
classe n'a pas besoin d'être nommée et elle est appelée classe interne anonyme. - 2) Si vous souhaitez accéder à une variable externe dans une classe interne anonyme,
la variable doit être finale (obligatoire avant JDK1.8, 1.8 n'est pas obligatoire)
//匿名内部类的演示
public class NstInnerClassDemo {
public static void main(String[] args) {
//1)创建了Aoo的一个派生类，但是没有名字
//2)创建了该派生类的一个对象，名为o1
//3)大括号中的为派生类的类体
Aoo o1 = new Aoo() {
};
//1)创建了Aoo的一个派生类，但是没有名字
//2)创建了该派生类的一个对象，名为o2
//3)大括号中的为派生类的类体
Aoo o2 = new Aoo() {
};
int num = 5;
//1)创建了Boo的一个派生类，但是没有名字
//2)创建了该派生类的一个对象，名为o3
//3)大括号中的为派生类的类体
Boo o3 = new Boo() {
void show() {
System.out.println("showshow");
System.out.println(num); //JDK1.8之前，要求num必须是final的
}
};
o3.show();
}
}
abstract class Boo{
abstract void show();
}
abstract class Aoo{
}
Conseils: tant qu'une classe est une classe abstraite ou une interface, les méthodes de la sous-classe peuvent être implémentées à l'aide de classes internes anonymes (par exemple, pour implémenter le multithreading, vous devez hériter de la classe Thread ou hériter de l'interface Runnable)
Soyez patient pour le contenu de suivi et venez bientôt! Ecrire n'est pas facile, merci de donner un coup de pouce 3Q
S'il y a des erreurs, merci de commenter
Le catalogue de tous les chapitres est ici: https://blog.csdn.net/qq_41254299/article/details/106638651
Veuillez indiquer la source de la réimpression: https://blog.csdn.net/qq_41254299
Cet article provient du [blog de Superclover_]