package cn.itcast.demo03;
//外部类
public class Body {
    //内部类
    public class Heart{
        //内部类方法
        public void beat(){
            System.out.println("心脏跳动");
            System.out.println("My name is "+name);//正确，调用外部类的private成员
        }
    }
    private String name;//外部类成员变量
    public void methodBody(){
        System.out.println("外部类方法");
        Heart heart = new Heart();
        heart.beat();//调用内部类方法
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package cn.itcast.demo03;
/*内部类:一个类内部包含另外一个类，此类不能独立存在 分类： 1.成员内部类 2.局部内部类（包含匿名内部类） 成员内部类： 修饰符 class 类名称 { 修饰符 class 类名称 { // } // } 注意：内部类使用外部类可以随意访问，外部类用内需要借助内部类对象 * */
public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();
        body.methodBody();//用外部类对象调用内部类，间接方法
        System.out.println("==============");
        //直接方式 外.内
        Body.Heart heart = new Body().new Heart();
        heart.beat();

    }
}

重名成员变量

package cn.itcast.demo03;

public class Outer {
    int num = 10;//外部类成员变量
    public class Inner{
        int num = 20;//内部类成员变量
        public void methodInner(){
            int num = 30;//内部类方法的局部变量
            System.out.println(num);//30
            System.out.println(this.num);//20
            System.out.println(Outer.this.num);//10
        }
    }
}


package cn.itcast.demo03;

public class InnerClass {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.methodInner();
    }
}

package cn.itcast.demo04;

public class Outer {
    public void methodOuter(){
        class Inner{//局部内部类 ,只能被外部方法调用
            int num = 10;
            public void methodInner(){
                System.out.println(num);//10
            }
        }
        Inner inner = new Inner();
        inner.methodInner();
    }
}

package cn.itcast.demo04;

public class DemoMain {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.methodOuter();
    }

}

package cn.itcast.demo04;
/*局部内部类若想访问所在方法的局部变量，那么这个局部变量必须是有效final的*/
public class MyOuter {
    public void methodOuter(){
        int num = 10;//不写final但是不能再变
        class MyInner{
            public void methodInner(){
                System.out.println(num);
            }
        }
    }
}

匿名内部类

package cn.itcast.demo05;

public interface MyInterface {
    void method1();//抽象方法
    void method2();
}

package cn.itcast.demo05;

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void method() {
        System.out.println("封盖了匿名方法1！");
    }

    @Override
    public void method2() {
        System.out.println("封盖了匿名方法2！");
    }
}

package cn.itcast.demo05;
/*若接口的实现类或者父类的子类只需要使用唯一的一次 * 那么这种情况下可以省略该类的定义改为使用匿名内部类 * * 接口名称 对象名 = new 接口名称(){...};//error * 格式解析:new代表创建对象的动作，接口名称是内部类需要实现哪个接口, {...}是内部类的内容 * 注意： * 匿名内部类在创建对象的时候只能使用唯一一次 若希望使用多次还是定义实现类 *匿名对象在调用方法时只能调用唯一一次，若希望同一对象调用多次方法必须给对象起名字 * */
public class DemoMain {
    public static void main(String[] args) {
// MyInterfaceImpl impl = new MyInterfaceImpl();
// impl.method();

        //MyInterface some = new Myinterface();//error
        //匿名内部类
        MyInterface obj = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现类方法1");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类实现类方法2");
            }
        };
        obj.method1();//匿名内部类实现类方法
        obj.method2();
        System.out.println("==================");
        //使用内部类且省略对象名称,也是匿名对象
        new MyInterface(){
            @Override
            public void method1() {
                System.out.println("匿名内部类实现类方法1");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类实现类方法2");
            }
        }.method2();//只能调用一个方法
    }
}