第6章 java内部类

第6章 java内部类

java内部类可以分为：成员内部类、局部内部类。

内部类的特点：

①内部类仍然是一个独立的类，在编译后会生成独立的.class文件；

②内部类是外部类的一个成员，因此可以自由访问外部类的所有成员；

1、实例内部类

e.g.

class A{
    static String s1 = "这是A类中的静态成员";
    String s2 = "这是A类中的实例成员";
    // 实例内部类
    class B{
        String s2 = "这是内部类中的实例成员";
        void f2(){
            System.out.println("这是实例内部类中的实例方法");
            // 访问外部类中的静态成员
            System.out.println(s1);
            // 访问外部类中的实例成员
            A a = new A();
            System.out.println(a.s2);
            System.out.println(A.this.s2);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        // 创建外部类的实例
        A a = new A();
        // 创建内部类的实例
        A.B b= a.new B();
        b.f2();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

关于实例内部类的几点说明

①实例内部类可以访问外部类的所有成员；

②在实例内部类中不能定义静态成员，除非同时使用static和final修饰。

③在外部类的静态方法和外部类以外的其他类中，必须通过外部类的实例创建内部类的实例；

④在外部类和外部类以外的其他类中，必须通过内部类的实例访问内部类的成员；

2、静态内部类

class C{
    static String s1 = "这是外类中的静态成员";
    String s2 = "这是外部类中的实例成员";

    // 静态内部类
    static class D{
        static String s1 = "这是静态内部类中的静态成员";
        String s2 = "这是静态内部类中的实例成员";

        static void f1(){
            System.out.println("这是静态内部类中的静态方法");
            System.out.println(C.s1);
            System.out.println(new C().s2);
        }
        void f2(){
            System.out.println("这是静态内部类中的实例方法");
            System.out.println(C.s1);
            System.out.println(new C().s2);
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        // 访问静态内部类中的静态成员
       System.out.println( C.D.s1);
       C.D.f1();

       // 访问静态内部类中的实例成员
       // 创建内部类的实例
       C.D d = new C.D();
       System.out.println(d.s2);
       d.f2();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

关于静态内部类的说明

①静态内部类中可以定义静态成员和实例成员；

②要访问静态内部类的实例成员需要通过静态内部类的实例访问；

③静态内部类可以直接访问外部类的静态成员，如果要访问外部类的实例成员需要通过外部类的实例访问。

4、匿名类

匿名类是指没有名称的内部类，在创建时必须使用new语句声明；

两种实现方式：

①继承一个类，重写其方法；

②实现一个接口，实现其方法；

e.g. 实现方式1

class A1{
    void show(){
        System.out.println("这是A类中的方法");
    }
}

public class Test4 {
    // 匿名类
    A1 a1 = new A1(){
        @Override
        void show() {
            // super.show();
            System.out.println("这是匿名类中的方法");
        }
    };
    
    // 主方法
    public static void main(String[] args) {
        new Test4().a1.show();;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

e.g. 实现方式2

interface I3{
    int max(int x,int y);
}

public class Test4 {
    // 使用匿名类实现接口I3
    I3 i3 = new I3(){
        @Override
        public int max(int x, int y) {
            return x>y?x:y;
        }
    };

    public static void main(String[] args) {
        int result = new Test4().i3.max(20,50);
        System.out.println(result);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5、Lambda表达式与函数式接口

使用Lambda表达式实现的接口即函数式接口；

e.g.

interface I4{
    int max(int x,int y);
}

public class Test4 {
    // 使用Lambda表达式实现接口I4
    I1 i4 = (int a,int b)->{ return a>b?a:b; };

    // 主方法
    public static void main(String[] args) {
        int y = new Test4().i4.max(30,40);
        System.out.println(y);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

PS：使用Lambda表达式实现接口时，其对应接口中的抽象方法有且只能有一个。