内部类 (成员内部类、静态内部类、局部内部类、匿名内部类)

内部类:
成员内部类 :跟成员变量的位置是一样的 方法外,外部类以内
当成员内部类中的属性和外部类的属性发生冲突时,想要调用或修改外部类的属性,应该通过 外部类类名.this.属性名来调用
比如

class Outer{
	int a = 10;
	class Inner{
		int a = 20;
		public void print(){
			System.out.println(Outer.this.a);  //打印结果10
			System.out.println(this.a);  //打印结果20
		}
	}
}

(1)可以访问外部类的私有成员
(2)创建成员内部类对象,必须先创建外部类对象,再通过外部类对象.new 构造内部类对象
(3)成员内部类中不能有静态成员
(4)外部类类名.this指向外部类的当前对象

静态内部类 :成员内部类加了一个static
(1)只能访问外部类的静态成员
(2)创建静态内部类对象,不需要先创建外部类对象

局部内部类 :定义在方法以内的内部类
(1)使用范围等同于局部变量
(2)不仅可以访问外部类的私有成员,还可以访问外部类的局部常量(也就是final修饰的局部变量)

匿名内部类 :特殊的局部内部类
使用条件
(1)是用来继承一个类或者实现一个接口
(2)只会创建该类的一个对象

作用:
1.匿名内部类可以很好的实现隐藏，一般的非内部类，是不允许有 private 与protected权限的，但内部类可以。

2.内部类拥有外部类的所有元素的访问权限。

3.可以实现多重继承。

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

Lambda表达式
使用场景(接口中只有一个抽象方法)
接口名 引用 = (形参列表)->{//方法实现部分};
而且Lambda表达式中形参列表的数据类型可以省略,编译器自行推断
带有返回值的要在实现语句中返回对应的类型;而且可以省略return关键字和花括号

public class TestLambda{
	public static void main(String []args){
		IC ic = ()->{System.out.println("mc()...");}
		ID id = (a,b)->{System.out.println("mc()...");}
		IE ie = (a,b)->"mc()...";
	}
}

interface IC{
	void mc();
}

interface ID{
	void md(int a,String b);
}

interface IE{
	String md(double a,char c);
}

成员内部类的实例过程

package p1;

public class TestMemberInnerClass{
	public static void main(String []args){
		//创建一个外部类
		Outer o = new Outer();
		//通过外部类来创建内部类
		Outer.Inner in = o.new Inner();
		//调用内部类的成员方法print()
		in.print();
	}
}

class Outer{
	private int a = 10;//外部类Outer的私有属性a
	//内部类Inner
	public class Inner{
		private int a = 15;
		private int b = 20;//内部类Inner的私有属性b
		public void print(){
			System.out.println(Outer.this.a);//在内部类Inner的成员方法print中打印外部类Outer的私有属性a
			System.out.println(this.a);//打印内部类Inner的属性a
			System.out.println(b);//打印内部类Inner的属性b
		}
	}
}

打印结果图

静态内部类的实例过程

package p2;

public class TestStaticInnerClass{
	public static void main(String []args){
		//不用创建对象直接用类名访问静态成员
		System.out.println(Outer.Inner.b);
		
		//创建静态内部类对象不用创建外部类对象
		Outer.Inner in = new Outer.Inner();
		in.print();
	}
}

class Outer{
	//外部类成员a = 10
	int a = 10;
	static int b = 12;
	
	//定义一个静态内部类
	static class Inner{
		static int b = 20;
		public void print(){
			//在静态内部类中直接用外部类名.静态属性名打印外部类静态属性
			System.out.println(Outer.b);
		}
	}
}

打印结果图

局部内部类的实例过程

package p3;

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

class Outer{
	private int out = 10;
	public void method(int a){
		int b = 9;
		b = 10;
		class Inner{
			public void print(){
				System.out.println(out);
				System.out.println(a);
				System.out.println(b);
			}
		}
		Inner in = new Inner();
		in.print();
	}
}

打印结果图?怎么肥四??出错了???

那么,问题来了,为什么会出现这个错误呢?
原来,我用的是jdk8.0版本,和接口一样,默认给你添加了需要的修饰符,在这里添加的也就是final了
好,我现在把b=10给注释掉,再来看看运行结果

ok,结果打印出来了,这也就验证了我们上面所说的访问范围
局部内部类不仅可以访问外部类的成员(属性和方法),还可以访问外部类的局部常量

记住! 是局部常量!!! 原因是什么 我也不知道,希望有大佬能给我解答一下吧~~~嘿嘿

匿名内部类的实例过程

package p4;

public class TestAnonymousInnerClass{
	public static void main(String []args){
		m(new IA(){
			public void method(){
				System.out.println("我是匿名内部类");
			}
		});
	}
	
	public static void m(IA ia){
		ia.method();
	}
}

interface IA{
	void method();
}

小问号你是否有很多朋友???

这写的是啥玩意???
我们先来看看运行结果

编译还真没报错,还能打印出来
现在,我们回过头来看看这是个什么玩意

	m(new IA(){
		public void method(){
			System.out.println("我是匿名内部类");
		}
	});
	/*
		把它修饰一下就是
		m(匿名内部类);
		也就是 定义了一个没有名字的局部内部类
		我们假设这个类的名字是Unknown
		public class TestAnonymousInnerClass{
			public static void main(String []args){
				m(new Unknown());
			}
			public static void m(IA ia){
				class Unknown implements IA{
					public void method(){
						System.out.println("我是匿名内部类");
					}
				}
			}
		}
	*/

从这里可以看出,匿名内部类还是有弊端的,那就是它的可读性不高,那为什么还是有这么多人用呢?
往上看,去看看匿名内部类的作用你就知道了~~~