高级类特性----内部类

内部类

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类。

内部类和外层封装它的类之间存在逻辑上的所属关系

Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。 Inner class的名字不能与包含它的类名相同；
Inner class可以使用包含它的类的静态和实例成员变量，也可以使用它所在方法的局部变量。

 

内部类举例

class A {
　　private int s;
　　public class B {
　　　　public void mb() {
　　　　　　s = 100;
　　　　　　System.out.println("在内部类B中s=" + s);
　　　　}
　　}
　　public void ma() {
　　　　B i = new B();
　　　　i.mb();
　　}
}

public class Test {
　　public static void main(String args[]){
　　　　A o = new A();
　　　　o.ma();
　　}
}
public class A{
　　private int s = 111;
　　public class B {
　　　　private int s = 222;
　　　　public void mb(int s) {
　　　　　　System.out.println(s); // 局部变量s
　　　　　　System.out.println(this.s); // 内部类对象的属性s
　　　　　　System.out.println(A.this.s); // 外层类对象属性s
　　　　}
　　}
　　public static void main(String args[]){
　　　　A a = new A();
　　　　A.B b = a.new B();
　　　　b.mb(333);
　　}
}

内部类特性

Inner class可以声明为抽象类 ，因此可以被其它的内部类继承。也可以声明为final的。

和外层类不同，Inner class可以声明为private或protected；

Inner class 可以声明为static的，但此时就不能再使用外层封装类的非static的成员变量；

非static的内部类中的成员不能声明为static的，只有在顶层类或static的内部类中才可声明static成员。

 

---

 

 

 

 1 public class OuterClass {
 2     int age;
 3     
 4     static class StaticInnerClass{
 5         void test(){ 
 6             //System.out.println(age);
 7         }
 8     }
 9     
10     static String name = "-1";
11     
12     //1. 在类的内部定义的类称为内部类
13     //2. 内部类相当于类的一个成员, 可以修饰类的成员的， private, static, final, abstract 都可以修饰内部类
14     class InnerClass{
15         String name = "0";
16         
17         public void test(){
18             String name = "1";
19             
20             System.out.println(name); //1
21             System.out.println(this.name); //0
22             //5. 内部类引用外部类的成员
23             System.out.println(OuterClass.this.name); //-1
24         }
25     }
26 }

 

 

 1 public class TestInnerClass {
 2     public static void main(String[] args) {
 3 
 4         //4. 静态内部类的创建: 不再需要外部类的实例. 
 5         OuterClass.StaticInnerClass sic = new OuterClass.StaticInnerClass();
 6         
 7         //3. 非静态内部类的创建, 先创建外部类的实例, 再通过 外部类名.new 创建内部类的实例.
 8         OuterClass oc = new OuterClass();
 9         OuterClass.InnerClass in = oc.new InnerClass();
10         in.test();
11 
12         //6. 匿名内部类对象: 使用某一个接口通常是 先创建接口的实现类, 再创建其实现类的对象.
13         Proxy.newProxyInstance(null, null, new InvocationHandler() {
14             
15             @Override
16             public Object invoke(Object proxy, Method method, Object[] args)
17                     throws Throwable {
18                 // TODO Auto-generated method stub
19                 return null;
20             }
21         });
22         // 还可以, 直接创建其实现类对象. 
23         InvocationHandler invocationHandler = new InvocationHandler() {
24             @Override
25             public Object invoke(Object proxy, Method method, Object[] args)
26                     throws Throwable {
27                 return null;
28             }
29         };
30     }
31 }

 

转载于:https://www.cnblogs.com/justdoitba/p/7231791.html