day18 内部类

一、本类用作测试内部类的入门案例

package cn.sk.innerclass;

public class TestInner1 {
    public static void main(String[] args) {
        //3.创建内部类对象,使用内部类资源
        /**外部类名.内部类名 对象名 = 外部类对象.内部类对象*/
        Outer.Inner oi = new Outer().new Inner();
        oi.delete();
        System.out.println(oi.sum);
        //4.调用外部类的方法--这样是创建了一个外部类的匿名对象,只使用一次
        new Outer().find();
    }
}
//1.创建外部类 Outer
class Outer {
    String name;
   private int age;

    //1.2创建外部类的成员方法
    public void find() {
        System.out.println("Outer...find()");
        //6.测试外部类如何使用内部类的资源
        //System.out.println(sum);--不能直接使用内部类的属性
        //delete();--不能直接调用内部类的方法
        /**外部类如果想要使用内部类的资源,必须先创建内部类对象
         * 通过内部类对象来调用内部类的资源*/
        Inner in = new Inner();
        System.out.println(in.sum);
        in.delete();
    }
    //2.创建内部类--类的特殊成员

    /**
     * 根据内部类位置不同,分为：成员内部类(类里方法外),局部内部类(方法里)
     */
    class Inner {
        //2.1定义内部类的成员变量
        int sum = 10;

        //2.2定义内部类的成员方法
        public void delete() {
            System.out.println("Inner...delete()");
            //5.测试内部类是否可以使用外部类的资源
            /**结论：内部类可以直接使用外部类的资源,私有成员也可以！*/
            System.out.println(name);
            System.out.println(age);
            /**注意：此处测试完毕需要注释掉,否则会来回调用
             * 会抛出异常StackOverFlowExcepton栈溢出异常*/
            //find();
        }
    }
}

二、本类用来测试成员内部类被private修饰成员内部类被private修饰以后,无法被外界直接创建对象使用所以可以创建外部类对象,通过外部类对象间接访问内部类的资源

package cn.sk.innerclass;

public class TestInner2 {
    public static void main(String[] args) {
        /**如何使用内部类资源呢?*/
        //4.可以创建内部类Inner2的对象进行资源访问
        //Outer2.Inner2 oi2 = new Outer2().new Inner2();
        //oi2.eat();
        /**如果Inner2被private修饰,无法直接在外部创建对象,怎么办？*/
        //7.我们可以通过外部类对象,间接访问私有内部类的资源

        new Outer2().getInner2Eat();
    }
}
//1.创建外部类Outer2
class Outer2{
    //6.提供外部类公共的方法,在方法内部创建私有内部类的对象并调用内部类
    public void getInner2Eat(){
        Inner2 in = new Inner2();//外部类中创建内部类对象
        in.eat();
    }
    //2.创建成员内部类Inner2
    /**成员内部类的位置：类里方法外*/
    //5.将成员内部类被private修饰--私有化,只能在本类中访问,外部无法访问
        private class Inner2{
        //3.创建一个普通方法eat()
        public void eat(){
            System.out.println("Inner2...eat()");
        }
    }
}

三、本类用来测试成员内部类被static修饰

 

package cn.sk.innerclass;
/**本类用来测试成员内部类被static修饰*/
public class TestInner3 {
    public static void main(String[] args) {
        /**如何访问内部类的show()呢？*/
        //4.创建内部类对象并访问show（）
        //方式一：按照之前的方式,创建内部类对象并调用show（）
        //Outer3.Inner3 oi3 = new Outer3().new Inner3();
        //oi3.show();
        //方式二：创建匿名内部类对象来访问show（）
        //new Outer3().new Inner3().show();
        /**现象：用static修饰成员内部类后
         *  new Outer3().new Inner3()报错*/
        //6.用static修饰成员内部类以后上面创建的语句都报错了
        /**我们可以通过外部类类名直接创建内部类对象,无须创建外部类对象了*/
        Outer3.Inner3 oi  = new Outer3.Inner3();
        oi.show();
        //7.匿名内部类对象调用show()
        new Outer3.Inner3().show();
        //9.访问静态内部类中的静态资源--链式加载

        Outer3.Inner3.show2();
    }
}
//1.创建外部类Outer3
class Outer3{
    //2.创建成员内部类Inner3
    //5.内部类被static修饰--并不常用！！！浪费内存！
    static class Inner3{
        //3.创建普通成员方法
        public void show(){
            System.out.println("Inner3...show()");
        }
        //8.创建静态成员内部类中的静态成员方法
        static public void show2(){
            System.out.println("Inner3...show2()");
        }
    }
}

四、本类用来测试局部内部类

package cn.sk.innerclass;
public class TestInner4 {
    public static void main(String[] args) {
        /**如何使用内部类的志愿呢？
         * 注意：直接调用外部类的show()是无法触发内部类的
         * 需要在外部类中创建内部类对象并且进行调用,才能触发内部类的功能*/
        //5.创建外部类对象调用show()
        //7.当在外部类show()中创建局部内部类对象,并调用bye()时
        //局部内部类的功能才会被触发,否则不会执行,可回退到第五步进行测试
        new Outer4().show();
    }
}
//1.创建外部类
class Outer4{
    /**局部内部类的位置：方法里*/
    //2.创建外部类的成员方法
    public void show(){
        //3.创建局部内部类Inner4--不太常用！！！
        class Inner4{
            //4.创建局部内部类的普通属性与方法
            String name;
            int age;
            public void bye(){
                System.out.println("Inner4...bye()");
            }
        }
        //6.在show()里创建局部内部类对象
        Inner4 in = new Inner4();
        System.out.println(in.age);
        System.out.println(in.name);
        in.bye();
    }
}

五、本类用于测试匿名内部类,没有名字,通常结合着匿名对象一起使用

package cn.sk.innerclass;

import static java.lang.System.out;

/**本类用于测试匿名内部类,没有名字,通常结合着匿名对象一起使用*/
public class TestInner5 {
    /**接口可以创建对象的吗？不可以！！！*/
    //new Inner1（）;//接口不能创建对象
    //3.new Inner1()匿名对象
    //以前我们创建了一个接口,接口不能实例化
    // 就相当于创建了一个接口实现类+重写接口中的抽象方法+创建实现类对象+调用方法
    /**就相当于创建了一个接口的实现类+重写接口中的所有抽象方法*/
    public static void main(String[] args) {
        new Inner1() {
            @Override
            public void save() {//3.2重写接口中的抽象方法1
                out.println("我是Inner1接口的save()");
            }

            @Override
            public void get() {//3.2重写接口中的抽象方法2
                out.println("我是Inner1接口的get()");
            }
        }.get();//3.3触发指定的重写后的方法,只能调用一个,并且只能调用一次
        /**注意！！！匿名对象只使用一次,而且一次只能干一件事！！！！*/
        //5.new Inner2()匿名对象,相当于创建了抽象类的普通子类
        /**匿名内部类实现的方法都是抽象方法,注意是所有抽象方法*/
        new Inner2() {
            @Override
            public void drink() {
                out.println("我是Inner2抽象类的drink()");
            }
        }.drink();
        //7.普通类的匿名对象,不会强制要求产生匿名内部类的重写方法
        //如果使用对象,只需要干一件事--可以直接创建匿名对象,简单又方便
        new Inner3().power();
        //如果想使用同一个对象来干很多件事情,必须要给对象其名字

        Inner3 i3 = new Inner3();
        i3.power();
        i3.study();
        i3.study();
        i3.study();

    }

}

//1.创建接口
interface Inner1{
    //2.定义接口中的抽象方法
    void save();
    void get();
}
//4.创建抽象类
abstract class Inner2{
    public void play(){
        out.println("我是Inner2抽象类中的普通方法play()");
    }
    abstract public void drink();
}
//6.创建普通类Inner3
class Inner3{
    public void power(){
        out.println("我们会越来越强的,光头强");
    }
    public void study(){
        out.println("什么都阻挡不了我学习的脚步");
    }
}