Java编程思想学习笔记1 - 内部类

最新推荐文章于 2019-01-09 09:28:40 发布
最新推荐文章于 2019-01-09 09:28:40 发布
阅读量103 收藏
点赞数

内部类简单来说就是定义在一个类内部的类。一直很难理解为什么要使用内部类，对内部类的理解始终停留在表明。今天详细学习了Java内部类的机制，总结下内部类的使用。归纳大纲如下： 
1. 内部类的基础结构 
2. 内部类的优点和使用场景 
3. 内部类的分类 
4. 内部类的继承 
若有不正之处，请批评指教，共同成长！请尊重作者劳动成果，转载请标明原文链接



1. 内部类的基础结构 

package c10; public class Parcel1 { class Contents { private int i = 11; public int value(){ return i;
        }
    }

    class Destination { private String label;
        Destination (String whereTo) {
            label = whereTo;
        }
        String readLabel() { return label;
        }
    } public void ship(String dest) {
        Contents c = new Contents();
        Destination d = new Destination(dest);
        System.out.println(d.readLabel());
    } public static void main(String[] args) {

        Parcel1 p = new Parcel1();
        Parcel1.Contents contents = p.new Contents();
        Parcel1.Destination dest = p.new Destination("Tasmania");
    }   
}

输出结果：Tasmania
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

内部类其实是一个编译时的概念（内部类与普通类的不同体现在编译上），如上例所示，编译完成后，分别生成三个class文件：Parcel1.class, Parcel1$Contents.class, Destination$Contents.class。 
.class文件包含了如何创建该类型对象的全部信息。内部类生成的.class文件有严格的规则：外部类名称+$+内部类名称。如果是匿名内部类，编译器会简单地产生一个数字作为其表示符，如Parcel1$1.class.

2. 内部类的优点和使用场景

Thinking in Java中通过一个章节详细讨论了为什么需要内部类，可能是因为笔者的理解能力有限，直到今天也无法明确体会作者的意思，总结起来有以下这些： 
1. 内部类最吸引人的原因是：每个内部类都能独立继承一个（接口或类）的实现，所以无论外围类是否已经继承了某个（接口或类）实现，对于内部类都没有影响 
2. 内部类可以有多个实例，每个实例都有自己的状态信息，并且与外围类对象的信息相互独立 
3. 单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或集成同一个类 
4. 内部类并没有令人迷惑的”is-a”关系，是一个独立的实体 
也就是说通过内部类可以变相的实现类的多重继承（我们知道Java中只能引用多个接口，而不能继承多个类）。比如这样： 

//基类A、B、C class A {} abstract class B {}
class C {} //派生类通过内部类同时继承ABC class Z extends A {
    class Z1 extends B{
        C makeC() { return new C(){}; }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

也看了网上各位大神的文章，总结归纳，自己对为什么使用内部类的理解是这样的：

使用内部类会破坏良好的代码结构（第一次看到会觉得怪怪的），但为类的设计者提供了一种途径来隐藏类的实现细节（这些往往是客户端程序员所不关注的），同时也是代码变的更加灵活。

3. 内部类的分类

笔者认为内部类之所以很难理解，正是因为语法覆盖了大量难以理解的技术（如果都像基础内部类那样，就没有多少意思了）。内部类可以分为四种：成员内部类，局部内部类，嵌套类，匿名内部类。

  • 静态内部类的应用场景是：只可以访问外部类的静态成员变量和静态成员方法。
  • 成员内部类的应用场景是：它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。
  • 局部内部类：像局部变量一样，不能被public, protected, 
    private和static修饰。只能访问方法中定义的final类型的局部变量。
  • 匿名内部类：匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements,没有构造方法。匿名内部类隐式地继承了一个父类或者实现了一个接口。匿名内部类使用得比较多，通常是作为一个方法参数。

成员内部类

成员内部类拥有对外部类所有元素的访问权。 
在成员内部类要引用外部类对象时，使用outer.this来表示外部类对象； 
而需要创建内部类对象，可以使用outer.inner obj = outer.new inner(); 
（注意，在拥有外部类对象之前是不可能创建内部类对象的，除非你创建的是嵌套类） 
举个例子： 

package c10; public class Parcel { private int num = 11;

    class Contents { private int num = 12; public void print() { int num = 13;
            System.out.println("局部变量：" + num);
            System.out.println("内部局部变量：" + this.num);
            System.out.println("外部局部变量：" + Parcel.this.num);
        }

    } public static void main(String[] args) {
        Parcel p = new Parcel();
        Parcel.Contents c = p.new Contents();
        c.print();
    }
}

局部变量：13 内部局部变量：12 外部局部变量：11
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

局部内部类

当你要解决一个复杂的问题，想创建一个类来辅助你的解决方案，但又不希望这个类是公共可用的时，可以通过以下方式实现：

  • 一个定义在方法中的类
  • 一个定义在作用域内的类
  • 一个实现了接口的匿名类
  • 一个扩展了非默认构造器的匿名类
  • 执行字段初始化的匿名类

定义在方法中的内部类： 

public class Parcel5 { public Destination destination(String s) { 
        class PDestination implements Destination { private String label; private PDestination(String whereTo) { 
                label = whereTo; 
            } public String readLabel() { return label; 
            } 
        } return new PDestination(s); 
    } public static void main(String[] args) { 
        Parcel4 p = new Parcel4(); 
        Destination d = p.destination("Tasmania"); 
    } 
} 

Tasmania
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

PDestination类是destination()方法的一部分，在之外不能被访问。注意return语句中的向上转型，返回的是Destination的引用，它是PDestination的基类。

定义在作用域中的内部类： 

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

匿名内部类

一个匿名内部类的例子如下，匿名类是内部类比较常用的方式，简化了代码，更加灵活： 

package c10; //注释后，编译报错：Contents cannot be resolved to a type //interface Contents { } public class Parcel7 { public Contents contents() { return new Contents() { private int i = 11; public int value(){ return i; }
        };
    } public static void main(String[] args) {
        Parcel7 p = new Parcel7();
        Contents c = p.contents();
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

需要注意： 
1. new匿名类前，这个类需要定义，否则编译报错； 
2. 当所在的方法的形参需要被内部类里面使用时，该形参必须为final，否则编译报错，如下例所示： 

package c10;

interface Destination {} public class Parcel10 { public Destination destination( final String dest,final float price) { return new Destination() { private int cost;
            {
                cost = Math.round(price); if( cost > 100 ) {
                    System.out.println("Over budget");
                }
            } private String label = dest; public String readLabel() { return label; }

        };
    } public static void main(String[] args) {
        Parcel10 p = new Parcel10();
        Destination d = p.destination("Nanjing", 101.396F);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

通过匿名内部类，可以写出一个完美的工厂模式： 

package c10;

interface Service { void method1(); void method2();
}

interface ServiceFacotry {
    Service getService();
}

class Implementation1 implements Service { private Implementation1() {} @Override public void method1() {
        System.out.println("Implementation1 method1");      
    } @Override public void method2() {
        System.out.println("Implementation1 method2");          
    } public static ServiceFacotry factory = new ServiceFacotry() { @Override public Service getService() { return new Implementation1();
                }
            };
}

class Implementation2 implements Service { private Implementation2() {} @Override public void method1() {
        System.out.println("Implementation2 method1");      
    } @Override public void method2() {
        System.out.println("Implementation2 method2");          
    } public static ServiceFacotry factory = new ServiceFacotry() { @Override public Service getService() { return new Implementation2();
                }
            };
} public class Factories { public static void serviceConsumer(ServiceFacotry fact) {
        Service s = fact.getService();
        s.method1();
        s.method2();
    } public static void main(String[] args) {
        serviceConsumer(Implementation1.factory);
        serviceConsumer(Implementation2.factory);
    }
}

Implementation1 method1
Implementation1 method2
Implementation2 method1
Implementation2 method2
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67

嵌套类

如果不需要内部类对象与其外部类对象之间有联系，那么可以将内部类声明为static。嵌套类意味着： 
1. 要创建嵌套类的对象，并不需要先创建外部类的对象 
2. 不能从嵌套类的对象中访问非静态的外部类对象 
3. 嵌套类和普通的内部类还有一个区别：普通内部类不能有static数据和static属性，也不能包含嵌套类，但嵌套类可以。而嵌套类不能声明为private，一般声明为public，方便调用。 

package c10; public class Parcel11 { private static int age = 12; static class Contents { public void print() {
            System.out.println(age);
        }
    } public static void main(String[] args) {
        Contents c = new Contents();
        c.print();
    }
} 12
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

4. 内部类的继承

内部类的继承，是指内部类被继承，普通类extends内部类。而这时候代码上要有点特别处理，具体看以下例子： 

public class InheritInner extends WithInner.Inner { // InheritInner() 是不能通过编译的，一定要加上形参  InheritInner(WithInner wi) { 
        wi.super(); 
    } public static void main(String[] args) { 
        WithInner wi = new WithInner(); 
        InheritInner obj = new InheritInner(wi); 
    } 
} 

class WithInner { 
    class Inner {  
    } 
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

可以看到子类的构造函数里面要使用父类的外部类对象.super();而这个对象需要从外面创建并传给形参。

参考资料

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/31541037/viewspace-2157004/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/31541037/viewspace-2157004/

congxiu2052
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java编程思想学习笔记4 - 序列化技术
皖南笑笑生的博客
06-24 2283
今天来学习下Java序列化和反序列化技术，笔者对《Java编程思想》中的内容，结合网上各位前辈的帖子进行了整理和补充，包括： 序列化概述 Java原生序列化技术 Hessian序列化技术 JSON序列化技术 Java XML序列化技术 笔者将Hession、Json、XML都归为是一种序列化技术（序列化的本质是“轻量级持久化”，而Hession、Json、XML都属于这个范畴，Hessia...
《Java编程思想》第十章 内部类
01-20
本系列是我本人阅读java编程思想这本书的读书笔记，主要阅读第五章到第十七章以及第二十一章的内容，今天的笔记是第十章 java中有一种类叫内部类，这一章我们就来了解一下什么是内部类以及内部类的一些特性。 1.创建...
《Java编程思想》学习笔记3——内部类
Tony Chen的专栏
08-20 3016
1.java中，可以将一个类的定义放在另一个类的内部，这种叫做内部类。 内部类允许编程人员将逻辑上相关的类组织在一起，并且控制内部类对其他类的可见性。 2.在外部类的非静态方法中创建内部类的对象语法： 外部类类名.内部类类名 对象名 = 外部类对象.new 内部类类名(); 如： public class Outter{ class inner{ } } Outter out = ne
《Java编程思想》学习笔记：内部类
井方哥的博客
02-08 756
我们可以在一个类的创建多个内部类，相当于带了很多小弟，这些小弟总得认识自己的老大是谁吧（指向外围类对象的引用），这些小弟可以共享我的资源，同时，这些小弟都很优秀，能够独立完成我交给他们的某些工作（一个实现）
《java编程思想》学习笔记——内部类一
weixin_34323858的博客
11-22 89
2019独角兽企业重金招聘Python工程师标准>>> ...
《java编程思想》学习笔记——内部类三
weixin_33868027的博客
11-22 95
2019独角兽企业重金招聘Python工程师标准>>> ...
JAVA编程思想学习笔记（九）内部类
qq4131533523的博客
01-09 239
内部类 创建内部类 定义：可以将一个类的定义放在另一个类的定义内部，这就是内部类。 创建方式： 其中B就是A的内部类 class A{ class B{ ... } ... } 如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象，那么必须具体地指明这个对象的类型：OuterClassName.InnerClassName 链接到外部类 当生成一个内部类的对象时，此对象与制造它的...
Java基础内容-内部类学习笔记
03-21
根据老师讲解写的笔记
Java编程思想-笔记.docx
06-21
《java编程思想》学习笔记
JAVA并发编程实践-线程池-学习笔记
07-22
当调用 start 启动线程时 Java 虚拟机会调 用该类的 run方法。 那么该类的 run() 方法中就是调用了 Runnable 对象的 run() 方法。 我 们可以继承重写Thread 类，在其 start 方法中添加不断循环调用传递过来的 ...
Java编程思想读书笔记.pdf
11-27
Java编程思想读书笔记.pdf
《java编程思想》学习笔记——内部类五
weixin_33859665的博客
12-01 109
2019独角兽企业重金招聘Python工程师标准>>> ...
java编程思想学习笔记（第十章：内部类）
nbalive2010的博客
07-13 227
内部类定义：将一个类的定义放在另一个类的定义内部。 注意：内部类和组合是完全不同的概念，这一点很重要。 10.1、创建内部类 public class Parcel1 { class Contents { private int i = 11; public int value() { return i; } } class Destination { p
《java编程思想》学习笔记——内部类二
weixin_34226182的博客
11-22 85
2019独角兽企业重金招聘Python工程师标准>>> ...
pd16.py11111111111
最新发布
06-02
pd16.py11111111111
u-boot-2024.07-rc3.tar.bz2
06-02
【U-Boot 2024.07源码深度解析】002 - 下载及编译 U-Boot 源码 https://blog.csdn.net/Ciellee/article/details/139381921 配套的资源
287_基于移动端选课系统的设计与实现-源码.zip
06-02
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
4_New Project_2024-05-28_touch_test.eprj
06-02
4_New Project_2024-05-28_touch_test.eprj
intel_openmp-2021.3.0-py2.py3-none-win_amd64.whl
06-01
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
269_基于微信小程序校园餐饮服务系统的设计与实现-源码.zip
06-02
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值