内部类：成员内部类，局部内部类，静态内部类，匿名内部类

public class OuterClass {

private String name = "123";
private int  age = 20;
private static char sex ='女';

/**
* 成员内部类
*  1.可以无限制访问外部成员，包括私有的和静态的
*  2.内部类不能含有static的变量或方法；因为含有static修饰的变量或成员在类加载的时候初始化，此时还没有外部类
*      有static修饰的变量或方法只能放在静态内部类中
*  3.外部类访问内部类的成员和方法
*      外部类名.成员内部类名  对象名 = new 外部类名().new 内部类名();
*      对象名.成员
*  4.外部类无法访问内部类的私有属性或方法
*  5.当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。
*      如果要在内部类中访问外部类的同名成员，需要以下面的形式进行访问
*          外部类.this.成员变量
*          外部类.this.成员方法
*  练习：
*  1. 创建一个外部类，含有一个成员变量age=30;
*  2. 创建一个内部类，含有一个内部成员变量age=20；
*  3. 在内部类里创建一个方法，里面有一个局部变量age=10，在这个方法里分别打印值不同的三个age
*  4. 在main方法中，调用内部类的方法
*
*/
class InnerClass{
private char sex ='男';
private int age = 30;
public void print(){
int age = 10;
System.out.println(name);
System.out.println(OuterClass.this.sex);

System.out.println(age);
System.out.println(this.age);
System.out.println(OuterClass.this.age);
}

}

/**
* 2.局部内部类
*  局部内部类，是定义在一个方法或者一个作用域里面的类
*  局部内部类不能被public、protected、private以及static修饰符的。他的作用域被限定在声明这个局部类的块中
*  除了method方法，没有任何方法知道此类的存在
*/
public void method(){

int a = 10;

class InnerClass2{
public void print(){
System.out.println("哈哈哈");
}
}

InnerClass2 inner = new InnerClass2();
inner.print();
}

{
class InnerClass2{

}

}

/**
* 3.静态（嵌套）内部类
* a.成员内部类前加上了static修饰，它不能使用外部类的非static成员变量或者方法
* b.外部类调用该内部类的成员
*      调用静态成员：外部类名.内部类名.静态成员
*      调用非静态成员：new 外部类名.内部类名().非静态成员
*  int age = OutClass1.StaticInnerClass.b;//不需要创建外部类，也不需要创建内部类
int age1 = new OutClass1.StaticInnerClass().a;//调用静态内部类的非静态方法
*
*/
static class InnerClass3{

static int i = 100;
String j = "你好";

public void print(){
System.out.println(sex);
}

}
public void method2(){
System.out.println(OuterClass.InnerClass3.i);
System.out.println(new OuterClass.InnerClass3().j);

}

public static void main(String[] args) {
OuterClass.InnerClass oi = new OuterClass().new InnerClass();
System.out.println(oi.sex);
oi.print();
//System.out.println(OuterClass.this.sex);

OuterClass out = new OuterClass();
out.method();
out.method2();
}

}

/**
* 4. 匿名内部类
* 匿名内部类也就是没有名字的内部类正因为没有名字，所以匿名内部类只能使用一次，
* 它通常用来简化代码编写，但使用匿名内部类还有个前提条件：
* 必须继承一个父类或实现一个接口，但最多只能继承一个父类，或实现一个接口。
* 匿名内部类不能有构造方法。
* 匿名内部类不能定义任何静态成员、方法和类。
* 匿名内部类的本质：是继承了一个类或者实现接口的匿名子类对象
关于匿名内部类还有如下两条规则：
1）匿名内部类不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建内部类的对象。
因此不允许将匿名内部类定义成抽象类。
2）匿名内部类不能定义构造器（构造方法），因为匿名内部类没有类名，所以无法定义构造器，
但匿名内部类可以定义实例初始化块，
匿名内部类的格式：
new 类名或者接口(){
重写或者实现的方法
};
*/

public class NoNameClassDemo {
public static void main(String[] args) {
A a = new Aa();
a.testA();

new A(){
public void testA(){
System.out.println("匿名内部类的aaa");
}
}.testA();

A a1 = new A(){
public void testA(){
System.out.println("匿名内部类的aaa1111");
}
};
a1.testA();

B b= new B(){
public void testB(){
System.out.println("BBBB");
}
};
b.testB();
new B(){
public void testB(){
System.out.println("BBBB");
}
}.testB();

new C(){
public void testC(){
System.out.println("匿名内部类的CCC");
}
}.testC();

}
}

interface A{
public void testA();
}
abstract class B{
abstract  void testB();
}
class C{
public void testC(){
System.out.println("父类的c");
}
}
class Aa implements A{
@Override
public void testA() {
System.out.println("AAA");
}

}