Java内部类

2021年7月20日 6点热度 0条评论 来源: Acelin_H

内部类简介

Java 一个类中可以嵌套另外一个类,语法格式如下:

class OuterClass {   // 外部类
    // ...
    class NestedClass { // 嵌套类,或称为内部类
        // ...
    }
}

嵌套类有如下几种类型:

成员内部类

最简单的一种内部类,形式如下,跟其他变量一样,是一个类中的一个成员

class Outer {
    
    String str = "hello";
     
    public Outer(String str) {
        this.str = str;
    }
    
    /* 内部类 */
    class Inner {     
        public void showStr() {
            System.out.println(str);
        }
    }
}

  • 成员内部类可以无条件地访问外部类的所有元素
  • 外部类访问内部类需要先创建一个内部类对象
  • 成员内部类是依附外部类而存在
可以访问外部类原理

编译器会在编译时生成外部类和内部类两个字节码文件,还会给内部类的无参构造函数增加一个参数,为外部类的一个应用,且指向了外部类,故可以随意使用外部类一切。

侧面说明成员内部类依赖于外部类的优先创建,不然会初始化失败

局部内部类

定义在一个方法或者一个作用域里面的类,局部内部类的访问仅限于方法内或者该作用域内

class MyClass{
    public MyClass() {
         
    }
}
 
class Outer{
    public Outer(){
         
    }
     
    public MyClass getInner{
        
        /* 局部内部类 */
        class Inner extends MyClass{   
            int age = 0;
        }
        return new Inner();
    }
}

局部内部类就像是方法里面的一个局部变量一样,是不能有 public、protected、private 以及 static 修饰符的

匿名内部类

先看一下官方给的例子

public class HelloWorldAnonymousClasses {

    /**
     * 包含两个方法的HelloWorld接口
     */
    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }

    public void sayHello() {

        // 1、局部类EnglishGreeting实现了HelloWorld接口
        class EnglishGreeting implements HelloWorld {
            String name = "world";
            public void greet() {
                greetSomeone("world");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hello " + name);
            }
        }

        HelloWorld englishGreeting = new EnglishGreeting();

        // 2、匿名类实现HelloWorld接口
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "tout le monde";
            public void greet() {
                greetSomeone("tout le monde");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Salut " + name);
            }
        };

        // 3、匿名类实现HelloWorld接口
        HelloWorld spanishGreeting = new HelloWorld() {
            String name = "mundo";
            public void greet() {
                greetSomeone("mundo");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hola, " + name);
            }
        };

        englishGreeting.greet();
        frenchGreeting.greetSomeone("Fred");
        spanishGreeting.greet();
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }
}

匿名类表达式包含以下内部分:

  1. 操作符:new;
  2. 一个要实现的接口或要继承的类,案例一中的匿名类实现了HellowWorld接口,案例二中的匿名内部类继承了Animal父类;
  3. 一对括号,如果是匿名子类,与实例化普通类的语法类似,如果有构造参数,要带上构造参数;如果是实现一个接口,只需要一对空括号即可;
  4. 一段被"{}"括起来类声明主体;
  5. 末尾的";"号(因为匿名类的声明是一个表达式,是语句的一部分,因此要以分号结尾)。

本部分参考JAVA匿名内部类(Anonymous Classes)

静态内部类

静态内部类是不需要依赖于外部类的,并且它不能使用外部类的非static成员变量或者方法,这个和普通静态方法不能访问非静态方法或变量的原理一样,具体可以了解一下类的加载生命周期。

简单地说就是静态变量或方法是属于类的,非静态方法或变量是属于对象的,jvm加载类的时候就为类的静态变量或方法分配内存的,而非静态的需要等到要初始化对象时候才给分配内存,而这个过程是动态的,也就是等到我们什么时候想用,才会有累的初始化过程。

简单举个例子:

 
class Outer {
	int a = 1
	static int a = 2;
    public Outter() {
         
    }
     
	/* 静态内部类 */
    static class Inner {
        public Inner() {
             System.out.println(a); // 编译会报错
             System.out.println(b);

        }
    }
}

使用:

public class Test {
    public static void main(String[] args)  {
        Outer.Inner inner = new Outer.Inner();
    }
}

内部类简单应用

为什么在 Java 中需要内部类?总结一下主要有以下四点内部类的使用场景和好处:

  • 1.每个内部类都能独立的继承一个接口的实现,所以无论外部类是否已经继承了某个(接口的)实现,对于内部类都没有影响。内部类使得多继承的解决方案变得完整。
  • 2.方便将存在一定逻辑关系的类组织在一起,又可以对外界隐藏。
  • 3.方便编写事件驱动程序。
  • 4.方便编写线程代码。
    原文作者:Acelin_H
    原文地址: https://www.cnblogs.com/acelin/p/15029994.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。