(面向对象) Java内部类和匿名内部类

内部类概述:

        把类定义在其他类的内部，这个类就被称为内部类。
        举例：在类A中定义了一个类B，类B就是内部类。

 内部的访问特点：

        A:内部类可以直接访问外部类的成员，包括私有。
        B:外部类要访问内部类的成员，必须创建对象。

class Outer {
	private int num = 10;
	
	class Inner {
		public void show() {
			System.out.println(num);
		}
	}
	
	public void method() {
		//找不到符号
		//show();
	
		Inner i = new Inner();
		i.show();
	}
	
}

class InnerClassDemo {
	public static void main(String[] args) {
	
	}
}

内部类位置：

        成员位置:在成员位置定义的类，被称为成员内部类。    
        局部位置:在局部位置定义的类，被称为局部内部类。

成员位置:

    成员内部类:
        如何直接访问内部类的成员。
        外部类名.内部类名 对象名 = 外部类对象.内部类对象;

class Outer {
	private int num = 10;
	
	class Inner {
		public void show() {
			System.out.println(num);
		}
	}
}

class InnerClassDemo3 {
	public static void main(String[] args) {
		//需求：我要访问Inner类的show()方法
		//Inner i = new Inner();
		//i.show();
		
		//格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

成员内部类的修饰符：

        private 为了保证数据的安全性
        static 为了方便访问数据
            注意：静态内部类访问的外部类数据必须用静态修饰。

class Outer {
	private int num = 10;
	private static int num2 = 100;
	
	//内部类用静态修饰是因为内部类可以看出是外部类的成员
	public static class Inner {
		public void show() {
			//System.out.println(num);//错误: 无法从静态上下文中引用非静态 变量 num
			System.out.println(num2);
		}

		public static void show2() {
			//System.out.println(num);//错误: 无法从静态上下文中引用非静态 变量 num
			System.out.println(num2);
		}		
	}
}

class InnerClassDemo4 {
	public static void main(String[] args) {
		//使用内部类
		// 限定的新静态类
		//Outer.Inner oi = new Outer().new Inner();
		//oi.show();
		//oi.show2();
		
		//成员内部类被静态修饰后的访问方式是:
		//格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
		Outer.Inner oi = new Outer.Inner();
		oi.show();
		oi.show2();
		
		//show2()的另一种调用方式
		Outer.Inner.show2();
	}
}

局部内部类：

        A:可以直接访问外部类的成员
        B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

面试题：

        局部内部类访问局部变量的注意事项?
        A:局部内部类访问局部变量必须用final修饰
        B:为什么呢?
            局部变量是随着方法的调用而调用，随着调用完毕而消失。
            而堆内存的内容并不会立即消失。所以，我们加final修饰。
            加入final修饰后，这个变量就成了常量。既然是常量。你消失了。
            我在内存中存储的是数据20，所以，我还是有数据在使用。

class Outer {
	private int num  = 10;
	
	public void method() {
		//int num2 = 20;
		final int num2 = 20;
		class Inner {
			public void show() {
				System.out.println(num);//10
				//从内部类中访问本地变量num2; 需要被声明为最终类型
				System.out.println(num2);//20
			}
		}
		
		//System.out.println(num2);
		
		Inner i = new Inner();//方法调用随着调用完毕而消失，但是堆内存并没有消失还要继续使用变 
                              //量num2，所以会报错
		i.show();
	}
}

class InnerClassDemo5 {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

匿名内部类：

        就是内部类的简化写法。

    前提：存在一个类或者接口
        这里的类可以是具体类也可以是抽象类。
    
    格式：
        new 类名或者接口名(){
            重写方法;
        }
        
    本质是什么呢?
        是一个继承了该类或者实现了该接口的子类匿名对象。

interface Inter {
	public abstract void show();
	public abstract void show2();
}

class Outer {
	public void method() {
		//一个方法的时候
		/*
		new Inter() {
			public void show() {
				System.out.println("show");
			}
		}.show();
		*/
		
		//二个方法的时候
		/*
		new Inter() {
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		}.show();
		
		new Inter() {
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		}.show2();
		*/
		
		//如果我是很多个方法，就很麻烦了
		//那么，我们有没有改进的方案呢?
		Inter i = new Inter() { //多态
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		};
		
		i.show();
		i.show2();
	}
}

class InnerClassDemo6 {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

静态内部类：

我们知道，一个类的静态成员独立于这个类的任何一个对象存在，只要在具有访问权限的地方，我们就可以通过 类名.静态成员名 的形式来访问这个静态成员，同样的，静态内部类也是作为一个外部类的静态成员而存在，创建一个类的静态内部类对象不需要依赖其外部类对象。

public class InnerClassTest {
	public int field1 = 1;
    
	public InnerClassTest() {
		System.out.println("创建 " + this.getClass().getSimpleName() + " 对象");
        // 创建静态内部类对象
        StaticClass innerObj = new StaticClass();
        System.out.println("其内部类的 field1 字段的值为: " + innerObj.field1);
        System.out.println("其内部类的 field2 字段的值为: " + innerObj.field2);
        System.out.println("其内部类的 field3 字段的值为: " + innerObj.field3);
        System.out.println("其内部类的 field4 字段的值为: " + innerObj.field4);
    }
	
    static class StaticClass {

        public int field1 = 1;
        protected int field2 = 2;
        int field3 = 3;
        private int field4 = 4;
        // 静态内部类中可以定义 static 属性
        static int field5 = 5;

        public StaticClass() {
            System.out.println("创建 " + StaticClass.class.getSimpleName() + " 对象");
//            System.out.println("其外部类的 field1 字段的值为: " + field1); // 编译错误！！
        }
    }

    public static void main(String[] args) {
	    // 无需依赖外部类对象，直接创建内部类对象
//        InnerClassTest.StaticClass staticClassObj = new InnerClassTest.StaticClass();
		InnerClassTest outerObj = new InnerClassTest();
    }
}