package com.company;

/**
 * Created by Administrator on 2016/8/23.
 */
public class Outter {//生成的字节码文件是Outter.class
    /**
     * 嵌套的概念
     * 类中除了变量和方法之外,还可以定义一个类
     * 这个类就是内部类,就是嵌套
     *
     * 调用内部类 需要创建内部类的对象
     * */
    private int a=1;     //内部类可以调用外部类的成员,外部类不可以调用内部类的成员。
    private int b=1;
    public void a(){
        System.out.println("外部类a方法");
    }

    class Inner{//生成的字节码文件Outter$Inner.class
        //内部类中的成员与外部类的成员同名的话,则采用就近原则,使用内部类的成员。
        int b=2;
        public void b(){
            int b=3;
            System.out.println("内部类b方法,调用外部类的变量a="+a + "\n内部类调用外部类的a方法:");
            a();
            //如果要调用外部类中与内部类中重名的成员则采用
            System.out.println("外部类中的b="+Outter.this.b);
            System.out.println("内部类中的b="+this.b);
            System.out.println("函数中的b="+b);
        }
    }
}
package com.company;
/**
 * 同一个包下面,普通类创建对象市可以直接调用
 * 但是内部类就需要使用import引入
 * */

//import com.company.Outter.Inner;

public class Main {
    public static void main(String[] args)
    {
        Outter outter=new Outter();
        outter.a();
        /*
        * 不可以通过外部类对象去调用内部类中的变量和方法。
        *
        * 创建内部类对象的错误写法:
        *   Inner a=new Inner(); //错误的写法
        *   没有父类,就没有子类。
        *   同样没有外部类的对象,就不能创建内部类的对象
        *
        * 创建内部类对象的正确方法:
        *     通过外部类的对象创建内部类的对象
        *     写法一:
        *       Outter.Inner b=outter.new Inner();//正确的写法
        *     写法二:
        *       Outter.Inner b=new Outter().new Inner();//正确的写法   匿名的概念
        *       通过这种方式创建的外部类对象没有引用,是不能使用外部类里面的变量和方法
        *
        * */
        Outter.Inner b=new Outter().new Inner();
        b.b();
    }
}

运行效果:

外部类a方法
内部类b方法,调用外部类的变量a=1
内部类调用外部类的a方法:
外部类a方法
外部类中的b=1
内部类中的b=2
函数中的b=3

Process finished with exit code 0

匿名内部类


package com.company;

/**
 * Created by Administrator on 2016/8/23.
 */
public abstract class Computer {
    /**
     * 抽象类不能够创建出抽象类的对象
     * */
    public abstract void Internet();
    public abstract void WatchTV();
}
package com.company;
/**
 * 同一个包下面,普通类创建对象市可以直接调用
 * 但是内部类就需要使用import引入
 * */

//import com.company.Outter.Inner;

public class Main {
    public static void main(String[] args)
    {
        /**
         * 内名内部类
         * 这个下面其实是有一个类存在的,但是我们却看不见类的任何影子 没有名字,也看不到class关键字
         * 这个类没有名字,是一个一次性的
         * 证据就是在编译后的目录中会发现多出来一个名为Main$1.class 这个是系统为它命名的
         * 相当于创建出了一个匿名的内部类,继承了抽象类Computer并且实现了抽象类的抽象方法。
         * 我们创建出的是抽象类的子类的对象
         * */
        Computer computer=new Computer() {
            /**
             * 不能够创建出抽象类对象的说法是正确的
             * 这里是匿名的概念
             * 内名内部类
             * */
            @Override
            public void Internet() {
                System.out.println("我是Computer的子类,我可以上网");
            }

            @Override
            public void WatchTV() {
                System.out.println("我是Computer的子类,我可以看电视");
            }
        };
        computer.Internet();
        computer.WatchTV();
    }
}

执行结果:

我是Computer的子类,我可以上网
我是Computer的子类,我可以看电视

Process finished with exit code 0


接口的匿名内部类的原理也是这样的。应该注意的是:形式上写法是一样的,但是接口是没有构造方法的。

package com.company;

/**
 * Created by Administrator on 2016/8/23.
 */
public interface Standard {
    public final static int a=5;   //前面的都可以省略
    int b=5;
    public abstract void USBStandard();
    void CableStandard();
    void PowerStandard();
}
package com.company;

public class Main {
    public static void main(String[] args) {
        Standard pc=new Standard() {
            @Override
            public void USBStandard() {
                System.out.println("我是USB接口!吼吼!");
            }

            @Override
            public void CableStandard() {
                System.out.println("我是网线接口!吼吼!");
            }

            @Override
            public void PowerStandard() {
                System.out.println("我是电源接口!吼吼!");
            }
        };
        pc.USBStandard();     pc.CableStandard();     pc.PowerStandard();
  } }

运行结果

我是USB接口!吼吼!
我是网线接口!吼吼!
我是电源接口!吼吼!

Process finished with exit code 0

提起Java内部类(Inner Class)可能很多人不太熟悉,实际上类似的概念在C++里也有,那就是嵌套类(Nested Class),关于这两者的区别与联系,在下文中会有对比。内部类从表面上看,
就是在类中又定义了一个类(下文会看到,内部类可以在很多地方定义),而实际上并没有那么简单,乍看上去内部类似乎有些多余,它的用处对于初学者来说可能并不是那么显著,
但是随着对它的深入了解,你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类,是掌握Java高级编程的一部分,它可以让你更优雅地设计你的程序结构。
下面从以下几个方面来介绍:
第一次见面

  1. public interface Contents {
  2. int value();
  3. }
  4. public interface Destination {
  5. String readLabel();
  6. }
  7. public class Goods {
  8. private class Content implements Contents {
  9. private int i = 11;
  10. public int value() {
  11. return i;
  12. }
  13. }
  14. protected class GDestination implements Destination {
  15. private String label;
  16. private GDestination(String whereTo) {
  17. label = whereTo;
  18. }
  19. public String readLabel() {
  20. return label;
  21. }
  22. }
  23. public Destination dest(String s) {
  24. return new GDestination(s);
  25. }
  26. public Contents cont() {
  27. return new Content();
  28. }
  29. }
  30. class TestGoods {
  31. public static void main(String[] args) {
  32. Goods p = new Goods();
  33. Contents c = p.cont();
  34. Destination d = p.dest("Beijing");
  35. }
  36. }

在这个例子里类Content和GDestination被定义在了类Goods内部,并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容,而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里,直接用 Contents c和Destination d进行操作,你甚至连这两个内部类的名字都没有看见!这样,内部类的第一个好处就体现出来了 隐藏你不想让别人知道的操作,也即封装性。同时,我们也发现了在外部类作用范围之外得到内部类对象的第一个方法,那就是利用其外部类的方法创建并返回。
上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢?当然有,其语法格式如下:

  1. outerObject=new outerClass(Constructor Parameters);
  2. outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);

注意在创建非静态内部类对象时,一定要先创建起相应的外部类对象。至于原因,也就引出了我们下一个话题 非静态内部类对象有着指向其外部类对象的引用,对刚才的例子稍作修改:

  1. public class Goods {
  2. private valueRate = 2;
  3. private class Content implements Contents {
  4. private int i = 11 * valueRate;
  5. public int value() {
  6. return i;
  7. }
  8. }
  9. protected class GDestination implements Destination {
  10. private String label;
  11. private GDestination(String whereTo) {
  12. label = whereTo;
  13. }
  14. public String readLabel() {
  15. return label;
  16. }
  17. }
  18. public Destination dest(String s) {
  19. return new GDestination(s);
  20. }
  21. public Contents cont() {
  22. return new Content();
  23. }
  24. }

修改的部分用蓝色显示了。在这里我们给Goods类增加了一个private成员变量valueRate,意义是货物的价值系数,在内部类Content的方法value()计算价值时把它乘上。
我们发现,value()可以访问valueRate,这也是内部类的第二个好处 一个内部类对象可以访问创建它的外部类对象的内容,甚至包括私有变量!
这是一个非常有用的特性,为我们在设计时提供了更多的思路和捷径。要想实现这个功能,内部类对象就必须有指向外部类对象的引用。
Java编译器在创建内部类对象时,隐式的把其外部类对象的引用也传了进去并一直保存着。
这样就使得内部类对象始终可以访问其外部类对象,同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。
有人会问,如果内部类里的一个成员变量与外部类的一个成员变量同名,也即外部类的同名成员变量被屏蔽了,怎么办?没事,Java里用如下格式表达外部类的引用:
outerClass.this 
有了它,我们就不怕这种屏蔽的情况了。
静态内部类
和普通的类一样,内部类也可以有静态的。不过和非静态内部类相比,区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了,Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上,当然从设计的角度以及以它一些细节来讲还有区别。
除此之外,在任何非静态内部类中,都不能有静态数据,静态方法或者又一个静态内部类(内部类的嵌套可以不止一层)。
不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。
局部内部类 
是的,Java内部类也可以是局部的,它可以定义在一个方法甚至一个代码块之内。

  1. public class Goods1 {
  2. public Destination dest(String s) {
  3. class GDestination implements Destination {
  4. private String label;
  5. private GDestination(String whereTo) {
  6. label = whereTo;
  7. }
  8. public String readLabel() {
  9. return label;
  10. }
  11. }
  12. return new GDestination(s);
  13. }
  14. public static void main(String[] args) {
  15. Goods1 g = new Goods1();
  16. Destination d = g.dest("Beijing");
  17. }
  18. }

上面就是这样一个例子。在方法dest中我们定义了一个内部类,最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部,就可以这样做。当然,定义在方法中的内部类可以使设计多样化,用途绝不仅仅在这一点。
下面有一个更怪的例子:

  1. public class Goods2 {
  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("slip");
  14. String s = ts.getSlip();
  15. }
  16. }
  17. public void track() {
  18. internalTracking(true);
  19. }
  20. public static void main(String[] args) {
  21. Goods2 g = new Goods2();
  22. g.track();
  23. }
  24. }

你不能在if之外创建这个内部类的对象,因为这已经超出了它的作用域。不过在编译的时候,内部类TrackingSlip和其他类一样同时被编译,只不过它由它自己的作用域,超出了这个范围就无效,除此之外它和其他内部类并没有区别。
匿名内部类 
java的匿名内部类的语法规则看上去有些古怪,不过如同匿名数组一样,当你只需要创建一个类的对象而且用不上它的名字时,使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的:
new interfacename(){......}; 或 new superclassname(){......}; 
下面接着前面继续举例子:

  1. public class Goods3 {
  2. public Contents cont() {
  3. return new Contents() {
  4. private int i = 11;
  5. public int value() {
  6. return i;
  7. }
  8. };
  9. }
  10. }

这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象,看上去的确十分简洁。
在java的事件处理的匿名适配器中,匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码:

  1. frame.addWindowListener(new WindowAdapter(){
  2. public void windowClosing(WindowEvent e){
  3. System.exit(0);
  4. }
  5. });

有一点需要注意的是,匿名内部类由于没有名字,所以它没有构造函数(但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类,创建它的时候必须带上这些参数,并在实现的过程中使用super关键字调用相应的内容)。如果你想要初始化它的成员变量,有下面几种方法:
如果是在一个方法的匿名内部类,可以利用这个方法传进你想要的参数,不过记住,这些参数必须被声明为final。
将匿名内部类改造成有名字的局部内部类,这样它就可以拥有构造函数了。 
在这个匿名内部类中使用初始化代码块。 
为什么需要内部类? 
java内部类有什么好处?为什么需要内部类?
首先举一个简单的例子,如果你想实现一个接口,但是这个接口中的一个方法和你构想的这个类中的一个方法的名称,参数相同,你应该怎么办?这时候,你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的,所以这样做可以完成所有你直接实现这个接口的功能。
不过你可能要质疑,更改一下方法的不就行了吗?
的确,以此作为设计内部类的理由,实在没有说服力。
真正的原因是这样的,java中的内部类和接口加在一起,可以的解决常被C++程序员抱怨java中存在的一个问题 没有多继承。实际上,C++的多继承设计起来很复杂,而java通过内部类加上接口,可以很好的实现多继承的效果。

JAVA 第二天 内部类的更多相关文章

  1. Java 中的内部类

    前言 在第一次把Java 编程思想中的内部类这一章撸完后,有点印象.大概知道了什么时内部类,局部内部类,匿名内部类,嵌套内部类.随着时间的推移,自己慢慢的就忘记了,总感觉自己思考的东西不多,于是 看了 ...

  2. 【转】Java中的内部类和匿名类

       Java内部类(Inner Class),类似的概念在C++里也有,那就是嵌套类(Nested Class),乍看上去内部类似乎有些多余,它的用处对于初学者来说可能并不是那么显著,但是随着对它的 ...

  3. Java学习笔记二十:Java中的内部类

    Java中的内部类 一:什么是内部类: (1).什么是内部类呢? 内部类( Inner Class )就是定义在另外一个类里面的类.与之对应,包含内部类的类被称为外部类. (2).那为什么要将一个类定 ...

  4. 学习Java第二周

    这是学习java的第二周,又这样不知不觉的结束了 上周想要学习的这一周也都做到了,可是觉得进度有些慢了,学习了: 1. 接口和抽象类: 2. 集合与数组: 3. 方法的定义: 4. 递归算法: 5.对 ...

  5. [java] 深入理解内部类: inner-classes

    [java] 深入理解内部类: inner-classes // */ // ]]>   [java] 深入理解内部类: inner-classes Table of Contents 1 简介 ...

  6. JAVA第二次作业展示与学习心得

    JAVA第二次作业展示与学习心得 在这一次作业中,我学习了复选框,密码框两种新的组件,并通过一个邮箱登录界面将两种组件运用了起来.具体的使用方法和其他得组件并没有什么大的不同. 另外我通过查阅资料使用 ...

  7. Java中的内部类(成员内部类、静态内部类、局部内部类、匿名内部类)

    Java中的内部类(成员内部类.静态内部类.局部内部类.匿名内部类) 神话丿小王子的博客主页 我们先看这样一段话:人是由大脑.肢体.器官等身体结果组成.而组成我们人体的心脏它也有自己的属性和行为(血液 ...

  8. java基础之 内部类

    Java中的内部类共分为四种: 静态内部类static inner class (also called nested class) 成员内部类member inner class 局部内部类loca ...

  9. java 笔记(2) —— 内部类的作用

    一.内部类简介 个人觉得内部类没多少研究价值,GUI中的事件响应算是非常典型的应用了. Java内部类其实在J2EE编程中使用较少,不过在窗口应用编程中特别常见,主要用来事件的处理.其实,做非GUI编 ...

随机推荐

  1. 新概念英语(1-57)An unusual day

    新概念英语(1-57)An unusually day What is Mr. Sawyer doing tonight? It is eight o'clock. The children go t ...

  2. 【iOS】 含tableView的ViewController基类的实现

    上篇博客写了ViewController的基类的实现,这篇博客主要写在BaseViewController的基础上实现一个含tableView控件的基类的实现,主要给包含tableView的页面来继承 ...

  3. 基于哈夫曼编码的文件压缩(c++版)

    本博客由Rcchio原创 我了解到很多压缩文件的程序是基于哈夫曼编码来实现的,所以产生了自己用哈夫曼编码写一个压缩软件的想法,经过查阅资料和自己的思考,我用c++语言写出了该程序,并通过这篇文章来记录 ...

  4. 编程基础学习JS的入门教程

    将JavaScript 插入网页的方法 使用<script>标签在网页中插入Javascript代码. 插入JavaScript 与在网页中插入CSS的方式相似.使用下面的代码可以在网页中 ...

  5. Linux下内存问题检测神器:Valgrind

    在写大型C/C++工程时难免会发生内存泄漏现象,系统编程中一个重要的方面就是有效地处理与内存相关的问题.你的工作越接近系统,你就需要面对越多的内存问题.有时这些问题非常琐碎,而更多时候它会演变成一个调 ...

  6. 【转】如何使用slave_exec_mode优雅的跳过1032 1062的复制错误

    今天线上的主从复制发生1062的错误,使用sql_slave_skip_counter跳过之后,由于后面的事务需要对刚刚的数据进行update,后续造成了新的1032的错误. 后来,无意中发现还有更好 ...

  7. [LeetCode] Prime Number of Set Bits in Binary Representation 二进制表示中的非零位个数为质数

    Given two integers L and R, find the count of numbers in the range [L, R] (inclusive) having a prime ...

  8. HttpClient入门一

    HttpClient是一个实现了Http协议的功能强大的编程工具包. 要使用HttpClient,通常需要以下几部: 1.常见一个HttpClient实例 2.创建一个get或者post方法 3.告诉 ...

  9. ●BZOJ 3676 [Apio2014]回文串

    题链: http://www.lydsy.com/JudgeOnline/problem.php?id=3676 题解: 后缀数组,Manacher,二分 首先有一个结论:一个串的本质不同的回文串的个 ...

  10. 2015 多校联赛 ——HDU5372(树状数组)

    Sample Input 3 0 0 0 3 0 1 5 0 1 0 0 1 1 0 1 0 0   Sample Output Case #1: 0 0 0 Case #2: 0 1 0 2 有0, ...