内部类:
成员内部类 :跟成员变量的位置是一样的 方法外,外部类以内
当成员内部类中的属性和外部类的属性发生冲突时,想要调用或修改外部类的属性,应该通过 外部类类名.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("我是匿名内部类");
}
}
}
}
*/
从这里可以看出,匿名内部类还是有弊端的,那就是它的可读性不高,那为什么还是有这么多人用呢?
往上看,去看看匿名内部类的作用你就知道了~~~