java-内部类介绍

内部类(Nested Class) 嵌套类：

（1）静态内部类

（2）非静态内部类:

• 普通内部类（成员内部类）：在一个外部类中直接定义的内部类。
• 匿名内部类:
• 方法内部类:在一个方法（外部类中的方法）或代码块中定义的内部类。 

内部类仍然是一个独立的类，在编译之后内部类会被单独编译成独立的.class文件，但是前面冠以外部类的类名和$符号。

内部类可以使用修饰符（public ,protected,default,private）。

静态内部类的基本用法:

1.静态内部类可以包含静态成员，非静态成员。

2.静态内部类可以直接调用外部类的经验属性，静态方法。单不能调用外部类的普通属性，普通方法。

3.在不相关类中，可以直接创建静态内部类的对象（不需要通过所在的外部类）。

4.静态内部类实际上和外部类联系很少，也就是命名空间上的联系。

方法内部类的基本用法:

1.方法内部类的地位和方法内的局部变量的位置类似，均不可被修饰符修饰。

2.方法内部类只能在生命的方法内是可见的。因此定义局部内部类之后，想用的话就要在此方法内直接实例化，一定是先声明后使用。

3.方法内部类不能访问定义它的方法内的局部变量，除非这个变量被定义为final,及局部变量和方法内部类生命周期不一致。

4.方法内部类只能包含非静态成员。

5.方法内部类中不能引用所在方法的普通局部变量，除非是常量。方法的生命周期和方法内部类对象的生命周期不一致。

匿名内部类的基本用法:

匿名内部类的实例化方式:new SomeInterfaceOrClass(){?};

意味着创造一个实现或者说继承了SomeInterfaceOrClass类的对象。

Ps：根据声明的位置，判断匿名内部类是成员内部类还是方法内部类。一般是方法内部类。

三种使用方法:

继承方式，接口方式，以及参数方式

通过代码了解一下:

  1 package com.etc;
  2 
  3 import java.util.Date;
  4 
  5 @SuppressWarnings("all")
  6 public class NestedClassDemo {
  7     public static void main(String[] args) {
  8 
  9         Test4 test=new Test4();
 10         test.test();
 11         //不相关的内部类调用及实例化
 12         Test4.Test t1=new Test4.Test();
 13         //成员内部类的实例必须借助外部类
 14         Test4.Test2 t2=test.new Test2();
 15         System.out.println("不相关内部类:"+t1.getClass());
 16         System.out.println("成员内部类:"+t2.getClass());
 17         useCarForTest us=new useCarForTest();
 18         System.out.print("继承式匿名内部类使用结果:");
 19         us.use();
 20         System.out.print("参数式匿名内部类使用结果:");
 21         us.useElement();
 22     }
 23 }
 24 
 25 @SuppressWarnings("all")
 26 class Test4{
 27 
 28     static int a=10;
 29     int b=20;
 30     //静态内部类
 31     static class Test{
 32         private void printA() {
 33             System.out.println(a);
 34             //静态内部类中不能调用外部类的普通成员
 35             //    System.out.println(b);
 36         }
 37     }
 38     //普通内部类 
 39     class Test2{
 40         //成员内部类中不能有静态的成员，除非声明为final，并且只能是编译器可以确定值的常量表达式
 41         int a=10;
 42         final static int b=20;
 43         /*final static Date date=new Date();*/
 44     }
 45 
 46     //方法内部类，局部内部类
 47     public void test() {
 48 
 49         class Test3{
 50 
 51         }
 52         //匿名内部类也可以放在方法内部类里面、为继承式匿名内部类使用
 53         Runnable run=new Runnable() {
 54             @Override
 55             public void run() {
 56                 System.out.println("测试1");
 57             }
 58         };
 59     }
 60 
 61     //定义了匿名内部类的类体，同时创建了一个匿名内部类的实例。
 62     Runnable run=new Runnable() {
 63         @Override
 64         public void run() {
 65             System.out.println("测试2");
 66         }
 67     };
 68 }
 69 
 70 
 71 
 72 class useCarForTest{
 73 
 74     public void element(Car car) {
 75         car.say();
 76     }
 77     //匿名内部类的使用,参数式
 78     public void useElement() {
 79         element(new Car() {
 80             @Override
 81             public void say() {
 82                 System.out.println("这是一辆奔驰");    
 83             }
 84         });
 85     }
 86 
 87     //匿名内部类的使用,继承式
 88     public void use() {
 89         Car car=new Car() {
 90             @Override
 91             public void say() {
 92                 System.out.println("这是一辆保时捷!");    
 93             }
 94         };
 95         car.say();
 96     }
 97 }
 98 
 99 class Car{
100     public void say() {
101         System.out.println("这是一辆车!");
102     }
103 }

 

运行效果截图:

 

ps:文章待完善，后续补全。

 

转载于:https://www.cnblogs.com/weekstart/p/10852164.html