`
ijavagos
  • 浏览: 1241611 次
  • 性别: Icon_minigender_2
  • 来自: 北京
文章分类
社区版块
存档分类
最新评论

Java语言基础：内部类

Java 
阅读更多
1.  普通内部类
  • 普通内部类的一个最简单的例子：

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

  1. // 外部类   
  2. class  OutterClass {  
  3.     private   int  mOut =  10 ;  
  4.     // 内部类   
  5.     public   class  InnerClass {  
  6.         private   int  mIn =  0 ;  
  7.         public   void  printOutPrivate(){  
  8.             // 直接打印外部类的成员   
  9.             System.out.println(mOut);  
  10.         }  
  11.     }  
  12.     public   void  printInPrivate(){  
  13.         InnerClass inClass = new  InnerClass();  
  14.         // 直接打印内部类的私有成员   
  15.         System.out.println(inClass.mIn);  
  16.     }  
  17.     public   void  printOutPrivate(){  
  18.         InnerClass inClass = new  InnerClass();  
  19.         inClass.printOutPrivate();  
  20.     }  
  21. }  
  22.    
  23. public   class  Main {      
  24.     public   static   void  main(String[] args) {  
  25.         OutterClass outClass = new  OutterClass();  
  26.         outClass.printInPrivate();  
  27.         outClass.printOutPrivate();  
  28.     }  
  29. }  
 
  • 如果外部类的成员变量与内部类的成员变量名字相同，当内部类要访问外部类的该成员时，可以使用“OutClass.this.mem”来区分：

  1. // 外部类   
  2. class  OutterClass {  
  3.     private   int  mMem =  10 ;  
  4.     // 内部类   
  5.     public   class  InnerClass {  
  6.         private   int  mMem =  0 ;  
  7.         public   void  printOutPrivate(){  
  8.             // 直接打印外部类的成员   
  9.             System.out.println(OutterClass.this .mMem);  
  10.         }  
  11.     }  
  12. }  
 
  • 要创建普通内部类，必须先创建相应的外部类：

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


  1. // 外部类   
  2. class  OutterClass {  
  3.     private   int  mMem =  10 ;  
  4.     // 内部类   
  5.     public   class  InnerClass {  
  6.         private   int  mMem =  0 ;  
  7.         public   void  printOutPrivate(){  
  8.             // 直接打印外部类的成员   
  9.             System.out.println(OutterClass.this .mMem);  
  10.         }  
  11.     }  
  12.     public  InnerClass newInnerClass() {  
  13.         return   new  InnerClass();  
  14.     }  
  15. }  
  16.    
  17. public   class  Main {      
  18.     public   static   void  main(String[] args) {  
  19.         OutterClass outClass = new  OutterClass();  
  20.        OutterClass.InnerClass inClass = outClass.newInnerClass();  
  21.         inClass.printOutPrivate();  
  22.     }  
  23. }  
 
2.  静态内部类
普通内部类前面加上static修饰符，就成为静态内部类，静态内部类类似于C++的嵌套类，与普通内部类相比有如下区别：
  • 静态内部类没有指向外部类的引用，外部类对于它来说更像一个名字空间。
  • 普通内部类不能有静态成员，静态方法，或另一个静态内部类；而静态内部类可以有这一切。
  • 静态内部类可以直接创建，不必先创建外部类：

  1. // 外部类   
  2. class  OutterClass {  
  3.     private   int  mMem =  0 ;  
  4.     // 静态内部类   
  5.     static   public   class  InnerClass {  
  6.         private   int  mMem =  0 ;  
  7.         public   void  printOutPrivate(){  
  8.             // 这是错误的   
  9.             // System.out.println(OutterClass.this.mMem);   
  10.         }  
  11.     }  
  12.     public   void  printInPrivate() {  
  13.         InnerClass inClass = new  InnerClass();  
  14.         // 可以直接访问静态内部类的成员   
  15.         System.out.println(inClass.mMem);  
  16.     }  
  17. }  
  18. public   class  Main {      
  19.     public   static   void  main(String[] args) {  
  20.         // 直接创建静态内部类   
  21.         OutterClass.InnerClass inClass = new  OutterClass.InnerClass();  
  22.         inClass.printOutPrivate();  
  23.     }  
  24. }  
 
从上面描述可以看出，静态内部类与一般类没有太大区别，只不过它是放在一个类的里面，这个类相当于它的名字空间，可以防止命名冲突。
3.  局部内部类
Java可以把一个类定义在一个方法里面，甚至是一个{}块里面，它的作用域就在这个块里面：
 

  1. // 外部类   
  2. class  OutterClass {  
  3.     public   void  testLocalInner() {  
  4.         if  ( true )  
  5.         {  
  6.             class  LocalInner {  
  7.                 public   void  proc() {  
  8.                     System.out.println("hello" );  
  9.                 }  
  10.             }  
  11.             // 可以创建使用   
  12.             LocalInner localInner = new  LocalInner();  
  13.             localInner.proc();  
  14.         }  
  15.         // 错误：超出类定义的作用域   
  16.         LocalInner localInner = new  LocalInner();  
  17.         localInner.proc();  
  18.     }  
  19. }  
 
局部内部类的一般用途是实现某个接口，并作为这个接口传出方法被使用：
 

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

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

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

0
顶
0
踩
分享到：
| 需求也有例外
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java语言基础：内部类2.pdf

    java语言基础：内部类2.pdf

    java语言基础：内部类2[整理].pdf

    java语言基础：内部类2[整理].pdf

    java基础 包含:Java入门 基础语法 JAVA 类和对象 JAVA 高级类 等等

    在移动开发中，Android操作系统广泛采用Java语言，开发者可以利用Android SDK创建丰富的手机应用。 总的来说，Java作为一门广泛应用于各领域的编程语言，其基础知识涵盖了从入门到高级的各种概念和技术，无论你是...

    java基础第七章内部类与异常类.doc

    Java 基础第七章内部类与异常类 Java 语言支持在一个类中定义另一个类，这样的类称做内部类。内部类和外嵌类之间存在着紧密的关系：内部类可以访问外嵌类的成员变量和方法，而外嵌类也可以使用内部类声明的对象作为...

    java基础java内部类

    Java 内部类是 Java 语言的一个重要特性，它允许在一个类的内部定义另一个类。内部类的概念在 Java 中有着广泛的应用，特别是在处理复杂的继承问题和实现特定设计模式时。以下将详细介绍 Java 内部类的基本概念、...

    Java__接口、内部类和Java_API基础

    "Java接口、内部类和Java_API基础" Java接口是Java语言中的一个抽象概念，它定义了一组方法的集合，但不提供实现。...这些基础类库为Java语言提供了强大的功能支持，使得Java语言能更好地满足各种编程需求。

    Java语言基础入门教程 Java开发编程基础课程 第12章 内部类和异常处理 共18页.pptx

    ### Java语言基础入门教程：内部类与异常处理 #### 一、内部类概述 内部类是在另一个类的内部定义的类。它具有多种类型，并且能够访问外部类的私有成员，这使得内部类在实现特定功能时非常灵活且强大。 #### 二、...

    Java编程基础：实验手册

    Java编程基础实验手册是针对初学者设计的一份详尽教程，旨在帮助读者掌握Java编程语言的基本概念、语法和实践技能。这份手册涵盖了从环境搭建到编写简单程序的全过程，逐步引导学习者深入理解面向对象编程的核心思想...

    Java应用基础：网友精选25个Java试题分享

    Java作为一门广泛应用于企业级开发、互联网应用以及大数据处理等领域的编程语言，其基础知识的掌握对于初学者和专业开发者都至关重要。"Java应用基础：网友精选25个Java试题分享"是一个集合了Java核心概念与实践操作...

    Java语言基础.ppt

    "Java语言基础" Java语言基础是指Java语言的基本概念和特点。Java语言是面向对象的、简单的、安全的、多线程的、解释型的、与平台无关的编程语言。Java语言的发展经历了从C++到Java的演化过程，面向对象的概念是...

    计算机后端-Java-Java核心基础-第17章 异常处理 04. 复习：内部类.avi

    计算机后端-Java-Java核心基础-第17章 异常处理 04. 复习：内部类.avi

    java语言基础.zip

    这份"java语言基础.zip"压缩包很可能是某内部培训机构的教学资料，旨在帮助初学者掌握Java编程的核心知识。下面，我们将深入探讨Java语言的基础内容。 1. **Java简介**： Java是一种跨平台、面向对象的编程语言，...

    java反射机制 读者基础：具备Java 语言基础

    Java反射机制是Java语言的一个重要特性，它使得Java在运行时具有了动态性，能够获取和操作类的信息，包括类的修饰符、超类、实现的接口、字段和方法等。这种机制允许程序在运行时动态加载未知名称的类，进行字段的...

    Java语言程序设计 基础篇 第八版 带目录

    根据提供的信息，“Java语言程序设计 基础篇 第八版 带目录”这本书主要针对初学者介绍了Java编程的基础知识。尽管提供的具体内容部分只包含了下载链接，我们仍然可以根据书名、描述以及标签来推断出书中可能涵盖的...

    Java语言基础入门教程 Java开发编程基础课程 第8章 内部类和异常处理 共18页.pptx

    ### Java语言基础入门教程：内部类与异常处理 #### 一、内部类概述 内部类是在另一个类的内部定义的类。它具有多种类型，并且能够访问外部类的私有成员，这使得内部类在实现特定功能时非常灵活且强大。 #### 二、...

    java 集合和内部类资料

    Java集合框架是Java编程...总之，这个资料包涵盖了Java集合框架和内部类的基础知识，对于想要深入理解Java编程的开发者来说，是一份宝贵的学习资源。通过学习，你可以提升在处理数据集合和实现复杂设计模式上的能力。

    JAVA_12内部类

    Java内部类是Java编程语言中的一个独特特性，它允许在一个类的定义内部定义另一个类。这种设计模式在处理复杂的对象关系、实现匿名类以及提供更好的封装性时非常有用。在这个"JAVA_12内部类"的学习资料中，我们将会...

    Java高手真经 编程基础卷.part1.rar

    《Java高手真经(编程基础卷):Java核心编程技术》详细讲解了Java语言基础开发中的各种技术，主要内容包括如下。Java开发入门：JDK、JVM、Eclipse、Linux。Java语法基础：类、抽象类、接口、内部类、匿名类、异常、...

    Java高手真经 编程基础卷.part3.rar

    《Java高手真经(编程基础卷):Java核心编程技术》详细讲解了Java语言基础开发中的各种技术，主要内容包括如下。Java开发入门：JDK、JVM、Eclipse、Linux。Java语法基础：类、抽象类、接口、内部类、匿名类、异常、...

Magicbox
Global site tag (gtag.js) - Google Analytics