【内部类】 成员内部类、局部内部类、匿名内部类

• 成员内部类

public  class  外部类{
    //成员内部类
    public  class  内部类{
        public  void  fun(){
           System.out.println(num);   //内部类可以访问外部类的成员
        }
    }

    private  int  num = 0;  
    //外部类如果要访问内部类的成员，则需要通过内部类的对象访问
}

使用方式：

1.外部类使用内部类，主函数再使用外部类

2.通过new的方式

外部类.内部类 对象名 = new 外部类().new 内部类();

 

• 局部内部类

定义在方法内部的类，就是局部内部类，只有当前所属方法才能使用。

//外部类
public class Outer{
	public void methodOuter(){
		//局部内部类
		class Inner{
			final int n = 0;  // 2.则这个局部变量必须是final修饰的
			public void methodInner(){
				System.out.println(n);  // 1.局部内部类要访问所在方法中的局部变量
			}
		}
		
		Inner inner = new Inner();
		inner.methodInner();
	}
}

public class MyMain{
	public static void main(String[] args){
		Outer outer = new Outer();
		outer.methodOuter();
	}
}

 

局部内部类要访问所在方法中的局部变量，则这个局部变量必须是final修饰的。

原因：

1.new出来的对象在堆中

2.局部变量跟着方法走的，在栈内存当中

3.方法运行结束后，立刻出栈，局部变量就会消失

4.但是new出来的对象还在堆中，直到被回收

 

定义一个类的时候，修饰权限符的规则：

1.外部类：public、(default)

2.成员内部类：public、protected、(default)、private

3.局部内部类：无

 

• 匿名内部类（实现接口不用实现类）

如果接口的实现类（或者是父类的子类）只需要使用唯一一次，那么这种情况下，就可以省略该类的定义，而改为使用匿名内部类。

public interface MyInterFace{
	public abstract void show();
}

public class Cat implements MyInterFace{
	public void show(){
		System.out.println("Hello");
	}
}

public class MyMain{
	public static void main(String[] args){
		//一般情况
		Cat cat = new Cat();
		//或者 MyInterFace cat = new Cat();
	}
}

匿名内部类实现

public interface MyInterFace{
	public abstract void show();
}

public class MyMain{
	public static void main(String[] args){
        //没有实现类Cat
		MyInterFace cat = new MyInterFace(){
            //覆盖所有抽象方法
             public void show(){
		        System.out.println("Hello");
	         }
        };  //别忘了分号
	}
}

或者不用对象名

public class MyMain{
	public static void main(String[] args){
		new MyInterFace(){
             public void show(){
		        System.out.println("Hello");
	         }
        }.show();   //一次性的方法调用
	}
}