day08内部类以及匿名内部类概念

内部类

1 概念

定义在类的内部的类叫内部类

2 分类

1成员内部类
2 普通内部类
3 私有内部类
4 静态内部类
5 局部内部类
~ 内部类的层次是没有限制的

3 普通内部类

直接定义在类的内部中，作为类的成员之一，使用public或者缺省修饰词修饰的内部类

public class Outer {
int num = 6;
// 普通内部类
public class Inner {
int count = 9;
public void innerRun() {
System.out.println("--innerRun--");
}
}
public void outerRun() {
System.out.println("---outerRun--");
}
}

1 访问内部类
–》在外部类的方法中访问内部类，需要定义一个内部类对象，通过对象去访问
–》在其他类中访问内部类

public void outerRun() {
System.out.println("---outerRun--");
// 访问内部类
Inner inner = new Inner();
inner.innerRun();
}

public static void main(String[] args) {
// 内部类对象的创建
// Outer.Inner inner = 外部类对象.new 内部类();
Outer.Inner inner = new Outer().new Inner();
Outer outer = new Outer();
Outer.Inner inner2 = outer.new Inner();
// 调用内部类方法
inner.innerRun();
}

2 内部类中可以直接访问外部类的成员

// 普通内部类
public class Inner {
int count = 9;
public void innerRun() {
System.out.println("--innerRun--" + num);
outerRun();
}
}

3 内部类和外部类中的成员是可以同名的
通过this和Outer.this区分

public class Outer {
int num = 6;
// 普通内部类
public class Inner {
int count = 9;
int num = 7;
public void innerRun() {
//同名时this是内部类对象，Outer.this是外部类对象
System.out.println("--innerRun--" + num + Outer.this.num);
outerRun();
}
}

4 私有内部类

定义在类的内部，并且private修饰的内部类

public class Outer2 {
int num = 6;
// 私有内部类
private class Inner {
int count = 9;
int num = 7;
public void innerRun() {
outerRun();
}
}
public void outerRun() {
System.out.println("---outerRun--");
// 访问内部类
Inner inner = new Inner();
inner.innerRun();
}
}

1 不能在其他类中访问内部类
2 可以通过外部类的方法，创建内部类对象，通过调用外部类的方法间接访问内部类
3 外部类的访问修饰词public 缺省的，内部类可以被private和static ，protecte等修饰

5 静态内部类

static 修饰的内部类

public class Outer2 {
int num = 6;
// 静态内部类
static class Inner {
int count = 9;
int num = 7;
public void innerRun() {
System.out.println("--innerRun--");
}
}
public void outerRun() {
System.out.println("---outerRun--");
}
}

1 静态内部类中是可以有静态和非静态的成员的
2 一旦内部类中有静态的成员，则该内部类一定是静态内部类
3 静态内部类中只能访问外部类中静态的成员
4 外部类中访静态内部类 Outer2.inner inner3=new Outer2.inner（）；

6 局部内部类

定义在方法中的内部类

public void outerRun() {
System.out.println("---outerRun--");
class A {
int i = 9;
public void runA() {
System.out.println("runA" + num);
}
}
}

1 局部内部类的作用域范围，只有该方法
2 局部内部类可以正常访问外部类的数据
3 只能在该方法中去创建内部类对象，从而访问内部类数据，在其他方法中访问外部类，间接访问局部内部类
4 jdk1,7之前，要求局部内部类中范文的局部变量必须是final修饰的

7 * 匿名内部类

7.1 概述

1 是没有名字的内部类
2 一次性的内部类，将类的定义和类的实例化一次性完成的类
3 匿名内部类定义的是一个类的子类或者一个借口的实现类
4 实例化的是类的子类或接口的实例化对象

7,2 格式

7,3 案例

new 类名(){
//重写的方法
};

public interface InnerA {
public void run();
}
abstract class Demo {
public abstract void test();
public void show() {
System.out.println("---show--");
}
}
public static void main(String[] args) {
//匿名内部类
InnerA innerA2 = new InnerA() {
@Override
public void run() {
System.out.println("run----");
}
};
//调用方法
innerA2.run();
Demo demo = new Demo() {
@Override
public void test() {
System.out.println("--test--");
}
@Override
public void show() {
System.out.println("show");
}
};
demo.show();
}

使用场景

匿名内部类经常作为参数

匿名内部类经常作为参数
public interface InnerA {
public void run();
public void test();
}
public class Tool {
public static void toolMethod(InnerA innerA) {
innerA.run();
}
}
public class Test2 {
public static void main(String[] args) {
Tool.toolMethod(new A());
Tool.toolMethod(new InnerA() {
@Override
public void run() {
System.out.println("**************");
}
@Override
public void test() {
}
});
}
}
class A implements InnerA {
@Override
public void run() {
}
@Override
public void test() {
}
}