文章目录
- 静态内部类(被static修饰的成员内部类)--可以实例化!
- 获取静态内部类对象(把它当成外部类的成员)
- 静态内部类可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法
- 静态内部类跟静态方法一样，只能访问静态的成员变量和方法，不能直接访问外部类的非静态成员变量,但是普通内部类可以访问任意外部类的成员变量和方法
- 实例内部类(未被static修饰的成员内部类)
- 实例化实例内部类(先将外部类实例化)
- 实例内部类中包含了2个this(一个是外部类,一个是实例内部类自己)
- 匿名内部类
- 匿名对象(运用的场景是只使用一次对象)
- 匿名内部类
- 局部内部类(定义在方法里面)
- 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。
- 在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。
public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类
静态内部类(被static修饰的成员内部类)–可以实例化!
获取静态内部类对象(把它当成外部类的成员)
创建静态内部类对象时，不需要先创建外部类对象
class Outer {
//静态内部类
static class InnerClass {
}
}
public class Test {
public static void main(String[] args) {
Outer.InnerClass inn = new Outer.InnerClass();
}
}
class Outer {
//静态内部类
static class InnerClass {
}
InnerClass inn = new InnerClass();
}
静态内部类可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法
静态内部类跟静态方法一样，只能访问静态的成员变量和方法，不能直接访问外部类的非静态成员变量,但是普通内部类可以访问任意外部类的成员变量和方法
- 因为外部类对象的非静态成员,依赖外部类对象
- 被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问,方便在没有创建对象的情况下进行调用(方法/变量)
class Outer {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//静态内部类
static class InnerClass {
public int data4 = 4;
public static int data5 = 5;
public void test() {
Outer outer = new Outer();
System.out.println(outer.data1);
System.out.println(outer.data2);
System.out.println(data3);
System.out.println(data4);
System.out.println(data5);
}
}
}
public class Test {
public static void main(String[] args) {
Outer.InnerClass inn = new Outer.InnerClass();
inn.test();
}
}
class Outer {
//静态内部类
static class InnerClass {
public static int data = 5;
public static void test() {
System.out.println(data);
}
}
}
public class Test {
public static void main(String[] args) {
Outer.InnerClass.test();
System.out.println(Outer.InnerClass.data);
}
}
实例内部类(未被static修饰的成员内部类)
一般实例内部类不能有被static修饰的成员变量和方法,但是成员变量加上final后可以变成常量(常量在编译的时候确定)
- 外部类中的任何成员都可以在实例内部类方法中直接访问
- 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象
实例化实例内部类(先将外部类实例化)
实例内部类对象必须在先有外部类对象前提下才能创建
两种方式:
class Outer {
class InnerClass {
}
}
public class Test {
public static void main(String[] args) {
Outer out = new Outer();
Outer.InnerClass innerClass = out.new InnerClass();
Outer.InnerClass innerClass2 = new Outer().new InnerClass();
}
}
实例内部类中包含了2个this(一个是外部类,一个是实例内部类自己)
class Outer {
public int data1 = 1;
public static int data2 = 2;
class InnerClass {
public int data1 = 111;
public static final int data3 = 3;
public void test() {
System.out.println(Outer.this.data1);
System.out.println(this.data1);
System.out.println(data1);
System.out.println(data2);
System.out.println(data3);
}
}
public void func() {
InnerClass innerClass = new InnerClass();
innerClass.test();
}
}
public class Test {
public static void main(String[] args) {
Outer.InnerClass innerClass = new Outer().new InnerClass();
innerClass.test();
}
}
匿名内部类
匿名对象(运用的场景是只使用一次对象)
public class Test {
public void func() {
System.out.println("func()");
}
public static void main(String[] args) {
new Test().func();
}
}
匿名内部类
抽象类和接口可以接收具体对象
interface InterFaceA {
void func();
}
public class Test {
public static void main(String[] args) {
InterFaceA a = new InterFaceA() {
@Override
public void func() {
System.out.println("func()");
}
};
a.func();
System.out.println("============");
new InterFaceA() {
@Override
public void func() {
System.out.println("func()");
}
}.func();
}
}
局部内部类(定义在方法里面)
只能在方法里面实例化对象.
不能被public、static等访问限定符修饰
局部内部类只能在所定义的方法体内部使用
编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class
public class Test {
public void test() {
class InnerClass {
public void test() {
System.out.println("InnerClass::test()");
}
}
InnerClass innerClass = new InnerClass();
innerClass.test();
}
public static void main(String[] args) {
Test test = new Test();
test.test();
}
}
![[环境配置]vscode免密ssh的设置流程](https://img-blog.csdnimg.cn/b62bbbf087a9490f969d930e46ba6082.png)
