Java语言基础：内部类

内部类，计算机面向对象程序设计概念。向对象程序设计中，可以在一个类的内部定义另一个类，这种类称为嵌套类(nested classes),它有两种类型，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。

澧县ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为成都创新互联公司的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：18982081108（备注：SSL证书合作）期待与您的合作！

1. 普通内部类

普通内部类的一个最简单的例子：

 
 
 
    
  
  
  
  1. // 外部类     
    2. 
  
  
  
  2. class OutterClass {     
    3. 
  
  
  
  3.     // 内部类     
    4. 
  
  
  
  4.     public class InnerClass {     
    5. 
  
  
  
  5.         private int i = 0;     
    6. 
  
  
  
  6.         public int getInt(){     
    7. 
  
  
  
  7.             return i;     
    8. 
  
  
  
  8.         }     
    9. 
  
  
  
  9.     }     
    10. 
  
  
  
  10.     public void proc(){     
    11. 
  
  
  
  11.         InnerClass inClass = new InnerClass();     
    12. 
  
  
  
  12.         System.out.println(inClass.getInt());     
    13. 
  
  
  
  13.     }     
    14. 
  
  
  
  14. }     
    15. 
  
  
  
  15.       
    16. 
  
  
  
  16. public class Main {         
    17. 
  
  
  
  17.     public static void main(String[] args) {     
    18. 
  
  
  
  18.         OutterClass outClass = new OutterClass();     
    19. 
  
  
  
  19.         outClass.proc();     
    20. 
  
  
  
  20.     }     
    21. 
  
  
  
  21. }    
    22.

外部类可以访问内部类的私有成员，内部类也可以访问外部类的私有成员：

 
 
 
    
  
  
  
  1. // 外部类     
    2. 
  
  
  
  2. class OutterClass {     
    3. 
  
  
  
  3.     private int mOut = 10;     
    4. 
  
  
  
  4.     // 内部类     
    5. 
  
  
  
  5.     public class InnerClass {     
    6. 
  
  
  
  6.         private int mIn = 0;     
    7. 
  
  
  
  7.         public void printOutPrivate(){     
    8. 
  
  
  
  8.             // 直接打印外部类的成员     
    9. 
  
  
  
  9.             System.out.println(mOut);     
    10. 
  
  
  
  10.         }     
    11. 
  
  
  
  11.     }     
    12. 
  
  
  
  12.     public void printInPrivate(){     
    13. 
  
  
  
  13.         InnerClass inClass = new InnerClass();     
    14. 
  
  
  
  14.         // 直接打印内部类的私有成员     
    15. 
  
  
  
  15.         System.out.println(inClass.mIn);     
    16. 
  
  
  
  16.     }     
    17. 
  
  
  
  17.     public void printOutPrivate(){     
    18. 
  
  
  
  18.         InnerClass inClass = new InnerClass();     
    19. 
  
  
  
  19.         inClass.printOutPrivate();     
    20. 
  
  
  
  20.     }     
    21. 
  
  
  
  21. }     
    22. 
  
  
  
  22.       
    23. 
  
  
  
  23. public class Main {         
    24. 
  
  
  
  24.     public static void main(String[] args) {     
    25. 
  
  
  
  25.         OutterClass outClass = new OutterClass();     
    26. 
  
  
  
  26.         outClass.printInPrivate();     
    27. 
  
  
  
  27.         outClass.printOutPrivate();     
    28. 
  
  
  
  28.     }     
    29. 
  
  
  
  29. }    
    30.

如果外部类的成员变量与内部类的成员变量名字相同，当内部类要访问外部类的该成员时，可以使用“OutClass.this.mem”来区分：

 
 
 
    
  
  
  
  1. // 外部类     
    2. 
  
  
  
  2. class OutterClass {     
    3. 
  
  
  
  3.     private int mMem = 10;     
    4. 
  
  
  
  4.     // 内部类     
    5. 
  
  
  
  5.     public class InnerClass {     
    6. 
  
  
  
  6.         private int mMem = 0;     
    7. 
  
  
  
  7.         public void printOutPrivate(){     
    8. 
  
  
  
  8.             // 直接打印外部类的成员     
    9. 
  
  
  
  9.             System.out.println(OutterClass.this.mMem);     
    10. 
  
  
  
  10.         }     
    11. 
  
  
  
  11.     }     
    12. 
  
  
  
  12. }  
    13.

要创建普通内部类，必须先创建相应的外部类：

 
 
 
    
  
  
  
  1. // 外部类     
    2. 
  
  
  
  2. class OutterClass {     
    3. 
  
  
  
  3.     private int mMem = 10;     
    4. 
  
  
  
  4.     // 内部类     
    5. 
  
  
  
  5.     public class InnerClass {     
    6. 
  
  
  
  6.         private int mMem = 0;     
    7. 
  
  
  
  7.         public void printOutPrivate(){     
    8. 
  
  
  
  8.             // 直接打印外部类的成员     
    9. 
  
  
  
  9.             System.out.println(OutterClass.this.mMem);     
    10. 
  
  
  
  10.         }     
    11. 
  
  
  
  11.     }     
    12. 
  
  
  
  12. }     
    13. 
  
  
  
  13.       
    14. 
  
  
  
  14. public class Main {         
    15. 
  
  
  
  15.     public static void main(String[] args) {     
    16. 
  
  
  
  16.         OutterClass outClass = new OutterClass();     
    17. 
  
  
  
  17.        OutterClass.InnerClass inClass = outClass.new InnerClass();     
    18. 
  
  
  
  18.         inClass.printOutPrivate();     
    19. 
  
  
  
  19.     }     
    20. 
  
  
  
  20. }    
    21.

也可以用下面的方式：

 
 
 
    
  
  
  
  1. // 外部类     
    2. 
  
  
  
  2. class OutterClass {     
    3. 
  
  
  
  3.     private int mMem = 10;     
    4. 
  
  
  
  4.     // 内部类     
    5. 
  
  
  
  5.     public class InnerClass {     
    6. 
  
  
  
  6.         private int mMem = 0;     
    7. 
  
  
  
  7.         public void printOutPrivate(){     
    8. 
  
  
  
  8.             // 直接打印外部类的成员     
    9. 
  
  
  
  9.             System.out.println(OutterClass.this.mMem);     
    10. 
  
  
  
  10.         }     
    11. 
  
  
  
  11.     }     
    12. 
  
  
  
  12.     public InnerClass newInnerClass() {     
    13. 
  
  
  
  13.         return new InnerClass();     
    14. 
  
  
  
  14.     }     
    15. 
  
  
  
  15. }     
    16. 
  
  
  
  16.       
    17. 
  
  
  
  17. public class Main {         
    18. 
  
  
  
  18.     public static void main(String[] args) {     
    19. 
  
  
  
  19.         OutterClass outClass = new OutterClass();     
    20. 
  
  
  
  20.        OutterClass.InnerClass inClass = outClass.newInnerClass();     
    21. 
  
  
  
  21.         inClass.printOutPrivate();     
    22. 
  
  
  
  22.     }     
    23. 
  
  
  
  23. }    
    24.

2. 静态内部类

普通内部类前面加上static修饰符，就成为静态内部类，静态内部类类似于C++的嵌套类，与普通内部类相比有如下区别：

静态内部类没有指向外部类的引用，外部类对于它来说更像一个名字空间。

普通内部类不能有静态成员，静态方法，或另一个静态内部类;而静态内部类可以有这一切。

静态内部类可以直接创建，不必先创建外部类：

 
 
 
    
  
  
  
  1. // 外部类     
    2. 
  
  
  
  2. class OutterClass {     
    3. 
  
  
  
  3.     private int mMem = 0;     
    4. 
  
  
  
  4.     // 静态内部类     
    5. 
  
  
  
  5.     static public class InnerClass {     
    6. 
  
  
  
  6.         private int mMem = 0;     
    7. 
  
  
  
  7.         public void printOutPrivate(){     
    8. 
  
  
  
  8.             // 这是错误的     
    9. 
  
  
  
  9.             // System.out.println(OutterClass.this.mMem);     
    10. 
  
  
  
  10.         }     
    11. 
  
  
  
  11.     }     
    12. 
  
  
  
  12.     public void printInPrivate() {     
    13. 
  
  
  
  13.         InnerClass inClass = new InnerClass();     
    14. 
  
  
  
  14.         // 可以直接访问静态内部类的成员     
    15. 
  
  
  
  15.         System.out.println(inClass.mMem);     
    16. 
  
  
  
  16.     }     
    17. 
  
  
  
  17. }     
    18. 
  
  
  
  18. public class Main {         
    19. 
  
  
  
  19.     public static void main(String[] args) {     
    20. 
  
  
  
  20.         // 直接创建静态内部类     
    21. 
  
  
  
  21.         OutterClass.InnerClass inClass = new OutterClass.InnerClass();     
    22. 
  
  
  
  22.         inClass.printOutPrivate();     
    23. 
  
  
  
  23.     }     
    24. 
  
  
  
  24. }    
    25.

从上面描述可以看出，静态内部类与一般类没有太大区别，只不过它是放在一个类的里面，这个类相当于它的名字空间，可以防止命名冲突。

3. 局部内部类

Java可以把一个类定义在一个方法里面，甚至是一个{}块里面，它的作用域就在这个块里面：

 
 
 
    
  
  
  
  1. // 外部类     
    2. 
  
  
  
  2. class OutterClass {     
    3. 
  
  
  
  3.     public void testLocalInner() {     
    4. 
  
  
  
  4.         if (true)     
    5. 
  
  
  
  5.         {     
    6. 
  
  
  
  6.             class LocalInner {     
    7. 
  
  
  
  7.                 public void proc() {     
    8. 
  
  
  
  8.                     System.out.println("hello");     
    9. 
  
  
  
  9.                 }     
    10. 
  
  
  
  10.             }     
    11. 
  
  
  
  11.             // 可以创建使用     
    12. 
  
  
  
  12.             LocalInner localInner = new LocalInner();     
    13. 
  
  
  
  13.             localInner.proc();     
    14. 
  
  
  
  14.         }     
    15. 
  
  
  
  15.         // 错误：超出类定义的作用域     
    16. 
  
  
  
  16.         LocalInner localInner = new LocalInner();     
    17. 
  
  
  
  17.         localInner.proc();     
    18. 
  
  
  
  18.     }     
    19. 
  
  
  
  19. }    
    20.

局部内部类的一般用途是实现某个接口，并作为这个接口传出方法被使用：

 
 
 
    
  
  
  
  1. // 接口     
    2. 
  
  
  
  2. interface Talker {     
    3. 
  
  
  
  3.     public void Talk();     
    4. 
  
  
  
  4. }     
    5. 
  
  
  
  5.       
    6. 
  
  
  
  6. // 外部类     
    7. 
  
  
  
  7. class OutterClass {     
    8. 
  
  
  
  8.     public Talker getTalker() {     
    9. 
  
  
  
  9.         // 现实该接口的局部内部类     
    10. 
  
  
  
  10.         class SomeTalker implements Talker {     
    11. 
  
  
  
  11.             public void Talk() {     
    12. 
  
  
  
  12.                 System.out.println("hello");     
    13. 
  
  
  
  13.             }     
    14. 
  
  
  
  14.         }     
    15. 
  
  
  
  15.         // 创建类实例并作为Talker返回     
    16. 
  
  
  
  16.         SomeTalker talker = new SomeTalker();     
    17. 
  
  
  
  17.         return talker;     
    18. 
  
  
  
  18.     }     
    19. 
  
  
  
  19. }     
    20. 
  
  
  
  20.       
    21. 
  
  
  
  21. public class Main {         
    22. 
  
  
  
  22.     public static void main(String[] args) {     
    23. 
  
  
  
  23.         OutterClass outClass = new OutterClass();     
    24. 
  
  
  
  24.         Talker talker = outClass.getTalker();     
    25. 
  
  
  
  25.         talker.Talk();     
    26. 
  
  
  
  26.     }     
    27. 
  
  
  
  27. }    
    28.

4. 匿名内部类

匿名内部类的语法如下：

 
 
 
    
  
  
  
  1. new InterfaceName(){......}; 或 new SuperclassName(){......};   
    2.

它被认为是InterfaceName的实现者，或是SuperclassName的继承类，匿名内部类没有构建函数，如果SuperclassName有带参数的构造函数，必须在创建匿名内部类时带上这些参数，下面是匿名内部类最常见的使用场合：

 
 
 
    
  
  
  
  1. // 接口     
    2. 
  
  
  
  2. interface Talker {     
    3. 
  
  
  
  3.     public void Talk();     
    4. 
  
  
  
  4. }     
    5. 
  
  
  
  5.       
    6. 
  
  
  
  6. // 外部类     
    7. 
  
  
  
  7. class OutterClass {     
    8. 
  
  
  
  8.     public void Talk(Talker talker) {     
    9. 
  
  
  
  9.         talker.Talk();     
    10. 
  
  
  
  10.     }     
    11. 
  
  
  
  11. }     
    12. 
  
  
  
  12.       
    13. 
  
  
  
  13. public class Main {         
    14. 
  
  
  
  14.     public static void main(String[] args) {     
    15. 
  
  
  
  15.         OutterClass outClass = new OutterClass();     
    16. 
  
  
  
  16.         // 直接生成一个匿名内部类     
    17. 
  
  
  
  17.         outClass.Talk(new Talker(){     
    18. 
  
  
  
  18.             public void Talk() {     
    19. 
  
  
  
  19.                 System.out.println("hello");     
    20. 
  
  
  
  20.             }     
    21. 
  
  
  
  21.         });     
    22. 
  
  
  
  22.     }     
    23. 
  
  
  
  23. }    
    24.

原文出处：http://blog.csdn.net/linzhengqun/archive/2011/03/24/6275586.aspx 

【编辑推荐】

  1. Java的局部内部类以及final类型的参数和变量
  2. 没有原生数据类型，Java会更好吗？
  3. 20个开发人员非常有用的Java功能代码
  4. 走进Java 7中的模块系统
  5. 2009年十大Java技术解决方案

网页标题：Java语言基础：内部类
分享网址：http://www.shufengxianlan.com/qtweb/news14/49464.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站收录知识

分类信息网

雅安托管服务器　　 　乐山服务器托管　　 　手机网站版本　　 　四川乐山服务器托管　　 　bgp多线机房托管　　 　瑞杰企业管理　　 　网络推广外包　　 　济桢教育　　 　php主机　　 　成都400电话申请　　 　微信小程序开发　　 　谷歌优化排名　　 　网站建设方案　　 　成都APP定制开发　　 　自贡网站建设　　 　青年旅行社　　 　云服务器　　 　成都高电机柜租用　　 　成都网站设计公司　　 　成都雨棚定制