Tatsächlich sind interne Klassen, wie der Name schon sagt, Klassen innerhalb von Klassen, und es gibt eine andere Klasse innerhalb einer Klasse.
Innere Klassen sind in vier Typen unterteilt:
1. Statische innere Klassen
3. Anonyme innere Klassen
Lernen Sie sie einzeln kennen ~ ~
Um es statisch zu machen, können Sie den externen Klassennamen direkt aufrufen, ohne ein Objekt zu erstellen:
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
*/
}
}Methode interne Klasse erstellt, wie der Name schon sagt, auch eine neue Klasse in Methodenkörper der externen Klasse:
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
内部类静态方法访问内部非静态成员:小红
*/
}1. Vor der Klasse dürfen keine Zugriffsmodifikatoren vorhanden sein
2 kann nur innerhalb dieser Methode verwendet werden
3. Statische Informationen können nicht erstellt werden 4 Es kann direkt auf lokale Variablen und Parameter innerhalb der Methode zugegriffen werden
5 Sie können nach Belieben auf alle Informationen der externen Klasse zugreifen
D. Anonyme innere Klasse:
Anonyme innere Klasse ist eine innere Klasse ohne Namen:
Definieren Sie zuerst eine Schnittstelle:
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我爱学习
// 孩子喜欢玩！public interface USB {
void read();
}1 Klassen können keine statischen Mitglieder oder Methoden definieren
2. Methoden in anonymen inneren Klassen können nicht abstrakt sein 3. Die inneren Klassen müssen alle abstrakten Methoden der Schnittstelle oder der abstrakten übergeordneten Klasse implementieren
4. Die externen Klassenmitgliedervariablen bzw Mitgliedsmethoden, auf die die anonyme innere Klasse zugreift, müssen mit statischen Methoden geändert werden.
Zusammenfassung der inneren Klassen:
1. Warum innere Klassen verwenden? Interne Klassen haben die grundlegenden Eigenschaften von Klassen: Sie können übergeordnete Klassen erben und Schnittstellen implementieren. Bei tatsächlichen Problemen werden wir auf einige Probleme stoßen, die durch Schnittstellen nicht gelöst werden können. In diesem Fall können wir interne Klassen verwenden, um eine bestimmte oder zu erben abstrakte Klasse. Löst indirekt eine Reihe von Problemen, die durch die Unfähigkeit von Klassen zur Mehrfachvererbung verursacht werden.
2. Vorteile innerer Klassen:
Innere Klassen können mehrere Instanzen verwenden und sind unabhängig von den Informationen anderer peripherer Objekte , er ist eine unabhängige Entität. Mit Ausnahme der äußeren Klasse können andere Klassen nicht auf den Moment zugreifen, in dem das Objekt der inneren Klasse erstellt wird, und sind nicht auf die Erstellung des Objekts der äußeren Klasse angewiesen
Das obige ist der detaillierte Inhalt vonAnalyse interner Java-Klasseninstanzen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
