Analyse d'instance de classe interne Java

Classes internes :

En fait, les classes internes, comme leur nom l'indique, sont des classes dans les classes, et il y a une classe dans une classe.

Les classes internes sont divisées en quatre types :

1. Les classes internes ordinaires

2. # 🎜🎜#

3. Classe interne de méthode

4. Classe interne anonyme

Apprenons-la un par un~~

#🎜🎜 ## 🎜🎜#A. Classes internes ordinaires :

Comprenons-le d'abord à travers le code :

package InternalClass;
/**
 * 内部类
 */
public class Car {
    public int a = 10;
    public int b = 20;
    //外部类的方法
    public void method() {
        System.out.println("我是外部类Car的普通方法！");
        bus b = new bus();     //创建内部类的对象
        b.internalMethod();
    }
    //内部类（在Car类中的bus类）
    public class bus {
        int b = 30;
        //内部类方法
        public void internalMethod() {
            System.out.println("**这是bus内部类的普通方法！");
            System.out.println("**我是内部类，现在在访问外部类Car的a:" + a);
            System.out.println("**我是内部类，现在在访问内部类bus的b:" + this.b);
            System.out.println("**我是内部类，现在在访问外部类bus的b:" + Car.this.b);
            //注意，如果在内部类需要使用外部类的属性，必须通过外部的类去this外部类的属性
        }
    }    
	//程序运行入口：
	public static void main(String[] args) {
	    Car car = new Car();   //创建外部类的对象
	    car.method();
	    // 运行上面的代码 会输出 ： 我是外部类Car的普通方法！
	   	//运行内部类的方法
	   	//在上面method方法中已经创建了内部类bus的对象b
	   	//这里就是通过使用外部类Car的对象car去new一个内部类对象
	   	bus b = car.new bus();  
	   	//通过内部类对象b 去使用方法即可
	    b.internalMethod();   
		//输出：
		/*
		**这是bus内部类的普通方法！
		**我是内部类，现在在访问外部类Car的a:10
		**我是内部类，现在在访问内部类bus的b:30
		**我是内部类，现在在访问外部类bus的b:20
*/
   }
}

B. #🎜 🎜#

Comme leur nom l'indique, les classes internes statiques modifient également la classe interne avec static pour la rendre statique. Elle peut être appelée directement en utilisant le nom de la classe externe sans créer d'objet : #🎜🎜. #

package InternalClass;
public class Person {
    String name = "小王";
    static int age = 20;
    //创建静态内部类
    public static class Student{
        String name = "小红";
        //静态内部类的方法
        public static void study(){
            Person p = new Person(); //创建外部类的对象
            //静态访问非静态需要使用对象去调用
            System.out.println("内部类静态方法访问外部非静态成员:"+p.name);
            System.out.println("内部类静态方法访问外部静态成员:"+Person.age);
            System.out.println("内部类静态方法访问内部非静态成员:"+new Student().name);
        }
    }
    //程序运行入口
    public static void main(String[] args) {
        //静态内使用方法不需要创建对象
        Student.study();
    }
/*
输出：
内部类静态方法访问外部非静态成员:小王
内部类静态方法访问外部静态成员:20
内部类静态方法访问内部非静态成员:小红
*/
}

C. Classe interne de la méthode :

Comme son nom l'indique, la classe interne de la méthode crée également une nouvelle classe dans le corps de la méthode de la classe externe. :

package InternalClass;
/**
 * 方法内部类
 */
public class Student {
    //方法
    public void study(){
        int age = 20;
        String name = "小王";
        //在方法内写类：方法内部类
        class child{
            //方法内部类的方法
            public void play(){
                System.out.println("孩子喜欢玩！");
            }
        }
        //在外部类study的方法内创建一个生成内部类child的对象，并使用方法
        child c = new child();
        c.play();
    }
    //程序执行入口
    public static void main(String[] args) {
        Student stu = new Student();
        //这里调用study方法后，在study方法体内创建了child的对象和调用了play的方法
        stu.study();  
    }
}
//输出：我叫：小王我今年：20我爱学习
//	   孩子喜欢玩！

Résumé des classes internes (il existe de nombreuses limitations, vous devez donc faire attention aux scénarios d'utilisation) :

1. être des modificateurs d'accès avant la classe

2. Utilisez uniquement

3 dans cette méthode. Impossible de créer des informations statiques

4. variables et paramètres locaux dans la méthode, mais ne peut pas être modifié

#🎜🎜 #5 Vous pouvez accéder librement à toutes les informations de la classe externe

D. 🎜🎜#

Une classe interne anonyme est une classe interne sans nom Classe :

Définissez d'abord une interface :

public interface USB {
    void read();
}

package InternalClass;
/**
 * 匿名内部类
 */
public class Child {
    public static void main(String[] args) {
        USB u = new USB() {
            @Override
            public void read() {
                System.out.println("这是匿名内部类，是USB接口没有具名的子类，必须重写 接口做具体实现");
            }
        };
        u.read();
    }
}

Quatre points à noter pour les classes internes anonymes :

1 .Les classes internes anonymes ne peuvent pas définir de membres ou de méthodes statiques

2 Les méthodes des classes internes anonymes ne peuvent pas être abstraites.

3. Les classes internes anonymes doivent implémenter des interfaces ou un parent abstrait. Toutes les méthodes abstraites de la classe

4. Les variables membres de la classe externe ou les méthodes membres accessibles par les classes internes anonymes doivent être décorées. with static

Résumé des classes internes :

#🎜 🎜#1.

Les classes internes ont les caractéristiques de base des classes : elles peuvent hériter des classes parents et implémenter des interfaces. Dans les problèmes réels, nous rencontrerons des problèmes qui ne peuvent pas être résolus par les interfaces. Dans ce cas, nous pouvons utiliser des interfaces internes. classes pour hériter d'une classe spécifique ou abstraite, résout indirectement une série de problèmes causés par l'incapacité de plusieurs classes d'héritage.

2. Avantages des classes internes :

Les classes internes peuvent utiliser plusieurs instances. Chaque instance a ses propres informations d'état et est indépendante des informations des autres objets périphériques. La classe n'a pas la relation déroutante "est-un". C'est une entité indépendante. La classe interne offre une meilleure encapsulation. À l'exception de la classe externe, les autres classes ne peuvent pas accéder à l'objet de classe interne. ne dépend pas de la création d'objets de classe périphériques

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!