内部类的使用 InnerClass

1、内部类总结

/**
 *  内部类的位置
 *  1、Java中允许将一个类 A 生命在一个类B中 则类A称为内部类  类B 称为外部类
 *  2、成员内部类(分为 静态  和 非静态) 2、局部内部类（方法内,形参，代码块内，构造器内）
 *
 *  3、成员内部类能干什么
 *    一方面 作为一个 类
 *        > 可以有 属性 方法 构造器
 *        > 可以有final 修饰 不能 被继承
 *        > 可以 被 abstract修饰
 *     一方面 作为一个外部类的成员
 *       >可以和外部类的方法 一样调用 外部类的 属性 方法 (非静态的)
 *          这里要注意属性重名和不重名的使用方式
 *       >内部类可以 被四种权限修饰符修饰
 *
 * 4、开发中怎么使用内部类
 *    4.1 如何实例化 内部类（注意静态和非静态的 区别）
 *    4.2 如何在成员内部类中如何调用外部类的 结构
 *    4.3 开发中常用的 内部类使用的方式有那些。
 * 5、局部内部类常见的使用方式
 *    5.1 返回一个匿名对象
 *    5.2 返回一个匿名类的匿名对象
 *    5.3 使用Lambda表达式返回一个匿名类的匿名对象
 *
 * 5、外部类被加载的时候 内部类不一定会立即加载 （内部类主动调用的时候加载）
 *    5.1 可以使用静态代码块的方式测试
 *
 *
 */

 

2、成员内部类之非静态内部类

2.1 代码示例

//成员内部类的
public class Persion {
        String name = "小明";
        int age = 20;
        public void eat() {
            System.out.println("人吃饭");
        }
        //非静态内部类
        class Bird {
            private String name = "dujuan";
            public void sing() {
                System.out.println("唱歌");
                Persion.this.eat(); //调用外部类的非静态属性(方法)
                //这里的age 直接调用的是外部类的非静态属性
                System.out.println(age);
            }
            //因为name 有 三个,该方法中调用不同位置的属性使用方式不一样。
            public void  fly(String name){
                //调用形参的属性
                System.out.println(name);
                //内部类bird类的name
                System.out.println(this.name);
                //调用外部类的非静态属性
                System.out.println(Persion.this.name);
            }
        }
}

 

　　

2.2 成员内部类之非静态内部类测试

//成员内部类的实例化方式
public class InnerClassTest {
    public static void main(String[] args) {
        Persion persion = new Persion();

        //创建Bird非静态的内部类
        Persion.Bird bird = new Persion().new Bird();

        bird.sing();
        bird.fly("黄鹂");
    }
}

 

 

 

3、成员内部类之静态内部类

3.1 代码示例

//成员内部类的
public class Persion {
        String name = "小明";
        int age = 20;
        public void eat() {
            System.out.println("人吃饭");
        }
        //静态内部类
        static class Dog {
            private String name;
            public final static String SEAON = "AUTOMU";

            public void show() {
                System.out.println("卡拉是条狗");
            }
            static {
                System.out.println("内部类 被加载");
            }
        }
}

 

3.2 成员内部类之静态内部类测试

//成员内部类的实例化方式
public class InnerClassTest {

    public static void main(String[] args) {

        Persion persion = new Persion();

        //创建Dog 静态内部类
        Persion.Dog dog = new Persion.Dog();
        dog.show();


    }
}

 

4、局部内部类

4.1 代码示例

/**
 * 局部内部类
 */
public class JuBuInnerClass {

    //比较少的使用方式---> 方法中声明一个类
    public void method(){
        //局部内部类
        class AA{

        }
    }


   //这样的使用方式比较多
   public Comparable getComparable(){
        //创建一个实现Comparable的类 局部内部类 方式一 比较标准的方式
         class MyComparable implements  Comparable{

             @Override
             public int compareTo(Object o) {
                 return 0;
             }
         }
         //返回一个匿名对象
         return  new MyComparable();
   }

    //这样的使用方式比较多 局部内部类 方式二  返回一个匿名类的匿名对象
    public Comparable getComparable1(){
        int s = 20;

        //返回一个实现Comparable接口的匿名类的匿名对象
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }

    //这样的使用方式比较多 局部内部类 方式三  采用lambda表达式
    public Comparable getComparable2(){
        int s = 20;
        return (o -> {
            int s1 = (int) o;

            return s1 - s;
        });
    }


}

 

4.2 局部内部类的测试　

public class JuBuInnerClassTest {
    public static void main(String[] args) {
        JuBuInnerClass juBuInnerClass = new JuBuInnerClass();


        Comparable comparable = juBuInnerClass.getComparable2();

        Integer res = comparable.compareTo(23);

        System.out.println(res);

    }


}