Répertoire d'articles
Classification interne
De manière générale, les classes internes comprennent généralement quatre types: les classes internes membres, les classes internes locales, les classes internes anonymes et les classes internes statiques.
Classe interne des membres
class Circle {
double radius = 0;
public Circle(double radius) {
this.radius = radius;
}
class Draw {
//内部类
public void drawSahpe() {
System.out.println("drawshape");
}
}
}
La classe interne membre peut localiser de manière inconditionnelle tous les attributs membres et méthodes membres de la classe externe, y compris les privatemembres et les membres statiques.
class Circle {
private double radius = 0;
public static int count =1;
public Circle(double radius) {
this.radius = radius;
}
class Draw {
//内部类
public void drawSahpe() {
System.out.println(radius); //外部类的private成员
System.out.println(count); //外部类的静态成员
}
}
}
Il est à noter que lorsque la variable membre ou la méthode de la classe interne et de la classe externe porte le même nom, le phénomène caché se produit, c'est-à-dire que les membres de la classe interne du membre sont accessibles par défaut. Si vous avez besoin d'accéder à un membre du même nom d'une classe externe, vous devez y accéder sous la forme suivante:
// 外部类.this.成员变量
// 外部类.this.成员方法
Si la classe externe souhaite accéder aux membres de la classe interne membre, elle doit d'abord créer un objet de la classe interne et y accéder via une référence à cet objet.
La classe interne membre dépend de la classe externe, c'est-à-dire que la prémisse de la création d'un objet de la classe interne est l'existence d'un objet de la classe externe.
public class Test {
public static void main(String[] args) {
//第一种方式：
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建
//第二种方式：
Outter.Inner inner1 = outter.getInnerInstance();
}
}
class Outter {
private Inner inner = null;
public Outter() {
}
public Inner getInnerInstance() {
if(inner == null)
inner = new Inner();
return inner;
}
class Inner {
public Inner() {
}
}
}
Si la classe interne de membre Inner est décorée avec private, il est uniquement accessible à l'intérieur de la classe externe. S'il est décoré avec public, il est accessible n'importe où; s'il est décoré avec protected, il ne peut être que dans le même package ou hérité de la classe externe. S'il s'agit de l'autorisation d'accès par défaut, elle n'est accessible que sous le même package.
Classe intérieure locale
Une classe définie dans une méthode ou une portée. La différence avec la classe interne membre est que l'accès de la classe interne locale est limité à la méthode ou à la portée.
Tout comme une variante locale, il ne peut y avoir aucun modificateur public, protégé, privé, statique.
class People{
public People() {
}
}
class Man{
public Man(){
}
public People getWoman(){
class Woman extends People{
//局部内部类
int age =0;
}
return new Woman();
}
}
Classe intérieure anonyme
Autrement dit, une classe interne sans nom. Cette définition de classe disparaît immédiatement et ne peut pas être réutilisée. Elle est généralement utilisée pour simplifier le code.
La condition préalable à l'utilisation de classes internes anonymes est: doit hériter d'une classe parente ou implémenter une interface, et au plus hériter d'une classe parente ou implémenter une interface.
Règles d'utilisation:
- Une classe interne anonyme ne peut pas être une classe abstraite, car lorsque le système crée une classe interne anonyme, il crée immédiatement un objet de la classe interne anonyme. Par conséquent, il n'est pas autorisé de définir des classes internes anonymes en tant que classes abstraites.
- Une classe interne anonyme ne peut pas définir de constructeur. Étant donné que la classe interne anonyme n'a pas de nom de classe, le constructeur ne peut pas être défini. Mais une classe interne anonyme peut définir un bloc d'initialisation, via le bloc d'initialisation d'instance, pour compléter ce dont le constructeur a besoin.
Code simplifié
abstract class Person {
public abstract void eat();
}
class Child extends Person {
public void eat() {
System.out.println("eat something");
}
}
public class Demo {
public static void main(String[] args) {
Person p = new Child();
p.eat();
}
}
Dans le Childcas où la classe dans le code ci-dessus n'est utilisée qu'une seule fois, l'écrire en tant que classe interne peut simplifier le code.
abstract class Person {
public abstract void eat();
}
public class Demo {
public static void main(String[] args) {
Person p = new Person() {
public void eat() {
System.out.println("eat something");
}
};
p.eat();
}
}
interface
interface Person {
public void eat();
}
public class Demo {
public static void main(String[] args) {
Person p = new Person() {
public void eat() {
System.out.println("eat something");
}
};
p.eat();
}
}
Tant qu'une classe est abstraite, les méthodes de ses sous-classes peuvent être implémentées à l'aide de classes internes anonymes.
Classe interne statique
Par rapport à la classe interne membre, la classe interne statique en a une de plus static, c'est-à-dire qu'elle n'a pas besoin de dépendre de la classe externe. De plus, il ne peut pas utiliser de variables membres non statiques ou de méthodes de classes externes.
public class Test {
public static void main(String[] args) {
Outter.Inner inner = new Outter.Inner();
}
}
class Outter {
public Outter() {
}
static class Inner {
public Inner() {
}
}
}
Quelques avantages des classes internes
- Chaque classe interne peut hériter indépendamment de l'implémentation d'une interface, donc peu importe si la classe externe a hérité de l'implémentation d'une interface, cela n'a aucun effet sur la classe interne.
- Il est pratique d'organiser ensemble les classes qui ont une certaine relation logique et peuvent être cachées du monde extérieur.
Référence
- https://zhuanlan.zhihu.com/p/45339875
- https://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html
- https://www.cnblogs.com/dolphin0520/p/3811445.html