java内部类

最新推荐文章于 2025-06-18 17:33:39 发布

浩瀚蓝天dep

最新推荐文章于 2025-06-18 17:33:39 发布

阅读量242

点赞数 1

CC 4.0 BY-SA版权

分类专栏：学习分享文章标签： java

本文链接：https://blog.youkuaiyun.com/LSW_JAVADP/article/details/97915286

学习分享专栏收录该内容

23 篇文章

订阅专栏

一、什么是内部类

之前我们所说的类都对应于一个独立的java源文件，但是一个类也可以放在另一个类的内部，这个类就叫做内部类，相对于它而言的我们称之为外部类

二、内部类的作用

内部类与包含着它的外部类有着密切的联系，内部类可以实现对外部的完全隐藏，可以实现更好的封装作用，代码的实现上也更简洁。内部类可以很好的访问外部类的私有变量。

内部类只是java编译器的概念，对于java虚拟机来说他是不知道内部类这回事的，每一个内部类都会被编译为一个单独的类，生成一个单独的字节码文件。

三、内部类的分类

内部类按照位置和方式不同，可以分为4种：

1.静态内部类

2.成员内部类

3.方法内部类

4.匿名内部类

静态内部类和成员内部类可以被外部调用，如果不想被访问可以声明为private，这样外部就没法使用了

方法内部类是在一个方法内部定义和使用的；

匿名内部类的使用范围更小

四、分别对以上四个内部类进行介绍

（一）静态内部类

静态内部类和静态变量和静态方法定义的位置一样，通过static关键字修饰，以下是实例：

public class Outer {
    //类变量
    private static int a = 100;
    //静态内部类
    public static class StaticInner {
        //静态内部类的方法
        public void innerMethod(){
            System.out.println("inner :"+a);
        }

    }
    //外部类的方法
    public void outerMethod(){
        StaticInner inner = new StaticInner();
        inner.innerMethod();
    }
}

内部类的调用：

public class Main {

    public static void main(String[] args) {
        Outer.StaticInner si = new Outer.StaticInner();
        si.innerMethod();
        Outer o = new Outer();
        o.outerMethod();
    }
}

结果：

inner :100
inner :100

外部类为Outer，内部类为StaticInner静态内部类用static修饰，静态内部类在语法上除了放在其他类内部，他与独立的类没什么区别，同样可以有静态变量，静态方法，成员变量，成员方法和构造方法等。静态内部类可以访问外部类的静态变量和方法，但是不可以访问实例变量和方法，在类的内部可以直接使用内部静态类的方法，如outerMethod（）方法所示
（二）成员内部类

和静态内部类相比成员内部类没有用static修饰，但是含义有很大不同，以下是实例：

public class Outer {
    //实例变量
    private  int a = 100;
    //成员内部类
    public  class Inner {
        //成员内部类的方法
        public void innerMethod(){
            System.out.println("outer :"+a);
            // 调用外部类的方法
            action();
        }
    }
    //外部类的方法
    public void action(){
        System.out.println("outer action...");
    }
    public void outerMethod(){
        Inner inner = new Inner();
        inner.innerMethod();
    }
}

内部类的调用：

ublic class Main {

    public static void main(String[] args) {
       Outer outer = new Outer();
       Outer.Inner inner = outer.new Inner();
       inner.innerMethod();
//       outer.outerMethod();
    }
}

结果：

outer :100
outer action...

分析：
Inner是成员内部类，它除了能调用外部类的静态变量和方法还可以直接访问外部类的实例变量和方法，如：innerMethod直接访问外部类的私有实例变量a，同时直接调用action()方法。外部类调用内部类的语法：外部类对象.new 内部类(),如：outer.new Inner().

另外和静态内部类不同的是，成员内部类不能定义静态变量和方法（除了final修饰的常量外），同时剩余的两种方法内部类和匿名内部类也不能定义静态变量和方法。

（三）方法内部类

方法内部类即定义在方法内部的类，具体见实例：

public class Outer {
    //实例变量
    private  int a = 300;
    //外部类的方法
    public void action(){
        System.out.println("outer action...");
    }
    public void outerMethod(int param){
        String str = "hello";
        //方法内部类
        class MethodInner{
            public void innerMethod(){
                System.out.println("outer a:"+a);
                System.out.println("param "+param);
                System.out.println("local str:"+str);
            }
        }
        MethodInner inner = new MethodInner();
        inner.innerMethod();
    }
}

内部类的调用：

public class Main {

    public static void main(String[] args) {
        final int b = 200;
       Outer outer = new Outer();
       outer.outerMethod(b);
    }
}

结果：

outer a:300
param 200
local str:hello

分析：

方法内部类MethodInner,定义在外部类的outerMethod()中，方法内部类只能在定义的方法内部使用，如果方法是实例方法，除了静态变量和方法，内部类还可以直接访问外部类的实例变量和方法，具体见实例中的代码。如果是静态方法，则方法内部类只能访问外部类的静态变量和方法。方法内部类还可以访问方法的参数和方法中的局部变量

（四）匿名内部类

匿名内部类和前面三种内部类不同，它没有单独的类定义，它在创建对象的时候定义，语法如下：

new 父类(参数列表){
    //匿名内部类的实现部分
}
或者
new 父接口(){
    //匿名内部类的实现部分
}

匿名内部类是和new关联的，在创建对象的时候定义类，new后面跟的是父类或者父接口，然后是()，括号里面是传递的参数列表，最后是大括号{}，里面定义的是类的内容。

看个例子：

public class Parent {

    private int x;
    private int y;

    public Parent(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public String print(){
        return "x :"+x+" y :"+y;
    }
}

public class Outer {
    //实例变量
    private  int a = 300;
    //外部类的方法
    public void outerMethod(int x,int y){
        //匿名内部类
        Parent parent = new Parent(x, y) {

            @Override
            public String print() {
                System.out.println("匿名内部类 a:" +a);
                return super.print();
            }
        };
        System.out.println(parent.print());
    }
}

测试：

public class Main {

    public static void main(String[] args) {
        int x = 10;
        int y = 20;
       Outer outer = new Outer();
       outer.outerMethod(x,y);
    }
}

结果：