内部类分类介绍JAVA224-225

package com.test.nestedclass;
/**
* 测试内部类的基本定义方式
*/
public class Demo01 {
//静态内部类
private static class StaticNestedClass{
}

//普通内部类(成员内部类)
private class FieldInnerClass{
}

void sayHello(){
//方法内部类(局部内部类)
class LocalClass{
}

//匿名内部类。放到方法外面也可以，只是类型不一样了(不同位置不同类型)。
Runnable runnable = new Runnable() {//两个作用：定义了匿名内部类的类体；创建了匿名内部类的一个实例！
@Override
public void run() {
}
};
}
}

package com.test.nestedclass;

import com.test.nestedclass.Outer02.StaticInnerClass;
/**
* 测试静态内部类的详细用法
*/
public class Demo02{
public static void main(String[] args) {
//这样写比较明显，看得出外部类
Outer02.StaticInnerClass osic = new Outer02.StaticInnerClass();

//在不相关类(Demo02)中，可直接创建静态内部类的对象(不需要通过所在外部类(Outer02))
//      StaticInnerClass osic2 = new StaticInnerClass();//import com.test.nestedclass.Outer02.StaticInnerClass;
}
}

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

void t1(){
StaticInnerClass sic = new StaticInnerClass();
}
//静态内部类
/*private*/ static class StaticInnerClass {
int a = 3;
static int b = 5;//可包含静态成员、非静态成员

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

package com.test.nestedclass;
/**
* 测试成员内部类的详细用法
*/
public class Demo03 {
public static void main(String[] args) {
Outer03 out = new Outer03();
Outer03.InnerClass ic = out.new InnerClass();//先有外部类对象，才可创建内部类对象
ic.test();
}
}

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

public void t1(){
InnerClass ic = new InnerClass();//方法内可直接创建内部类对象
}
//成员内部类，相当于外部类的成员变量，可访问外部类的所有成员
class InnerClass{
int c = 1;
//成员内部类不能有静态成员，除非声明为final，并且只能是编译器可以确定值的常量表达式
final static int d = 80;
//      final static Date d2 = new Date();

//如果成员内部类可以有静态成员，如下：
//      static InnerClass ab = new InnerClass();
//则Outer03.InnerClass.ab可以直接获取内部类对象，这时成员内部类对象就完全脱离了外部类的控制！与设计成员内部类的初衷完全不一致！

void test(){
System.out.println(a);
//方法内
System.out.println("内部类对象：" + this);//成员内部类对象的创建。必须先有外部类对象！
System.out.println("外部类对象：" + Outer03.this);//引用了外部类的对象！
}
}
}

package com.test.nestedclass;
/**
* 测试方法内部类(局部内部类)
*/
public class Demo04 {
public static void main(String[] args) {
}
}

class Outer04{

public void test(){
/*final*/ int a = 3;

class Inner{
int b = 10;
//      static int c = 20;//方法内部类中只能定义非静态成员

void t1(){
System.out.println(b);
//              System.out.println(a);
//方法内部类中不能引用所在方法的普通局部变量，除非是常量。原因如下：
//方法的生命周期和方法内部类对象的生命周期不一致！方法执行完，内部类对象可能仍然存在！
}
}
}
}

package com.test.nestedclass;
/**
* 测试匿名内部类
*/
public class Demo05 {
public static void main(String[] args) {
Outer05 outer = new Outer05();
outer.test();
}
}

class Outer05{
public void test02(Car car){
car.run();
}

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

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

test02(new Car(){
@Override
public void run() {
System.out.println("参数式匿名内部类，车在跑！");
}
});
}
}

class Car{
public void run(){
System.out.println("汽车跑！");
}
}