java内部类

内部类概念

定义在另一个类内部的类

内部类主要特点：

内部类可以很好的实现隐藏，可以使用public（默认）、protect、private修饰符。以前声明类的时候都是public，或者不写。外部类不能使用protect、private修饰符。

内部类可以访问外部类所有的成员，包括私有的成员。

外部类不能访问内部类的成员和方法。必须建立内部类的对象才能访问。

内部类可以解决一些问题，比如间接的去实现多继承。

内部类可以避免修改接口，而实现同一个类中两种同名方法的调用。

内部类分类：

成员内部类

1、成员内部类属于外部类的实例成员，成员内部类可以有public、private、default、protected权限修饰符。在成员内部类中访问外部类的成员方法和属性，要使用“外部类名.this.成员方法”和“外部类名.this.成员属性”的形式。

2、创建成员内部类的实例使用“外部类名.内部类名 实例名=外部类实例名.new 内部类构造方法（参数）”的形式。

3、成员内部类不能与外部类重名。

4、不能再成员内部类中定义static属性、方法、类（static final形式的常量定义除外）。因为一个成员内部类的实例必然与一个外部类的实例相关联。static成员完全可以移到其外部类中去。

public class Main {public static void main(String[] args) {// OuterClass outerClass = new OuterClass();// InnerClass innerClass = outerClass.new InnerClass();Outer1 outer1 = new Outer1();Outer1.Inner1 inner1 = outer1.new Inner1();outer1.outerShow();inner1.innerShow();}}// 产生三个自己码文件 Main.class Outer1.class Outer1$Inner1.classclass Outer1 {private String name = "zhangsan";private int num1 = 10;public void outerShow() {System.out.println(name);System.out.println(num1);//外部类不能直接访问内部类的成员和方法//System.out.println(num2);//外部类要想访问内部类的属性和方法，必须先产生内部类对象Inner1 inner1 = new Inner1();inner1.innerShow();}//private class Inner1 私有的时候其他类不能创建内部类对象public class Inner1 {// 是否对外公开private String name = "lisi";private int num2 = 20;//静态的常量是可以的private static final int num3 = 20;// 在成员内部类中不能声明静态的成员，包括属性和方法// private static int num3=30;public void innerShow() {System.out.println("----------");System.out.println(name);System.out.println(num2);// 成员内部类可以直接访问外部类的属性和方法,包括私有的System.out.println(num1);outerShow();//Outer1.this外部类对象的引用，没有同名方法可以不加System.out.println(Outer1.this.name);Outer1.this.outerShow();}}}

//内部类可以避免修改接口，而实现同一个类中两种同名方法的调用。//具体的实用意义不大，只是为了演示学习内部类public class Main3 {public static void main(String[] args) {// TODO Auto-generated method stubSon son = new Son();son.show();son.show2();}}abstract class Parent {public abstract void show();}interface IShow {public abstract void show();}// class Son extends Parent implements IShow{//// @Override// public void show() {// }// }class Son extends Parent {@Overridepublic void show() {System.out.println("抽象类中show");}private class Inner2 implements IShow {@Overridepublic void show() {System.out.println("Inner2中show");}}public void show2() {new Inner2().show();}}

静态内部类

1、使用static修饰的成员内部类叫静态内部类。

2、静态内部类和外部类没有任何关系，只是在生成类名和类定义的时候有影响。静态内部类可以看做是与外部类平级的类。使用方式与外部类平级的类完全相同。

3、创建静态内部类的实例：外部类名.内部类名 实例名 = new 外部类名.内部类名（参数）;

4、静态内部类不能与外部类重名

5、静态内部类不能访问外部类的非静态的属性和方法。外部类不能访问内部类的非静态的属性和方法。

（把静态内部类当做外部类的静态方法来看）

public class StaticMain {public static void main(String[] args) {// 构造静态内部类对象Outer2.Inner2 inner2 = new Outer2.Inner2();inner2.innerShow();Outer2 outer2 = new Outer2();outer2.outerShow();}}class Outer2 {private String name = "zhangsan";private int num1 = 10;private static int num3 = 100;public void outerShow() {System.out.println(name);System.out.println(num1);// 不能访问// System.out.println(Inner2.name);// 可以通过内部类对象进行访问Inner2 inner2 = new Inner2();System.out.println(inner2.name);// 可以访问内部类中的静态属性System.out.println(Inner2.num3);}public static class Inner2 {private String name = "lisi";private int num2 = 20;private static int num3 = 30;public void innerShow() {// 静态内部类不能访问外部类中非静态成员// System.out.println(Outer2.this.name);// 可以访问自己内部的System.out.println(num2);// 通过类名访问System.out.println(Outer2.num3);}}}

匿名内部类

1、匿名内部类是没有名称的内部类，没有办法引用它们。必须在创建的时候作为new语句的一部分来声明并创建它们的实例。

2、匿名内部类必须继承一个类（抽象的、非抽象的都可以）或者实现一个接口。如果父类（或者父接口）是抽象类，则匿名内部类必须实现其所有的抽象方法。

3、匿名内部类中可以定义代码块{}，用于实例的初始化（代码块优先构造方法先执行），但是不能定义静态代码块。

4、new interface/superclass{ }

这种形式的new语句声明一个新的匿名类，它对一个给定的类进行扩展，或者实现一个给定的接口，并同时创建该匿名类的一个新实例。new 出来的是接口/抽象类的实现类对象。

5、接口/抽象类绝对不能实例化。

public class AnonymousInnerClass {public static void main(String[] args) {Person person = new Person();Animal dog = new Dog();person.feed(dog);person.feed(new Animal() {@Overridepublic void eat() {System.out.println("吃鱼");}});new Animal() {// 匿名内部类中可以有自己的属性private String name = "dog";// static不能有静态代码块{name = "haha";}@Overridepublic void eat() {System.out.println("吃鱼");}// 匿名内部类中可以有自己的方法public void show() {System.out.println("show " + name);}}.show();// 调用自己的方法，只能通过这个方法}}class Person {// 多态public void feed(Animal animal) {animal.eat();}}abstract class Animal {public abstract void eat();}class Dog extends Animal {@Overridepublic void eat() {System.out.println("啃骨头");}}

局部内部类

1、局部内部类使用最少。

2、定义在代码块{}，方法体内的类叫局部内部类。

3、局部内部类访问外部类的属性和方法使用“外部类名.this.属性名”和“外部类名.this.方法名（参数）”的形式。

4、对外部世界完全隐藏，只能在其作用域内生成对象。只能在方法体，代码块中构造。

5、局部类不能加访问修饰符，因为它们不是类成员。可以看做是局部变量。只有属性或者说是类的成员才能加访问修饰符。

6、成员内部类不能与外部类重名。

7、局部内部类访问作用域内的局部变量，该局部变量需要使用final修饰。也就是说局部内部类只能访问方法或者语句块中声明的常量。

public class LocalInnerClass {public static void main(String[] args) {Outer3 outer3 = new Outer3();outer3.showOuter();}}class Outer3 {private String name = "zhangsan";private int num1 = 10;private static int num2 = 20;public void showOuter() {int num4 = 50;final int num5 = 60;// 局部内部类不能加访问修饰符//局部内部类的声明周期很短，只在方法的语句块中有效//方法运行完，局部内部类对象释放class Inner3 {private int num3 = 30;private int num1 = 20;public void showInner() {System.out.println(num3);//自己的num1System.out.println(num1);//可以访问到System.out.println(Outer3.this.num1);System.out.println(Outer3.num2);//局部内部类只能访问声明其方法中的常量final//System.out.println(num4);System.out.println(num5);}}// 方法从上向下执行，只能在class之后创建，外部能不能使用Inner3Inner3 inner3 = new Inner3();inner3.showInner();}}