class 外部类类名{
class 内部类类名{
内部类类体;
}
}
private String str = "Outer类的str1";
private String str2 = "Outer类的str2";
/*
* 第一:内部类的名称不能与外部类重名
* 第二:可以使用final、访问修饰符修饰
*/
public class Inner{ // 内部类
private String str = "Inner类的str1";
private String str2 = "Inner类的str2";
public void show() {
// 内部类的成员优先于外部类成员
System.out.println(str);
System.out.println(str2);
// 使用"外部类.this.成员"访问外部类的成员
System.out.println(Outer.this.str2);
System.out.println(Outer.this.str);
}
}
}
```
- TestOuter.java
```java
import Inner.demo1.Outer.Inner;
public class TestOuter {
public static void main(String[] args) {
// 如果要创建内部类,那么在此之前需要先创建外部类对象
// 创建外部类对象
Outer o = new Outer();
// 创建内部类
Inner inner = o.new Inner();
inner.show();
}
}
```
Inner类的str1
Inner类的str2
Outer类的str2
Outer类的str1
private String str1 = "Outer类中的str1";
private String str2 = "Outer类中的str2";
// 定义一个外部类的方法
public void print() {
System.out.println("Outer类中的print方法");
}
static {
class Inner{} // 局部内部类
}
public void method() {
// 必须在使用之前定义
class Inner{
private String str1 = "Inner类中的str1";
// 内部类成员优先于外部类成员
public void visitOuter() {
System.out.println(str1);
System.out.println(str2);
print(); // 直接跳到外部类方法
}
}
// 局部内部类只能在定义它的方法或代码块中使用
// 只能使用abstract/final修饰,不能与外部类重名
Inner in = new Inner();
in.visitOuter();
}
}
```
- TestOuter.java
```java
public class TestOuter {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
```
Inner类中的str1
Outer类中的str2
Outer类中的print方法
public abstract void print();
}
```
- Outer.java
```java
public class Outer { // 外部类
private String str1 = "Outer类中str1";
private String str2 = "Outer类中str2";
// 匿名内部类
InterDemo id = new InterDemo() {
private String str1 = "匿名内部类str1";
@Override
public void print() {
System.out.println(str1);
System.out.println(str2);
// 如果想要调用外部类的变量 , 外部类.this.变量
System.out.println(Outer.this.str1);
}
};
public void show() {
id.print();
}
}
```
- TestOuter.java
```java
public class TestOuter {
public static void main(String[] args) {
Outer o = new Outer();
o.show();
}
}
```
匿名内部类str1
Outer类中str2
Outer类中str1
// 创建两个成员变量 一个静态,一个非静态
private String str1 = "外部类的str1";
private static String str2 = "外部类的str2";
// 成员方法,静态
public static void show1() {
System.out.println("外部类的show方法");
}
// 静态嵌套类
// 只能定义在类的成员位置,不能定义在方法或代码块中
public static class Inner{
private String str1 = "嵌套类的str1";
// private static String str2 = "嵌套类的str2";
public void show() {
System.out.println(str2);
System.out.println(str1);
// 不能直接访问外部类的非静态成员
// 但是可以直接访问外部类的静态成员
show1();
}
}
}
```
- TestOuter.java
```java
import Inner.demo4.Outer.Inner;
public class TestOuter {
public static void main(String[] args) {
// 如何创建内部类或者静态嵌套类对象
// 首先创建外部类的对象
Inner Inner = new Outer.Inner();
Inner.show();
}
}
```
外部类的str2
嵌套类的str1
外部类的show方法
名称 | 内部类(非静态嵌套类) | 静态嵌套类
喜欢就关注博主博吧 :smile:
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。