三大内部类

一 成员内部类

package com.ys.bao15;
/*
 * 成员内部类：在类的成员位置，与类的成员变量，成员方法处于同一位置
 * 
 */
public class InnerDemo {
	public static void main(String[] args) {
		Outer.Inner i = new Outer().new Inner();
		i.function();
		
//		Outer o = new Outer();
//		o.method();
	}
}

class Outer{
	private int num = 10;
	public void method() {
		Inner i = new Inner();
		i.function();
	}
	class Inner{
		public void function() {
			System.out.println("方法");
			//在内部类中，可以直接访问外部类的的成员，即使是私有的！
			System.out.println(num);
		}
	}
}

成员内部类可用的修饰符

package com.ys.bao15;
/*
 * 成员内部类的修饰符：我们可以使用权限修饰符来修饰内部类，但是如果使用private的来修饰，则无法在其他类中访问
 * 				我们可以使用static修饰成员内部类，就不用再创建外部类的对象了
 * 
 * 		还可以使用abstract，final修饰，不过意义不大
 */
public class InnerDemo02 {
	public static void main(String[] args) {
//		Outer2.Inner2 i = new Outer2().new Inner2();
//		i.function();
		//如果使用static修饰内部类，在主函数里new对象时，就不用再先创建出外部类的对象
		//直接new内部类的对象就行了
		Outer2.Inner2 i = new Outer2. Inner2();
		i.function();
	}
}

class Outer2{
	public void method(){
		Inner2 i = new Inner2();
		i.function();
	}
	static class Inner2{
		public void function() {
			System.out.println("方法");
		}
	}
}

二 局部内部类

package com.ys.bao15;
/*
 * 局部内部类：它的位置在方法内，出了方法就不能使用了
 */
public class InnerDemo03 {
	public static void main(String[] args) {
		Outer3 o = new Outer3();
		o.method();
		
	}
}

class Outer3{
	public void method() {
		int num = 10;
		class Inner3{
			public void function() {
				System.out.println("方法");
			}
		}
		Inner3 i = new Inner3();
		i.function();
		
	}
	public void test() {
//		System.out.println(num);
//		Inner i = new Inner();
	}
}

三 匿名内部类

package com.ys.bao15;
/*
 * 匿名内部类：可以把匿名内部类看做是没有名字的局部内部类
 * 			它定义在方法中
 * 			必须在定义匿名内部类的时候创建它的对象
 * 格式：
 * 		new 类/接口（）{
 * 			如果是创建了继承这个类的子类对象，	我们可以重写父类的方法
 * 			如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法
 * 		};
 * 原理：	是创建了继承这个类的子类对象或者是实现了这个接口的子类对象
 */
public class InnerDemo04 {
	public static void main(String[] args) {
		Outer4 o = new Outer4();
		o.method();
	}
}

interface Inner{
	abstract public void function();
}

class Outer4{
	public void method() {
//		new Inner() {
//
//			@Override
//			public void function() {
//				System.out.println("方法");
//			}
//			
//		}.function();;//相当于有了对象，再  .方法   进行调用，不过这样的缺点就是只能调一次
		
		//向上转型，把这个对象赋给同类型的对象
		Inner i = new Inner() {

			@Override
			public void function() {
				System.out.println("方法");
			}
			
		};
		//这样的话就想调用几次调用几次了
		i.function();
		i.function();
		i.function();
	}
}