【Class类概念】内部类，匿名类，嵌套类等解释的清晰不，铁子！

 
愿你如阳光，明媚不忧伤。

1. 嵌套类（Nested）

定义在类（包括接口）里面的类称为嵌套类。嵌套类是可以有层次的，也就是说嵌套类里面还可以定义类，成为嵌套类中的嵌套类。嵌套类分为两种：静态嵌套类和非静态嵌套类，非静态嵌套类就是内部类（inner class）。

1.1 静态嵌套类（static）

1. 静态类不能访问外部类的非静态成员和非静态方法，不管是public还是private的；
2. 静态类的实例不需要先实例化外部类成员，可直接实例化。

1.2 非静态嵌套类（non-static）

非静态嵌套类才是内部类，也就是说嵌套类包含内部类。

关系图：

 

1.2.1 内部类（inner）

内部类包括：成员类、局部类、匿名类。

1. 内部类中不能有静态修饰的成员（比如块、字段、方法、接口等），但可以有静态常量public static final int a = 6;
2. 内部类可以访问外部类任何成员，不管是公有的还是私有的，静态的还是非静态的；
3. 内部类命名格式：外部类名称+$+[该种类同名类中该类顺序]+[内部类名称]
   成员类：com.it.god.OuterClass$MemberClass；
   成员类不能同名，因此没有顺序
   局部类：com.it.god.OuterClass$1LocalClass；
   匿名类：com.it.god.OuterClass$1。
   匿名类没有名称，但可以有顺序

• 成员类（Member）

成员类算是最常见最常用的一种内部类，我们一般说的内部类说的就是成员类：在类里面，但不在块、构造器、方法里面。

public class ClassRelationship {
    // 成员类
    class MemberClass {
    }

    // 静态成员类
    public static class StaticMemberClass {
    }

    public static void main(String[] args) {
		// 实例化成员类时需要加上外部类限定
        MemberClass c1 = new ClassRelationship().new MemberClass();
        System.out.println(c1.getClass().getSimpleName() + "是成员类？\t" + c1.getClass().isMemberClass());
        System.out.println(c1.getClass().getSimpleName() + "是匿名内部类？\t" + c1.getClass().isAnonymousClass());
        System.out.println(c1.getClass().getSimpleName() + "是局部类？\t" + c1.getClass().isLocalClass());
        System.out.println(c1.getClass().getSimpleName() + "是合成类？\t" + c1.getClass().isSynthetic());

    }

}

-----------------------------------------------------------------
・【CONSOLE】实行结果
	MemberClass是成员类？		true
	MemberClass是匿名内部类？	false
	MemberClass是局部类？		false
	MemberClass是合成类？		false

 

• 局部类（Local）

在块、构造器以及方法内的类，这里的块包括普通块和静态块，可以同名，局部类只在本块范围内有效。

public class ClassRelationship {

    // 块内局部类
    {
        class LocalClass {
        }
    }

    // 静态块内局部类
    static {
        class LocalClass {
        }
    }
    
    // 构造器内局部类
    public ClassRelationship() {
        class LocalClass {
        }
    }

    public static void main(String[] args) {

        // 方法内局部类
        class LocalClass {
        }

        LocalClass c2 = new LocalClass();
        System.out.println(c2.getClass().getSimpleName() + "是成员类？\t" + c2.getClass().isMemberClass());
        System.out.println(c2.getClass().getSimpleName() + "是匿名内部类？\t" + c2.getClass().isAnonymousClass());
        System.out.println(c2.getClass().getSimpleName() + "是局部类？\t" + c2.getClass().isLocalClass());
        System.out.println(c2.getClass().getSimpleName() + "是合成类？\t" + c2.getClass().isSynthetic());

    }

}

-----------------------------------------------------------------
・【CONSOLE】实行结果
	LocalClass是成员类？		false
	LocalClass是匿名内部类？	false
	LocalClass是局部类？		true
	LocalClass是合成类？		false

 

• 匿名类（Anonymous）

就是没有名称的类，其名称由Java编译器给出。，一般是形如：外部类名称+$+匿名类顺序，没有名称也就是其他地方就不能引用，不能实例化，只用一次，当然也就不能有构造器。匿名类根据位于地方不同分为：成员匿名类和局部匿名类。使用匿名内部类的前提是该内部类必须是一个类或接口的的子类。

public class ClassRelationship {

    // 成员匿名类
    Anonymous a = new Anonymous() {

        @Override
        public void play() {
            System.out.println("Member-AnonymousClass");

        }
    // 注意：这里一定要加上分号，因为整个过程其实是在创建匿名内部类对象 创建对象需要语句需要分号来结束
    };

    public static void main(String[] args) {
        // 局部匿名类
        Anonymous a = new Anonymous() {

            @Override
            public void play() {
                System.out.println("Local-AnonymousClass");
            }
        // 注意：这里一定要加上分号，因为整个过程其实是在创建匿名内部类对象 创建对象需要语句需要分号来结束
        };
        a.play();

        System.out.println(a.getClass().getSimpleName() + "是成员类？\t" + a.getClass().isMemberClass());
        System.out.println(a.getClass().getSimpleName() + "是匿名内部类？\t" + a.getClass().isAnonymousClass());
        System.out.println(a.getClass().getSimpleName() + "是局部类？\t" + a.getClass().isLocalClass());
        System.out.println(a.getClass().getSimpleName() + "是合成类？\t" + a.getClass().isSynthetic());

    }

}

interface Anonymous {
    public abstract void play();

}

-----------------------------------------------------------------
・【CONSOLE】实行结果
	Local-AnonymousClass
	是成员类？		false
	是匿名内部类？	true
	是局部类？		false
	是合成类？		false

 

---

2. 合成类（Synthetic）

由Java编译器引入，并且在源代码中没有相应构造方法的结构体被认为是合成类。是不能用代码进行控制的类。合成构造使Java编译器能够在不改变JVM的情况下实现新的Java语言特征。我们不必去关心它。

我用eclipse做实验没有成功 → 传送门

 

---

【每日一面】

如何使用内部类？

使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。可以使用内部类继承某个具体的或抽象的类，间接解决类无法多继承引起的一系列问题。
成员内部类：可以调用外部所有信息，包括被private修饰的信息，作为成员存在，可以被任意权限修饰符修饰。
静态内部类：只能访问外部静态的信息，一般不用。
方法内部类：可以随意访问外部的所有信息，但是无法修改。无法创建静态信息，因为方法结束后，内存需要释放。
匿名内部类：和局部类访问规则一样，避免了只是用对象一次却建立了这个对象的繁琐过程。最常见的方式就是回调模式的使用，通过默认实现一个接口创建一个匿名类，然后new这个匿名类的实例。
成员内部类和匿名内部类用处多一些

// Outer类继承了ClassA，实现了IFunctionA
public class Outer extends ClassA implements IFunctionA{ 

	// Inner类继承了ClassB，实现了IFunctionB
	public class Inner extends ClassB implements IFunctionB{
	
	} 
	
}