内部类

内部类介绍

内部类（Nested Class） 嵌套类

静态内部类

非静态内部类

普通内部类（也称为成员内部类）

在一个类（外部类）中直接定义的内部类

匿名内部类

方法内部类

在一个方法（外部类的方法）或代码块中定义的内部类

内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号

内部类可以使用修饰符（public,protected,default,private）

内部类作用：

1、内部类可以方便使用外部类成员

2、内部类存是为了辅助外部类完成功能

例1：

/**
* 测试内部类基本定义方式
* @author qjc
*/
public class Demo01 {

//静态内部类
private static class StaticNestedClass{}

//普通内部类（成员内部类）
private class FieldInnerClass{}

void sayHello(){

//方法内部类
class LocalClass{}

/**
* 匿名内部类
* 两个作用：
*         1、定义匿名内部类实体
*         2、创建了匿名内部类的一个实例
*
*/
Runnable runnable = new Runnable(){
@Override
public void run() {
}
};
}
}

编译后class文件：



1、静态内部类

静态内部类可以包含静态成员、非静态成员

静态内部类可以直接调用外部类的静态属性、静态方法。但不能调用外部类的普通属性、普通方法。

在不相关类中，可以直接创建静态内部类的对象（不需要通过所在外部类）

静态内部类实际上和外部类联系很少，也就是命名空间上的联系

例2：

/**
* 静态内部类的使用
* @author qjc
*/
public class Demo02 {
public static void main(String[] args) {
//通常不相关类创建静态内部类方法
Outer02.StaticInnerClass sic = new Outer02.StaticInnerClass();

//不相关类中可以直接创建静态内部类（不推荐）
//import cn.qjc.nested.Outer02.StaticInnerC
StaticInnerClass sic2 = new StaticInnerClass();
}
}

class Outer02{
int c = 5;
static int b = 10;

void test2(){

//            System.out.println(a); //外部类不能调用内部类普通成员
System.out.println(b);

StaticInnerClass sic = new StaticInnerClass();
sic.test();
}

//静态内部类
static class StaticInnerClass{
int a = 3;
static int b = 5;
void test(){
System.out.println(a);

//静态内部类中不能调用外部类的普通成员！
//            System.out.println(c);
}
}
}

2、成员内部类（普通内部类）

成员内部类基本用法：

成员内部类就像一个成员变量一样存在于外部类中。

内部类可以访问外部类的所有成员（包含：private）

成员内部类的this指内部类对象本身，要拿到外部类对象可以使用：外部类.this

成员内部类的对象是一定要绑定到一个外部类的对象上的。因此。创建成员内部类对象时需要持有外部类对象的引用。因此，要先有外部类对象，后有成员内部类对象

成员内部类不能有静态成员

成员内部类对象的创建方式

外部类内部

　　　　　　Inner inner = new Inner()

外部类外部

　　　　　　Inner inner = new Outer().new Inner()

例3：

/**
* 普通内部类
* @author qjc
*/
public class Demo03 {
public static void main(String[] args) {
/**
* 不相关类创建成员内部类
*/
Outer03 out = new Outer03();
Outer03.InnerClass inner = out.new InnerClass();
inner.test();
}
}

class Outer03{
private int a = 3;
int b = 10;

void test2(){
//本类中直接创建成员内部类
InnerClass inner = new InnerClass();
}
//成员内部类
class InnerClass{
/**
* 成员内部类不能有静态成员，
* 除非声明为final
* 并且只能是编译器可以确认值的常量表达式
*/
int c = 5;
//        static int d = 10;//cannot be declared static;
final static int e = 5;
//        final static Date f = new Date();//cannot be resolved to a type

//        static void test2(){} //成员内部类不能有静态方法，

void test(){
System.out.println(a);

System.out.println("内部类对象："+this);//成员内部类对象的创建，必须先有外部类对象
System.out.println("外部类对象："+Outer03.this); //引用外部类的对象
}
}
}

3、方法内部类

方法内部类的地位和方法内的局部变量的位置类似。

因此不能修饰局部变量的修饰符也不能修饰局部内部类，譬如public、private、pritected、static、transient等

方法内部类只能在声明的方法内是可见的

因此定义局部内部类之后，想用的话就要在此方法内直接实例化，记住这里顺序不能反了，一定要先声明后使用，否则编译器会说找不到

方法内部类不能访问定义它的方法内的局部变量，除非这个变量被定义为final

本质原因：局部变量和方法内部类生命周期不一致！

方法内部类只能包含非静态成员！

例4：

/**
* 方法内部类
* @author qjc
*/
public class Demo04 {
public void test(){
int a = 3;
final int a2 = 3;
//方法内部类
class inner{
int b = 10;
//            static int c = 20; //方法内部类中只能定义非静态成员
final static int c2 = 20; //除非是final的

void test2(){
//                System.out.println(a); //方法内部类中不能饮用所在方法的普通局部变量
System.out.println(b); //除非是final的
/**
* 分析：
* 方法生命周期，和方法内部类生命周期不一致
* 方法执行完，内部类对象可能仍然存在
*/
}
}
}
}

4、匿名内部类

匿名内部类基本用法：

匿名内部类的实例化方式：new SomeInterfaceOrClass(){…}

意思是创造一个实现（继承）SomeInterfaceOrClass的类的对象

根据声明位置，判断匿名内部类是成员内部类还是方法内部类

注：一般是方法内部类，这是就具备了方法内部类的特性。

三种使用方法：

继承式

接口式

参数式

例5：

/**
* 匿名内部类定义三种方式
* @author qjc
*/
public class Demo05 {
public static void main(String[] args) {
Outer05 out = new Outer05();
out.test1();
}
}

class Outer05{

public void test1(){
int a = 3;
final int a2 =3;
//匿名内部类（接口式），由于本内部类定义在方法中，际方法内部类
Runnable runnable = new Runnable(){
@Override
public void run() {
}
};

//匿名内部类（继承式）
Car car = new Car(){
@Override
public void run() {
System.out.println("子类的车在跑");
//                System.out.println(a);
System.out.println(a2);
}
};
car.run();

//匿名内部类（参数式）
test2(new Car(){
@Override
public void run() {
System.out.println("参数式匿名内部类");
}
});
}

public void test2(Car car){
car.run();
}
}

abstract class Car{
public void run(){
}
}