JavaSE---内部类

1、概述

　　　　1.1　　内部类：一个类定义在其他类的内部，这个类被称为内部类；

　　　　　　　内部类可以放在外部类的任何位置；

　　　　1.2、语法

public class Test {

    修饰符 class 内部类类名{

    }
}

2、内部类访问特点

　　　　内部类可以直接访问外部类的成员，包括私有

　　　　外部类想访问内部类的成员，必须创建对象

3、根据内部类存放的位置，分为

　　　　成员内部类 ：　　　　

package com.an.innerclass.memberinnerclass;

public class Outer {

    private int age=18;
    private static String name="jack";
    String job="teacher";

    public void say(){
        System.out.println("Outer say...");
    }

    private MemberInnerClass memberInnerClass=null;
    public MemberInnerClass getMemberInnerClass(){
        if (null==memberInnerClass){
            memberInnerClass=new MemberInnerClass();
        }
        return memberInnerClass;
    }

    /**
     * 位置：作为外部类的成员
     * 成员内部类 可以 访问 外部类的所有成员属性、成员方法（包括 private、static）
     *
     */
    public class MemberInnerClass{

        void useOuter(){
            System.out.println(age);
            System.out.println(name);
            System.out.println(job);
            //如果 成员内部类 拥有的成员变量或方法 与 外部类同名时，默认访问的 是成员内部类的成员
            say();
            //如果 成员内部类 拥有的成员变量或方法 与 外部类同名时，要访问外部类成员，需要使用 外部类.this.成员方法｜成员变量
            Outer.this.say();
        }

        void say(){
            System.out.println("MemberInnerClass say...");
        }

    }
}

class Test{
    public static void main(String[] args) {
        //外部类  访问  内部类 的成员  只能创建 内部类对象，再由 内部类对象 访问 内部类成员
        //第一种方式：
        Outer.MemberInnerClass memberInnerClass=new Outer().new MemberInnerClass();
        memberInnerClass.useOuter();

        //第二种方式：
        Outer.MemberInnerClass memberInnerClass1=new Outer().getMemberInnerClass();
    }
}

javac编译Outer.java

public class Outer {
    private int age = 18;
    private static String name = "jack";
    String job = "teacher";
    private Outer.MemberInnerClass memberInnerClass = null;

    public Outer() {
    }

    public void say() {
        System.out.println("Outer say...");
    }

    public Outer.MemberInnerClass getMemberInnerClass() {
        if (null == this.memberInnerClass) {
            this.memberInnerClass = new Outer.MemberInnerClass();
        }

        return this.memberInnerClass;
    }

    public class MemberInnerClass {
        public MemberInnerClass() {
        }

        void useOuter() {
            System.out.println(Outer.this.age);
            System.out.println(Outer.name);
            System.out.println(Outer.this.job);
            this.say();
            Outer.this.say();
        }

        void say() {
            System.out.println("MemberInnerClass say...");
        }
    }
}

public class Outer$MemberInnerClass {
    public Outer$MemberInnerClass(Outer var1) {
        this.this$0 = var1;
    }

    void useOuter() {
        System.out.println(Outer.access$000(this.this$0));
        System.out.println(Outer.access$100());
        System.out.println(this.this$0.job);
        this.say();
        this.this$0.say();
    }

    void say() {
        System.out.println("MemberInnerClass say...");
    }
}

class Test {
    Test() {
    }

    public static void main(String[] var0) {
        Outer var10002 = new Outer();
        var10002.getClass();
        MemberInnerClass var1 = new MemberInnerClass(var10002);
        var1.useOuter();
        MemberInnerClass var2 = (new Outer()).getMemberInnerClass();
    }
}

　　　　局部内部类：

　　　　　　定义在方法中，仅在方法中有效；

　　　　　　不能使用任何修饰符，也不能用static修饰；

package com.an.innerclass.partinnerclass;

public class Outer {

    private String name="jack";
    private static int age=18;

    public void say(){
        /**
         * 局部内部类 不能有 public、protected、private 以及 static 修饰符的
         *
         * 外部如何使用局部内部类 ：
         *      外部类对象.外部类成员方法.内部类对象.内部类成员方法
         */
        class PartInnerClass{
            public void show(){
                System.out.println(name);
                System.out.println(age);
            }
        }


        new PartInnerClass().show();
    }
}
class Test{
    public static void main(String[] args) {
        new Outer().say();
    }
}

javac编译Outer.java

public class Outer {
    private String name = "jack";
    private static int age = 18;

    public Outer() {
    }

    public void say() {
        class PartInnerClass {
            PartInnerClass() {
            }

            public void show() {
                System.out.println(Outer.this.name);
                System.out.println(Outer.age);
            }
        }

        (new PartInnerClass()).show();
    }
}

class Outer$1PartInnerClass {
    Outer$1PartInnerClass(Outer var1) {
        this.this$0 = var1;
    }

    public void show() {
        System.out.println(Outer.access$000(this.this$0));
        System.out.println(Outer.access$100());
    }
}

class Test {
    Test() {
    }

    public static void main(String[] var0) {
        (new Outer()).say();
    }
}

　　　　匿名内部类：

　　　　　　　　　　　　　　　　　　a,　　只使用一次；

　　　　　　　　　　　　　　　　　　b,　　语法：

　　　　　　　　　　　　　　　　　　　　　　　　new 父类构造器(实参) | 实现接口(){ }

　　　　　　　　　　　　　　　　　　c,　　必须继承一个父类（最多一个）或实现一个接口（最多一个）；

　　　　　　　　　　　　　　　　　　d,　　不能定义构造器，但可以有初始化块；

　　　　　　　　　　　　　　　　　　e,　　不能是抽象类；

package com.an.innerclass.nonameinnerclass;

public interface NonameInnerClass {
    void say();
}

class Test{
    public static void main(String[] args) {
        /**
         * 匿名内部类 不能有访问修饰符和 static 修饰符
         *
         * 位置：参数
         */
        say(new NonameInnerClass() {
            public void say() {
                System.out.println("NonameInnerClass say...");
            }
        });
    }

    public static void say(NonameInnerClass nonameInnerClass){
        nonameInnerClass.say();
    }
}

javac编译Outer.java

public interface NonameInnerClass {
    void say();
}

class Test {
    Test() {
    }

    public static void main(String[] var0) {
        say(new NonameInnerClass() {
            public void say() {
                System.out.println("NonameInnerClass say...");
            }
        });
    }

    public static void say(NonameInnerClass var0) {
        var0.say();
    }
}

final class Test$1 implements NonameInnerClass {
    Test$1() {
    }

    public void say() {
        System.out.println("NonameInnerClass say...");
    }
}

　　　　匿名内部类实质：

　　　　　　创建一个实现接口的类，重写方法；

　　　　静态内部类：

package com.an.innerclass.staticinnerclass;

public class Outer {

    private String name="rose";
    static String job="teacher";

    /**
     * 静态内部类 static修饰
     *      不能访问外部类非static成员
     *
     *      不依赖于外部类对象，直接使用new Outer.StaticInnerClass()
     */
    public static class StaticInnerClass{

        public void say(){
            System.out.println(job);
        }
    }
}

class Test{
    public static void main(String[] args) {
        Outer.StaticInnerClass staticInnerClass =new Outer.StaticInnerClass();
        staticInnerClass.say();
    }
}

javac编译Outer.java

public class Outer {
    private String name = "rose";
    static String job = "teacher";

    public Outer() {
    }

    public static class StaticInnerClass {
        public StaticInnerClass() {
        }

        public void say() {
            System.out.println(Outer.job);
        }
    }
}

public class Outer$StaticInnerClass {
    public Outer$StaticInnerClass() {
    }

    public void say() {
        System.out.println(Outer.job);
    }
}

class Test {
    Test() {
    }

    public static void main(String[] var0) {
        StaticInnerClass var1 = new StaticInnerClass();
        var1.say();
    }
}

　　　　　　静态内部类不依赖外部类；

4、使用内部类

　　　　a, 外部类中使用内部类

　　　　b, 外部类以外使用内部类

　　　　　　非静态内部类：

　　　　　　　　声明变量： OuterClass.InnerClass 变量名 ;

　　　　　　　　实例化： OuterInstance.new InnerConstructor() ;

Outer.MemberInnerClass memberInnerClass=new Outer().new MemberInnerClass();

public class Outer$MemberInnerClass {
    public Outer$MemberInnerClass(Outer var1) {
        this.this$0 = var1;
    }

    void useOuter() {
        System.out.println(Outer.access$000(this.this$0));
        System.out.println(Outer.access$100());
        System.out.println(this.this$0.job);
        this.say();
        this.this$0.say();
    }

    void say() {
        System.out.println("MemberInnerClass say...");
    }
}

　　　　　静态内部类：

　　　　　　声明变量： OuterClass.InnerClass 变量名 ;

　　　　　　实例化： new OuterClass.InnerConstructor() ;

Outer.StaticInnerClass staticInnerClass =new Outer.StaticInnerClass();


public class Outer$StaticInnerClass {
    public Outer$StaticInnerClass() {
    }

    public void say() {
        System.out.println(Outer.job);
    }
}

posted on 2019-03-04 10:32 anpeiyong 阅读(121) 评论(0) 收藏举报

刷新页面返回顶部

行者

JavaSE---内部类

导航

公告