Java学习------内部类

1. 界说

界说在一个类中的类
2. 利用时机

• 当一个类必要用到另一个类，并且两个类的接洽比力密切时就必要利用内部类
  
• 内部类可以访问外部类的私有成员，这样可以将相关的类和接口隐藏在外部类的内部，提高封装性
  
• 匿名内部类是没著名字的类，通常用于界说一个只利用一次的类
  

3. 分类

3.1 静态内部类

可以当做静态变量来看

1. //静态内部类
2. public class OuterClass{
3.         private static int i = 0;
4.         private int j = 100;
5.         public static void m1() {
6.                 System.out.println("m1");
7.         }
8.         public void m2() {
9.                 System.out.println("m2");
10.         }
11.         //静态内部类
12.         //四种访问控制权限修饰符在这里都可以使用
13.         private static class InnerClass {
14.                 public void m3() {
15.                         System.out.println(i); //可以访问
16.                         System.out.println(j); //不可以访问
17.                         m1(); //可以访问
18.                         m2(); //不可以访问
19.                 }
20.         }
21. }

复制代码

注意点：无法直接访问外部类中实例变量和实例方法
如何利用： OuterClass.InnerClass oi = new OuterClass.InnerClass ();
3.2 实例内部类

可以当做实例变量来看

1. //实例内部类
2. public class OuterClass{
3.         private static int i = 0;
4.         private int j = 100;
5.         public static void m1() {
6.                 System.out.println("m1");
7.         }
8.         public void m2() {
9.                 System.out.println("m2");
10.         }
11.         //静态内部类
12.         //四种访问控制权限修饰符在这里都可以使用
13.         private class InnerClass {
14.                 public void m3() {
15.                         System.out.println(i); //可以访问
16.                         System.out.println(j); //可以访问
17.                         m1(); //可以访问
18.                         m2(); //可以访问
19.                 }
20.         }
21. }

复制代码

注意点：可以直接访问外部类中所有的实例变量，实例方法，静态变量，静态方法
如何利用： OuterClass.InnerClass oi = new OuterClass().new InnerClass ();
3.3 局部内部类

可以当做局部变量来看

1. //局部内部类
2. public class OuterClass{
3.         private static int i = 0;
4.         private int j = 100;
5.         public void m1() {
6.                 //局部变量
7.                 int i = 11;
8.                 //局部内部类
9.                 class InnerClass {
10.                         public void m2() {
11.                                 System.out.println(i); //可以访问
12.                                 System.out.println(j); //可以访问
13.                         }
14.                 }
15.                 //new 对象
16.                 InnerClass ic = new InnerClass();
17.                 ic.m2();
18.         }
19.         public static void m3() {
20.                 int i = 11;
21.                 //局部内部类
22.                 //这里的内部类的类名可以和上面相同的原因是属于局部，就和局部变量一样，出了大括号之后就没了
23.                 class InnerClass {
24.                         public void m2() {
25.                                 System.out.println(i); //可以访问
26.                                 System.out.println(j); //不可以访问
27.                         }
28.                 }
29.         }
30. }

复制代码

注意点：

• 局部内部类方外类外部的局部变量时，局部变量必要被final修饰
  
• 不能利用访问权限控制符修饰，由于只是在局部访问，外部不必要访问，添加这些修饰符也没有什么用
  
• 从JDK8开始，不必要手动添加final了，但JVM会自动添加
  

3.4 匿名内部类

特殊的局部内部类，没著名字，只可以利用一次

1. //匿名内部类
2. public class test {
3.     public static void main(String[] args) {
4.         Computer c = new Computer();
5.         c.conn(new Usb() {
6.             @Override
7.             public void read() {
8.                 System.out.println("read");
9.             }
11.             @Override
12.             public void write() {
13.                 System.out.println("write");
14.             }
15.         });
16.     }
17. }
19. class Computer {
20.     public void conn(Usb usb) {
21.         usb.read();
22.         usb.write();
23.     }
24. }
26. interface Usb {
27.     void read();
28.     void write();
29. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。