Java拾贝第五天——内部类

Java拾贝不建议作为0基础学习，都是本人想到什么写什么

内部类

在类中可以定义成员变量和方法，而且还可以定义一个类。

一般内部类分为四种：

成员内部类、局部内部类、静态内部类、匿名内部类。

成员内部类

成员内部类就好像成员变量一样，定义在类的内部。

class Out {
    private int num = 10;//成员变量

    private void say() {};//方法

    class In {
	private int x = 0;
        public void tell() {}
    }
}

那么此时，Out类称之为外部类。In类称之为内部类。

内部类作为外部类的内部结构，自然可以访问外部类的私有属性和方法。

public class Test6 {
    public static void main(String[] args) {
        Out out = new Out();
        out.T();

    }
}

class Out {//外部类
    private int num = 10;

    private void say() {
        System.out.println("外部类的私有方法");
    }
    public void T() {//外部类的T方法
        In in = new In();//外部类想要访问内部类需初始化
        in.tell();
    }

    class In {//内部类
        public void tell() {
            num = 5;//可以访问外部类的私有属性
            say();//可以访问外部类的私有方法
            System.out.println(num);
        }
    }
}
/*
外部类的私有方法
5
*/

虽说方法内部执行顺序是从上至下，但类的内部结构是平级。

内部类的实例不能单独存在，需初始化外部类之后再初始化内部类

public class Test6 {
    public static void main(String[] args) {
        Out out = new Out();
        Out.In in = out.new In();
	//Out.In in = new Out().new In();等价
        in.tell();
    }
}
class Out {//外部类
    private int num = 10;

    private void say() {
        System.out.println("外部类的私有方法");
    }
    class In {//内部类
        public void tell() {
            num = 5;//可以访问外部类的私有属性
            say();//可以访问外部类的私有方法
            System.out.println(num);
        }
    }
}
/*
外部类的私有方法
5
*/

内部类属性的访问顺序

public class Test6 {
    public static void main(String[] args) {
        Out.In in = new Out().new In();
        in.tell();
    }
}

class Out {//外部类
    private int i = 10;

    class In {//内部类
        private int i = 20;
        public void tell() {
            int i = 30;
            System.out.println(i);
            System.out.println(this.i);//访问内部类的成员变量
            System.out.println(Out.this.i);//内部类访问外部类的属性/方法的方式
        }
    }
}
/*
30
20
10
*/

局部内部类

局部内部类就好像局部变量，其访问权限也仅限于其作用域内

public class Test6 {
    public static void main(String[] args) {
        Out out = new Out();
        out.tell(15);
    }
}

class Out {//外部类
    private int i = 10;
    public void tell(final int temp) {
        int x = 10;
        class In {//局部内部类 与局部变量类似
            public void say() {
                i = 11;//内部类可以访问外部类私有属性和方法
                x=11;//报错，访问不到x
                System.out.println(i);
                System.out.println(temp);//想要访问形参temp必须加上final
            }
        }
        In in = new In();//在方法内部创建内部类对象并调用其方法。
        in.say();
    }
    public void tell2(){//因为是局部内部类，这里访问不到。
        In in = new In();
        in.say();
    }
}

静态内部类

用static修饰的内部类，只能调用外部类的静态属性或静态方法

public class Test6 {
    public static void main(String[] args) {
        Out.In in = new Out.In();//注意这里没有初始化Out的实例。
        in.tell();
        in.say();//运行过程中会自动修改为  Out.In.say();
        Out.In.say();

    }
}

class Out {//外部类
    private int i = 10;
    private static int j = 11;

    private void T() {
        System.out.println("私有T方法");
    }

    private static void F() {
        System.out.println("静态F方法");
    }

    static class In {//静态内部类
        public void tell() {
            i = 11;//报错，只能访问静态属性
            j = 12;
            T();///报错，只能访问静态方法
            F();
        }
        public static void say() {
            i = 11;///报错，只能访问静态属性
            j = 12;
            T();///报错，只能访问静态方法
            F();
        }
    }
}

因为静态属于类，所以上述代码中静态In类属于外部类Out。

Out.In.say();

可以使用上述代码访问其say方法。

当需要访问静态内部类的非静态方法时：

//非静态方法需要实例调用
Out.In in = new Out.In();
in.tell();

若需要访问静态内部类的静态方法时:

Out.In.say();

匿名内部类

待学习