可以将一个类的定义放在另一个类的定义内部,这就是内部类。

内部类是一个非常有用的特性但又比较难理解使用的特性(鄙人到现在都没有怎么使用过内部类,对内部类也只是略知一二)。

第一次见面

内部类我们从外面看是非常容易理解的,无非就是在一个类的内部在定义一个类。

  1. public class OuterClass {
  2. private String name ;
  3. private int age;
  4. public String getName() {
  5. return name;
  6. }
  7. public void setName(String name) {
  8. this.name = name;
  9. }
  10. public int getAge() {
  11. return age;
  12. }
  13. public void setAge(int age) {
  14. this.age = age;
  15. }
  16. class InnerClass{
  17. public InnerClass(){
  18. name = "chenssy";
  19. age = 23;
  20. }
  21. }
  22. }

在 这里InnerClass就是内部类,对于初学者来说内部类实在是使用的不多,鄙人菜鸟一个同样没有怎么使用过(貌似仅仅只在做swing 注册事件中使用过),但是随着编程能力的提高,我们会领悟到它的魅力所在,它可以使用能够更加优雅的设计我们的程序结构。在使用内部类之间我们需要明白为 什么要使用内部类,内部类能够为我们带来什么样的好处。

一、为什么要使用内部类

为什么要使用内部类?在《Think in java》中有这样一句话:使用内部类最吸引人的原因是:每个内部类都能独立地继承一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。

在我们程序设计中有时候会存在一些使用接口很难解决的问题,这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说,接口只是解决了部分问题,而内部类使得多重继承的解决方案变得更加完整。

  1. public interface Father {
  2. }
  3. public interface Mother {
  4. }
  5. public class Son implements Father, Mother {
  6. }
  7. public class Daughter implements Father{
  8. class Mother_ implements Mother{
  9. }
  10. }

其实对于这个实例我们确实是看不出来使用内部类存在何种优点,但是如果Father、Mother不是接口,而是抽象类或者具体类呢?这个时候我们就只能使用内部类才能实现多重继承了。

其实使用内部类最大的优点就在于它能够非常好的解决多重继承的问题,但是如果我们不需要解决多重继承问题,那么我们自然可以使用其他的编码方式,但是使用内部类还能够为我们带来如下特性(摘自《Think in java》):

      1、内部类可以用多个实例,每个实例都有自己的状态信息,并且与其他外围对象的信息相互独立。

      2、在单个外围类中,可以让多个内部类以不同的方式实现同一个接口,或者继承同一个类。

      3、创建内部类对象的时刻并不依赖于外围类对象的创建。

      4、内部类并没有令人迷惑的“is-a”关系,他就是一个独立的实体。

      5、内部类提供了更好的封装,除了该外围类,其他类都不能访问。

二、内部类基础

在这个部分主要介绍内部类如何使用外部类的属性和方法,以及使用.this与.new。

当我们在创建一个内部类的时候,它无形中就与外围类有了一种联系,依赖于这种联系,它可以无限制地访问外围类的元素。

  1. public class OuterClass {
  2. private String name ;
  3. private int age;
  4. /**省略getter和setter方法**/
  5. public class InnerClass{
  6. public InnerClass(){
  7. name = "chenssy";
  8. age = 23;
  9. }
  10. public void display(){
  11. System.out.println("name:" + getName() +"   ;age:" + getAge());
  12. }
  13. }
  14. public static void main(String[] args) {
  15. OuterClass outerClass = new OuterClass();
  16. OuterClass.InnerClass innerClass = outerClass.new InnerClass();
  17. innerClass.display();
  18. }
  19. }
  20. --------------
  21. Output:
  22. name:chenssy   ;age:23


这个应用程序中,我们可以看到内部了InnerClass可以对外围类OuterClass的属性进行无缝的访问,尽管它是private修饰的。这是因
为当我们在创建某个外围类的内部类对象时,此时内部类对象必定会捕获一个指向那个外围类对象的引用,只要我们在访问外围类的成员时,就会用这个引用来选择
外围类的成员。

其实在这个应用程序中我们还看到了如何来引用内部类:引用内部类我们需要指明这个对象的类型:OuterClasName.InnerClassName。同时如果我们需要创建某个内部类对象,必须要利用外部类的对象通过.new来创建内部类:OuterClass.InnerClass innerClass
= outerClass.new InnerClass();。

同时如果我们需要生成对外部类对象的引用,可以使用OuterClassName.this,这样就能够产生一个正确引用外部类的引用了。当然这点实在编译期就知晓了,没有任何运行时的成本。

  1. public class OuterClass {
  2. public void display(){
  3. System.out.println("OuterClass...");
  4. }
  5. public class InnerClass{
  6. public OuterClass getOuterClass(){
  7. return OuterClass.this;
  8. }
  9. }
  10. public static void main(String[] args) {
  11. OuterClass outerClass = new OuterClass();
  12. OuterClass.InnerClass innerClass = outerClass.new InnerClass();
  13. innerClass.getOuterClass().display();
  14. }
  15. }
  16. -------------
  17. Output:
  18. OuterClass...


这里了我们需要明确一点,内部类是个编译时的概念,一旦编译成功后,它就与外围类属于两个完全不同的类(当然他们之间还是有联系的)。对于一个名为
OuterClass的外围类和一个名为InnerClass的内部类,在编译成功后,会出现这样两个class文件:OuterClass.class
和OuterClass$InnerClass.class。

在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。

三、成员内部类

成员内部类也是最普通的内部类,它是外围类的一个成员,所以他是可以无限制的访问外围类的所有 成员属性和方法,尽管是private的,但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。

在成员内部类中要注意两点,第一:成员内部类中不能存在任何static的变量和方法;第二:成员内部类是依附于外围类的,所以只有先创建了外围类才能够创建内部类。

  1. public class OuterClass {
  2. private String str;
  3. public void outerDisplay(){
  4. System.out.println("outerClass...");
  5. }
  6. public class InnerClass{
  7. public void innerDisplay(){
  8. //使用外围内的属性
  9. str = "chenssy...";
  10. System.out.println(str);
  11. //使用外围内的方法
  12. outerDisplay();
  13. }
  14. }
  15. /*推荐使用getxxx()来获取成员内部类,尤其是该内部类的构造函数无参数时 */
  16. public InnerClass getInnerClass(){
  17. return new InnerClass();
  18. }
  19. public static void main(String[] args) {
  20. OuterClass outer = new OuterClass();
  21. OuterClass.InnerClass inner = outer.getInnerClass();
  22. inner.innerDisplay();
  23. }
  24. }
  25. --------------------
  26. chenssy...
  27. outerClass...

推荐使用getxxx()来获取成员内部类,尤其是该内部类的构造函数无参数时 。


四、局部内部类


这样一种内部类,它是嵌套在方法和作用于内的,对于这个类的使用主要是应用与解决比较复杂的问题,想创建一个类来辅助我们的解决方案,到那时又不希望这个
类是公共可用的,所以就产生了局部内部类,局部内部类和成员内部类一样被编译,只是它的作用域发生了改变,它只能在该方法和属性中被使用,出了该方法和属
性就会失效。

对于局部内部类实在是想不出什么好例子,所以就引用《Think in java》中的经典例子了。

定义在方法里:

  1. public class Parcel5 {
  2. public Destionation destionation(String str){
  3. class PDestionation implements Destionation{
  4. private String label;
  5. private PDestionation(String whereTo){
  6. label = whereTo;
  7. }
  8. public String readLabel(){
  9. return label;
  10. }
  11. }
  12. return new PDestionation(str);
  13. }
  14. public static void main(String[] args) {
  15. Parcel5 parcel5 = new Parcel5();
  16. Destionation d = parcel5.destionation("chenssy");
  17. }
  18. }

定义在作用域内:

  1. public class Parcel6 {
  2. private void internalTracking(boolean b){
  3. if(b){
  4. class TrackingSlip{
  5. private String id;
  6. TrackingSlip(String s) {
  7. id = s;
  8. }
  9. String getSlip(){
  10. return id;
  11. }
  12. }
  13. TrackingSlip ts = new TrackingSlip("chenssy");
  14. String string = ts.getSlip();
  15. }
  16. }
  17. public void track(){
  18. internalTracking(true);
  19. }
  20. public static void main(String[] args) {
  21. Parcel6 parcel6 = new Parcel6();
  22. parcel6.track();
  23. }
  24. }

五、匿名内部类

在做Swing编程中,我们经常使用这种方式来绑定事件

  1. button2.addActionListener(
  2. new ActionListener(){
  3. public void actionPerformed(ActionEvent e) {
  4. System.out.println("你按了按钮二");
  5. }
  6. });

我们咋一看可能觉得非常奇怪,因为这个内部类是没有名字的,在看如下这个例子:

  1. public class OuterClass {
  2. public InnerClass getInnerClass(final int num,String str2){
  3. return new InnerClass(){
  4. int number = num + 3;
  5. public int getNumber(){
  6. return number;
  7. }
  8. };        /* 注意:分号不能省 */
  9. }
  10. public static void main(String[] args) {
  11. OuterClass out = new OuterClass();
  12. InnerClass inner = out.getInnerClass(2, "chenssy");
  13. System.out.println(inner.getNumber());
  14. }
  15. }
  16. interface InnerClass {
  17. int getNumber();
  18. }
  19. ----------------
  20. Output:
  21. 5

这里我们就需要看清几个地方

      1、 匿名内部类是没有访问修饰符的。

      2、 new 匿名内部类,这个类首先是要存在的。如果我们将那个InnerClass接口注释掉,就会出现编译出错。

      3、 注意getInnerClass()方法的形参,第一个形参是用final修饰的,而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过,所以当所在方法的形参需要被匿名内部类使用,那么这个形参就必须为final。

      4、 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。

PS:由于篇幅有限,对匿名内部类就介绍到这里,有关更多关于匿名内部类的知识,我就会在下篇博客(java提高篇-----详解匿名内部类)做详细的介绍,包括为何形参要定义成final,怎么对匿名内部类进行初始化等等,敬请期待……

六、静态内部类


java提高篇-----关键字static中提到Static可以修饰成员变量、方法、代码块,其他它还可以修饰内部类,使用static修饰的内部类
我们称之为静态内部类,不过我们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别,我们知道非静态内部类在编译完成之后会隐含地
保存着一个引用,该引用是指向创建它的外围内,但是静态内部类却没有。没有这个引用就意味着:

      1、 它的创建是不需要依赖于外围类的。

      2、 它不能使用任何外围类的非static成员变量和方法。

  1. public class OuterClass {
  2. private String sex;
  3. public static String name = "chenssy";
  4. /**
  5. *静态内部类
  6. */
  7. static class InnerClass1{
  8. /* 在静态内部类中可以存在静态成员 */
  9. public static String _name1 = "chenssy_static";
  10. public void display(){
  11. /*
  12. * 静态内部类只能访问外围类的静态成员变量和方法
  13. * 不能访问外围类的非静态成员变量和方法
  14. */
  15. System.out.println("OutClass name :" + name);
  16. }
  17. }
  18. /**
  19. * 非静态内部类
  20. */
  21. class InnerClass2{
  22. /* 非静态内部类中不能存在静态成员 */
  23. public String _name2 = "chenssy_inner";
  24. /* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的 */
  25. public void display(){
  26. System.out.println("OuterClass name:" + name);
  27. }
  28. }
  29. /**
  30. * @desc 外围类方法
  31. * @author chenssy
  32. * @data 2013-10-25
  33. * @return void
  34. */
  35. public void display(){
  36. /* 外围类访问静态内部类:内部类. */
  37. System.out.println(InnerClass1._name1);
  38. /* 静态内部类 可以直接创建实例不需要依赖于外围类 */
  39. new InnerClass1().display();
  40. /* 非静态内部的创建需要依赖于外围类 */
  41. OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
  42. /* 方位非静态内部类的成员需要使用非静态内部类的实例 */
  43. System.out.println(inner2._name2);
  44. inner2.display();
  45. }
  46. public static void main(String[] args) {
  47. OuterClass outer = new OuterClass();
  48. outer.display();
  49. }
  50. }
  51. ----------------
  52. Output:
  53. chenssy_static
  54. OutClass name :chenssy
  55. chenssy_inner
  56. OuterClass name:chenssy

上面这个例子充分展现了静态内部类和非静态内部类的区别。

到这里内部类的介绍就基本结束了!对于内部类其实本人认识也只是皮毛,逼近菜鸟一枚,认知有限!我会利用这几天时间好好研究内部类!

巩固基础,提高技术,不惧困难,攀登高峰!!!!!!

java基础之:详解内部类(转载)的更多相关文章

  1. java基础(十三)-----详解内部类——Java高级开发必须懂的

    可以将一个类的定义放在另一个类的定义内部,这就是内部类. 为什么要使用内部类 为什么要使用内部类?在<Think in java>中有这样一句话:使用内部类最吸引人的原因是:每个内部类都能 ...

  2. Java基础数据类型详解

    在Java中的数据类型一共有8种,大致分为整型(4个)浮点型(2个)布尔(1)字符(1个) 分类 类型 默认值 占用字节 范围 整型 byte 0 1 = 8 bit -2^7 - 2^7 short ...

  3. JAVA基础——异常详解

    JAVA异常与异常处理详解 一.异常简介 什么是异常? 异常就是有异于常态,和正常情况不一样,有错误出错.在java中,阻止当前方法或作用域的情况,称之为异常. java中异常的体系是怎么样的呢? 1 ...

  4. java基础:数组详解以及应用,评委打分案例实现,数组和随机数综合,附练习案列

    1.数组 1.1 数组介绍 数组就是存储数据长度固定的容器,存储多个数据的数据类型要一致. 1.2 数组的定义格式 1.2.1 第一种格式 数据类型[] 数组名 示例: int[] arr;     ...

  5. Java基础 - 异常详解

    异常的层次结构 Throwable Throwable 是 Java 语言中所有错误与异常的超类. Throwable 包含两个子类:Error(错误)和 Exception(异常),它们通常用于指示 ...

  6. 【干货】用大白话聊聊JavaSE — ArrayList 深入剖析和Java基础知识详解(二)

    在上一节中,我们简单阐述了Java的一些基础知识,比如多态,接口的实现等. 然后,演示了ArrayList的几个基本方法. ArrayList是一个集合框架,它的底层其实就是一个数组,这一点,官方文档 ...

  7. JAVA基础——数组详解

    学习JAVA中数组的使用 一.什么是数组? 问:编写代码保存 4 名学生的考试成绩. 答:简单啊,定义 4 个变量呗 问:那"计算全年级 400 名学生的考试成绩",肿么办 答: ...

  8. Java基础——枚举详解

    前言: 在第一次学习面向对象编程时,我记得最深的一句话就是“万物皆对象”.于是我一直秉承着这个思想努力的学习着JAVA,直到学习到枚举(Enum)时,看着它颇为奇怪的语法……我一直在想,这TM是个什么 ...

  9. JAVA基础知识详解

    1. JVM是什么 JVM是Java Virtual Mechine的缩写.它是一种基于计算设备的规范,是一台虚拟机,即虚构的计算机. JVM屏蔽了具体操作系统平台的信息(显然,就像是我们在电脑上开了 ...

  10. Java 基础之详解 Java 反射机制

    一.什么是 Java 的反射机制?   反射(Reflection)是Java的高级特性之一,是框架实现的基础,定义:JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法: ...

随机推荐

  1. Mysql 基本操作连接数据库读取信息内容

    <?php header("content-type:text/html; charset=utf-8"); // 数据库配置信息 define("DB_HOST& ...

  2. unity3d基础01

    Unity3d 五大视图: 1 Scene:存放hierarchy中创建的游戏对象,但实际只能看到一部分 *Scene浏览: ①右键进入“飞行模式”,方便查看整个场景 ②选中摄像机,按ALT进入浏览的 ...

  3. cometd的js端代码

    一:js端使用方式 CometD JavaScript的配置.整个API可以通过一个单一的原型名为org.cometd.Cometd的对象来调用.Dojo工具包中有一个名称为dojox.cometd的 ...

  4. EventBus vs Otto vs LiteEventBus

    http://blog.chengyunfeng.com/?p=449 http://litesuits.com/

  5. 2016 - 1- 14 UI阶段学习补充 transform属性详解

    UIView的transform属性 transform是view的一个重要属性,它在矩阵层面上改变view的显⽰状态,能实现view的缩放.旋转.平移等功能.transform是CGAffineTr ...

  6. Chapter 5: Container

    Chapter 5: Container A container is a module that processes the requests for a servlet and populates ...

  7. Node.js的简介和安装

    一.Node.js的简介和安装 a)       什么是Node.js? Node.js是一个开发平台 让JavaScript运行在服务器端的开发平台 ---简单点说就是用JavaScript写服务器 ...

  8. Qemu+gdb跟踪内核源码

    1.编译安装Qemu Qemu源码下载地址:http://wiki.qemu.org/Download linux下可以直接用wget下载: wget http://wiki.qemu.org/dow ...

  9. Python mix-in 组合 ~ 将类组合起来 .

    在一个池塘中有10个乌龟 1 条鱼 . class Turtle: def __init__(self,x): # 在生命对象的时候 说明对象的 数量 . (还是一个对象 . 数量只是该对象的一个属性 ...

  10. JQuery基础DOM操作

    DOM创建节点及节点属性 通过JavaScript可以很方便的获取DOM节点,从而进行一系列的DOM操作.但实际上一般开发者都习惯性的先定义好HTML结构,但这样就非常不灵活了. 试想下这样的情况:如 ...