Java学习笔记 内部类

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();//只能调用一个方法
    }
}