//在A类中申明了一个B类，此B类就在A的内部，并且在成员变量的位置上，所以就称为成员内部类
public class Outer {
private int id;
public void out(){
System.out.println("这是外部类方法");
}
class Inner{
public void in(){
System.out.println("这是内部类方法");
}
}
}

public class Outer {
private int id;
public void out(){
System.out.println("这是外部类方法");
}
class Inner{
public void in(){
System.out.println("这是内部类方法");
}
}
}
public class Test{
public static void main(String[] args) {
//实例化成员内部类分两步
//1、实例化外部类
Outer outObject = new Outer();
//2、通过外部类调用内部类
Outer.Inner inObject = outObject.new Inner();
//测试，调用内部类中的方法
inObject.in();//打印：这是内部类方法
}
}

public class Outer {
private int id;
public void out(){
System.out.println("这是外部类方法");
}
class Inner{
public void in(){
System.out.println("这是内部类方法");
}
//内部类访问外部类私有的成员变量
public void useId(){
System.out.println(id+3);。
}
//内部类访问外部类的方法
public void useOut(){
out();
}
}
}
public class Test{
public static void main(String[] args) {
//实例化成员内部类分两步
//1、实例化外部类
Outer outObject = new Outer();
//2、通过外部类调用内部类
Outer.Inner inObject = outObject.new Inner();
//测试
inObject.useId();//打印3，因为id初始化值为0，0+3就为3，其中在内部类就使用了
外部类的私有成员变量id。
inObject.useOut();//打印：这是外部类方法
}
}

public class MemberInnerClassTest {
private String name;
private static int age;
public void run(){}
public static void go(){}
public class MemberInnerClass{
private String name;
//内部类访问外部类
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(MemberInnerClassTest.this.name);
System.out.println(MemberInnerClassTest.age);
MemberInnerClassTest.this.run();
MemberInnerClassTest.go();
}
}
//外部类访问成员内部类
//成员内部类的对象要 依赖于外部类的对象的存在
public void test(){
//MemberInnerClass mic = MemberInnerClassTest.this.new
MemberInnerClass();
//MemberInnerClass mic = this.new MemberInnerClass();
MemberInnerClass mic = new MemberInnerClass();
mic.name = "tom";
mic.test("hua");
}
public static void main(String[] args) {
//MemberInnerClass mic = new MemberInnerClass();这个是不行的，this是动态的。
//所以要使用要先创建外部类对象，才能使用
MemberInnerClassTest out = new MemberInnerClassTest();
MemberInnerClass mic = out.new MemberInnerClass();
//如果内部类是private,则不能访问，只能通过内部方法来调用内部类
mic.name="jik";
mic.test("kkk");
}
}

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

public class Outer {
private int id;
//在method01方法中有一个Inner内部类，这个内部类就称为局部内部类
public void method01(){class Inner{
public void in(){
System.out.println("这是局部内部类");
}
}
}
}

public class Test {
public static void main(String[] args) {
//讲new出来的Apple实例赋给apple变量保存起来，但是我们只需要用一次，就可以这样写
Apple apple = new Apple();
apple.eat();
//这种就叫做匿名对象的使用，不把实例保存到变量中。
new Apple().eat();
}
}
class Apple{
public void eat(){
System.out.println("我要无了");
}
}

main:
A a = new A(){
//实现A中的抽象方法
//或者重写A中的普通方法
};
注:这个大括号里面其实就是这个内部类的代码,只不过是声明该内部类的同时就是要new创建了其对象,
并且不能反复使用,因为没有名字。
例如:
B是一个接口，依托于B接口创建一个匿名内部类对象
B b = new B(){
//实现B中的抽象方法
};

public class Test {
public static void main(String[] args) {
//如果我们需要使用接口中的方法，我们就需要走3步，1、实现接口 2、创建实现接口类的实
例对象 3、通过对象调用方法
//第二步
Test02 test = new Test02();
//第三步
test.method();
}
}
//接口Test1
interface Test01{
public void method();
}
//第一步、实现Test01接口
class Test02 implements Test01{
@Override
public void method() {
System.out.println("实现了Test接口的方法");
}
}

public class Test {
public static void main(String[] args) {
//如果我们需要使用接口中的方法，我们只需要走一步，就是使用匿名内部类，直接将其
类的对象创建出来。
new Test1(){
public void method(){
System.out.println("实现了Test接口的方法");
}
}.method();
}
}
interface Test1{
public void method();
}