内部类

内部类可以实现多继承的效果。

成员内部类静态内部类方法内部类匿名内部类

成员内部类

成员内部类内部不允许存在任何static变量或方法 正如成员方法中不能有任何静态属性 （成员方法与对象相关、静态属性与类有关）

成员内部类是依附外部类的，只有创建了外部类才能创建内部类。

class OuterClass { int x = 10; private class InnerClass { int y = 5; public void p(){ x++;//访问父类属性 } } } public class MyMainClass { public static void main(String[] args) { OuterClass myOuter = new OuterClass(); OuterClass.InnerClass myInner = myOuter.new InnerClass(); System.out.println(myInner.y + myOuter.x); } }

重名

见内部类与外部类关系

类.this.属性/方法 //类名为外部类或内部类

访问权限

内部类与外部类可以访问彼此的所有属性，方法（包括私有方法、私有属性）。

静态内部类

使用static修饰的内部类我们称之为静态内部类，静态内部类和非静态内部类之间存在一个最大的区别，非静态内部类在编译完成之后会隐含的保存着一个引用，该引用是指向创建它的外围类，但是静态类没有。没有这个引用就意味着：

静态内部类的创建不需要依赖外部类可以直接创建。静态内部类不可以使用任何外部类的非static类（包括属性和方法），但可以有自己的成员变量。 public class A { public String name = "test"; private static int age =20; static class Inner{ private String name; public void fun() { System.out.println(name); System.out.println(age); } } public static void main(String [] args) { A.Inner in = new A.Inner(); in.fun(); } }

访问权限

内部类与外部类可以访问彼此的所有属性，方法（包括私有方法、私有属性）。

方法内部类

定义在方法里的类

方法内部类不允许使用访问权限修饰符（public、private、protected）均不允许。

方法内部类对外部完全隐藏，除了创建这个类的方法可以访问它以外，其他地方均不能访问

方法内部类如果想要使用方法形参，该形参必须使用final声明（JDK8形参变为隐式final声明）

public class A { private int num =5; //普通方法 public void dispaly(int temp) { //方法内部类即嵌套在方法里面 class Inner{ public void fun() { System.out.println(num); //temp++; //Error System.out.println(temp);// Fine } } //方法内部类在方法里面创建 new Inner().fun(); } public static void main(String[] args) { A out = new A(); out.dispaly(2); } }

匿名内部类

匿名内部类就是一个没有名字的方法内部类，因此特点和方法与方法内部类完全一致，除此之外，还有自己的特点：

匿名内部类必须继承一个（或抽象）类或者实现一个接口。（创建实例写法）匿名内部类没有类名，因此没有构造方法。 interface MyInterface { //接口中方法没有方法体 void test(); } public class A{ private int num = 5; public void dispaly(int temp) { //匿名内部类，匿名的实现了MyInterface接口 // 接口单方法，可以写成lambada表达式 new MyInterface() { public void test() { System.out.println("匿名实现MyInterface接口"); System.out.println(temp); } }.test(); } public static void main(String[] args) { A out = new A(); out.dispaly(3); } }

方法参数也可以

interface MyInterface { void test(); } abstract class Z1{ abstract public void p(MyInterface my); } public class A extends Z1{ private int num = 5; public static void main(String[] args) { A out = new A(); out.dispaly(3); out.p(() ->{ System.out.println("f"); }); } @Override public void p(MyInterface my) { } }

创建内部类对象

在外部类内创建

Inner in = new Inner();

在外部类外部 创建非静态内部类

需先创建外部类实例

语法： 外部类.内部类 内部类对象 = new 外部类().new 内部类(); 举例： Outer.Inner in = new Outer().new Inner();

在外部类外部 创建静态内部类

语法： 外部类.内部类 内部类对象 = new 外部类.内部类(); 举例： Outer.Inner in = new Outer.Inner();

内部类与外部类的关系

对于非静态的内部类，内部类的创建依赖外部类的实例对象，在没有外部类实例之前是无法创建内部类的。内部类可以直接访问外部类的元素（包括私有域）外部类在内部类之前创建，创建内部类时会将外部类的对象传入 class Outer{ //成员变量 与对象有关 private String msg; private int age; //-------------------------- class Inner{ public void dispaly() { //此处有一个隐藏的Outer.this msg = "test"; age = 20; System.out.println(msg); System.out.println(age); } } //-------------------------- public void test() { Inner in = new Inner(); in.dispaly(); } } public class Test{ public static void main(String[] args) { Outer out = new Outer(); out.test(); } } 外部类可以通过内部类的引用间接访问内部类元素 – -要想访问内部类属性，必须先创建内部类对象 class Outer{ public void dispaly() { //外部类通过创建内部类的对象间接访问内部类元素 Inner in = new Inner(); in.dispaly(); } class Inner{ public void dispaly() { System.out.println("内部类"); } } } public class Test1{ public static void main(String[] args) { Outer out = new Outer(); out.dispaly(); } }

匿名类

见匿名内部类

class Polygon { public void display() { System.out.println("在 Polygon 类内部"); } } class AnonymousDemo { public void createClass() { // 创建的匿名类继承了 Polygon 类 Polygon p1 = new Polygon() { public void display() { System.out.println("在匿名类内部。"); } }; p1.display(); } } class Main { public static void main(String[] args) { AnonymousDemo an = new AnonymousDemo(); an.createClass(); } }