社区首页 >专栏 >Java——内部类使用总结（基本概念、定义内部类、static定义内部类、方法中定义内部类）

Java——内部类使用总结（基本概念、定义内部类、static定义内部类、方法中定义内部类）

Winter_world

发布于 2020-09-25 02:25:28

55600

代码可运行

文章被收录于专栏：技术小屋-未分类技术小屋-未分类

运行总次数：0

代码可运行

1、基本概念

类的组成包括：成员、方法，几乎所有程序都不会对嵌套程序有什么限定，内部类指的是在一个类中继续嵌套其他类结构的一种代码形式，且理论上可以一直嵌套。

【举例】：观察内部类

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Outer o = new Outer();
        o.fun();
    }

}

class Outer{ //外部类
    private String info = "hello";
    class Inner{ //内部类
        public void print(){
            System.out.println(info);
        }
    }
    public void fun(){
        Inner inner = new Inner();
        inner.print();
    }
}

类本身的核心组成就应该是属性和方法，但是引用了内部类的话，程序结构就被破坏了，那么内部类的好处在哪？若将内部类拿出，变为两个类，程序改动非常大，内部类的最大好处就是可以直接进行外部类的私有属性访问。

现在有以下几个问题：

（1）在编写代码中，只要是属性的访问，一定要加this，但由于属性是外部类的，所以需要：外部类.this.属性；

class Outer{ //外部类
    private String info = "hello";
    class Inner{ //内部类
        public void print(){
            System.out.println(Outer.this.info);
        }
    }
    public void fun(){
        Inner inner = new Inner();
        inner.print();
    }
}

（2）以上代码，内部类可以方便操作外部类私有属性，那么外部类是否可以访问内部类的私有属性：答案，是

   protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Outer o = new Outer();
        o.fun();
    }

class Outer{ //外部类
    private String info = "hello";
    class Inner{ //内部类
        private String msg = "world";
        public void print(){
            System.out.println(Outer.this.info);
        }
    }
    public void fun(){
        Inner inner = new Inner();
        inner.print();
        System.out.println(inner.msg);
    }
}

由以上可知，内部类和外部类的私有属性是可以直接访问的。

（3）目前可发现，实例化内部类的对象操作都是在外部类的fun()方法里面完成的，其他类是否可以直接操作内部类对象，在其他类中实例化内部类对象，语法如下：

外部类名称.内部类名称对象名称 = new 外部类().new 内部类()；

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Outer.Inner inner = new Outer().new Inner();
        inner.print();
    }

}

class Outer{ //外部类
    private String info = "hello";
    class Inner{ //内部类
        private String msg = "world";
        public void print(){
            System.out.println(Outer.this.info);
        }
    }
    public void fun(){
        Inner inner = new Inner();
        inner.print();
        System.out.println(inner.msg);
    }
}

（4）内部类可以通过private定义为私有内部类，仅可以被其外部类使用

class Outer{ //外部类
    private String info = "hello";
    private class Inner{ //内部类
        private String msg = "world";
        public void print(){
            System.out.println(Outer.this.info);
        }
    }
    public void fun(){
        Inner inner = new Inner();
        inner.print();
        System.out.println(inner.msg);
    }
}

2、static定义内部类

利用static定义的属性和方法是不受类的控制的，相当于一个局外结构，如果内部类使用了static定义，那么此内部类就相当于变成了外部类，只能访问外部类的static属性。

【举例】：利用static定义内部类

class Outer{ //外部类
    private static String info = "hello";
    static class Inner{ //static内部类 = 外部类
        private String msg = "world";
        public void print(){
            System.out.println(info);
        }
    }
    public void fun(){
        Inner inner = new Inner();
        inner.print();
        System.out.println(inner.msg);
    }
}

既然static内部类变成了外部类，那么外部类就可以被其他类直接进行操作。但是这时候的实例化格式为：

外部类名称.内部类名称对象名称 = new 外部类.内部类()；

        Outer.Inner inner = new Outer.Inner();
        inner.print();

后续开发中，我们见到的程序类库中出现xxx.xxx就表示的是内部类。

3、方法中定义内部类

理论上内部类可以在任何位置中定义，包括：代码块、类中、方法中，实际开发中，有可能在方法中使用内部类。

【举例】：方法中写内部类

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Outer outer = new Outer();
        outer.fun(100);
    }

}

class Outer{ //外部类
    private  String info = "hello";

    public void fun(int temp){
        double sal = 9000.0;
        class Inner{
            public void print(){
                System.out.println("Outer类中的info属性="+Outer.this.info);
                System.out.println("fun()方法中的参数temp="+temp);
                System.out.println("fun()方法中定义的临时变量sal="+sal);
            }
        }
        new Inner().print();
    }
}