首页 > 代码库 > 内部类

内部类

2024-09-28 18:32:39   220人阅读

内部类：
 
内部类根据表现形式可以分为四种：成员内部类、局部内部类、匿名内部类、静态内部类
 
内部类访问特点：
1，内部类可以直接访问外部类中的成员。
2，外部类要访问内部类，必须建立内部类的对象。
一般用于类的设计。
 
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。
这时就是还有的事物定义成内部类来描述。
 
 
成员内部类：

1、成员内部类是依附其外部类而存在的，如果要产生一个成员内部类，必须有一个其外部类的实例

2、成员内部类中不可以定义静态方法（如果内部类中定义了静态成员，该内部类也必须是静态的）

3、成员内部类可以声明为private的，声明为private的成员内部类对外不可见，外部不能调用私有成员内部类的public方法

4、成员内部类可以声明为public的，声明为public的成员内部类对外可见，外部也可以调用共有成员内部类的public方法

5、成员内部类可以访问其外部类的私有属性，如果成员内部类的属性和其外部类的属性重名，则以成员内部类的属性值为准

 

 

静态内部类：
用static修饰的内部类就是静态内部类
如果内部类中定义了静态成员，该内部类也必须是静态的。
 
特点：

1、静态内部类中可以有静态方法，也可以有非静态方法

2、静态内部类只能访问其外部类的静态成员与静态方法

3、和普通的类一样，要访问静态内部类的静态方法，可以直接"."出来不需要一个类实例；要访问静态内部类的非静态方法，必须拿到一个静态内部类的实例对象

4、注意一下实例化成员内部类和实例化静态内部类这两种不同的内部类时写法上的差别

（1）成员内部类：外部类.内部类 XXX = 外部类.new 内部类();

 

（2）静态内部类：外部类.内部类 XXX = new 外部类.内部类();

 
局部内部类： 

局部内部类是定义在一个方法或者特定作用域里面的类

注意一下局部内部类没有访问修饰符，另外局部内部类要访问外部的变量或者对象，该变量或对象的引用必须是用final修饰的
内部类在局部位置上只能访问局部中被final修饰的局部变量。
 
  1. classOuter
  2. {
  3. int num =3;
  4. Object method()
  5. {
  7. finalint x =9;
  9. classInner
  10. {
  11. publicString toString()
  12. {
  13. return"show ..."+x;
  14. }
  15. }
  17. Object in =newInner();
  18. return in;//0x0045
  19. // in.show();
  20. }
  24. }
  26. classInnerClassDemo3
  27. {
  28. publicstaticvoid main(String[] args)
  29. {
  30. Outer out =newOuter();
  31. Object obj = out.method();
  32. System.out.println(obj);
  34. }
  35. }
 
 
匿名内部类：
就是内部类的简写格式。
必须有前提：内部类必须继承或者实现一个外部类或者接口。
匿名内部类：其实就是一个匿名子类对象。 
格式：new 父类or接口(){子类内容}
 
 
  1. abstractclassDemo
  2. {
  3. abstractvoid show();
  4. }
  6. classOuter
  7. {
  8. int num =4;
  9. /*
  10. class Inner extends Demo
  11. {
  12. void show()
  13. {
  14. System.out.println("show ..."+num);
  15. }
  1. }
  1. */
  2. publicvoid method()
  3. {
  4. //new Inner().show();
  5. newDemo()//匿名内部类。
  6. {
  7. void show()
  8. {
  9. System.out.println("show ........"+num);
  10. }
  11. }.show();
  12. }
  13. }
  16. classInnerClassDemo4
  17. {
  18. publicstaticvoid main(String[] args)
  19. {
  20. newOuter().method();
  21. }
  22. }
通常的使用场景之一：
当函数参数是接口类型时，而且接口中的方法不超过三个。
可以用匿名内部类作为实际参数进行传递
 
 
转自：http://www.cnblogs.com/xrq730/p/4875907.html
 
 
 
 
多态结合内部类  的面试题：
 
下面的代码编译时报错：
 
  1. classOuter
  2. {
  3. void method()
  4. {
  5. Object obj =newObject()
  6. {
  7. publicvoid show()
  8. {
  9. System.out.println("show run");
  10. }
  12. };
  13. obj.show();//因为匿名内部类这个子类对象被向上转型为了Object类型。
  14. //这样就不能在使用子类特有的方法了。
  17. }
  18. }
  20. classInnerClassDemo6
  21. {
  22. publicstaticvoid main(String[] args)
  23. {
  24. newOuter().method();
  25. }
  26. }
 
 
下面的代码可以执行：
  1. classOuter
  2. {
  3. void method()
  4. {
  5. newObject()
  6. {
  7. publicvoid show()
  8. {
  9. System.out.println("show run");
  10. }
  12. }.show();
  14. }
  15. }
  17. classInnerClassDemo6
  18. {
  19. publicstaticvoid main(String[] args)
  20. {
  21. newOuter().method();
  22. }
  23. }
 
 



null



内部类


联系
我们