Java 内部类种类及使用解析

  Java 内部类种类及使用解析

内部类Inner Class

  将相关的类组织在一起,从而降低了命名空间的混乱。

  一个内部类可以定义在另一个类里,可以定义在函数里,甚至可以作为一个表达式的一部分。

Java中的内部类共分为四种

静态内部类static inner class (also called nested class)

成员内部类member inner class

局部内部类local inner class

匿名内部类anonymous inner class

静态内部类Static Inner Class

  最简单的内部类形式。

  类定义时加上static关键字。

  不能和外部类有相同的名字。

  被编译成一个完全独立的.class文件,名称为OuterClass$InnerClass.class的形式。

只可以访问外部类的静态成员和静态方法,包括了私有的静态成员和方法。

  生成静态内部类对象的方式为:

OuterClass.InnerClass inner = new OuterClass.InnerClass();

  静态内部类使用代码:

package com.learnjava.innerclass;

class StaticInner
{
    private static int a = 4;

    // 静态内部类
    public static class Inner
    {
        public void test()
        {
            // 静态内部类可以访问外部类的静态成员
            // 并且它只能访问静态的
            System.out.println(a);
        }

    }
}

public class StaticInnerClassTest
{

    public static void main(String[] args)
    {
        StaticInner.Inner inner = new StaticInner.Inner();
        inner.test();
    }
}

成员内部类Member Inner Class

  成员内部类也是定义在另一个类中,但是定义时不用static修饰。

  成员内部类和静态内部类可以类比为非静态的成员变量和静态的成员变量。

  成员内部类就像一个实例变量。

它可以访问它的外部类的所有成员变量和方法,不管是静态的还是非静态的都可以

  在外部类里面创建成员内部类的实例:

this.new Innerclass();

  在外部类之外创建内部类的实例:

(new Outerclass()).new Innerclass();

  在内部类里访问外部类的成员:

Outerclass.this.member

  详情见代码例子:

package com.learnjava.innerclass;

class MemberInner
{
    private int d = 1;
    private int a = 2;

    // 定义一个成员内部类
    public class Inner2
    {
        private int a = 8;

        public void doSomething()
        {
            // 直接访问外部类对象
            System.out.println(d);
            System.out.println(a);// 直接访问a,则访问的是内部类里的a

            // 如何访问到外部类里的a呢?
            System.out.println(MemberInner.this.a);
        }

    }

}

public class MemberInnerClassTest
{

    public static void main(String[] args)
    {

        // 创建成员内部类的对象
        // 需要先创建外部类的实例
        MemberInner.Inner2 inner = new MemberInner().new Inner2();

        inner.doSomething();
    }
}

局部内部类Local Inner Class

  局部内部类定义在方法中,比方法的范围还小。是内部类中最少用到的一种类型。

  像局部变量一样,不能被public, protected, private和static修饰。

  只能访问方法中定义的final类型的局部变量。

  局部内部类在方法中定义,所以只能在方法中使用,即只能在方法当中生成局部内部类的实例并且调用其方法。

package com.learnjava.innerclass;

class LocalInner
{
    int a = 1;

    public void doSomething()
    {
        int b = 2;
        final int c = 3;
        // 定义一个局部内部类
        class Inner3
        {
            public void test()
            {
                System.out.println("Hello World");
                System.out.println(a);

                // 不可以访问非final的局部变量
                // error: Cannot refer to a non-final variable b inside an inner
                // class defined in a different method
                // System.out.println(b);

                // 可以访问final变量
                System.out.println(c);
            }
        }

        // 创建局部内部类的实例并调用方法
        new Inner3().test();
    }
}

public class LocalInnerClassTest
{
    public static void main(String[] args)
    {
        // 创建外部类对象
        LocalInner inner = new LocalInner();
        // 调用外部类的方法
        inner.doSomething();
    }

}

匿名内部类Anonymous Inner Class

  匿名内部类就是没有名字的局部内部类,不使用关键字class, extends, implements, 没有构造方法。

匿名内部类隐式地继承了一个父类或者实现了一个接口

  匿名内部类使用得比较多,通常是作为一个方法参数。

package com.learnjava.innerclass;

import java.util.Date;

public class AnonymouseInnerClass
{

    @SuppressWarnings("deprecation")
    public String getDate(Date date)
    {
        return date.toLocaleString();

    }

    public static void main(String[] args)
    {
        AnonymouseInnerClass test = new AnonymouseInnerClass();

        // 打印日期:
        String str = test.getDate(new Date());
        System.out.println(str);
        System.out.println("----------------");

        // 使用匿名内部类
        String str2 = test.getDate(new Date()
        {
        });// 使用了花括号,但是不填入内容,执行结果和上面的完全一致
            // 生成了一个继承了Date类的子类的对象
        System.out.println(str2);
        System.out.println("----------------");

        // 使用匿名内部类,并且重写父类中的方法
        String str3 = test.getDate(new Date()
        {

            // 重写父类中的方法
            @Override
            @Deprecated
            public String toLocaleString()
            {
                return "Hello: " + super.toLocaleString();
            }

        });

        System.out.println(str3);
    }
}

  生成的.class文件中,匿名类会生成OuterClass$1.class文件,数字根据是第几个匿名类而类推。

  Swing中使用内部类的例子如下:

package com.learnjava.innerclass;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JButton;
import javax.swing.JFrame;

public class SwingTest
{
    public static void main(String[] args)
    {
        JFrame frame = new JFrame("JFrame");
        JButton button = new JButton("JButton");

        button.addActionListener(new ActionListener()
        {
            // new出来一个实现了ActionListener接口的类的实例

            @Override
            public void actionPerformed(ActionEvent arg0)
            {
                System.out.println("Hello World");

            }
        });

        //加入按钮
        frame.getContentPane().add(button);

        //设置关闭行为
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        frame.setSize(200, 200);
        
        frame.addWindowListener(new WindowAdapter()
        {
            //也可以使用继承了适配器类的匿名内部类
            @Override
            public void windowClosing(WindowEvent e)
            {
            
                System.out.println("Closing");
                System.exit(0);
            }
        });
        frame.setVisible(true);
    }

}

参考资料

  张龙老师Java SE系列视频教程。

  博客早期一篇内部类文章:

http://www.cnblogs.com/mengdd/archive/2012/08/22/2650800.html

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏LanceToBigData

JavaSE(五)JAVA对象向上转型和向下转型

今天做了一个测试的题目,发现自己还是很多问题没有静下心来做。很多问题是可以自己解决的但是自己一是没有读清题意,二是自己心里太急躁了。所以这个要自己应以为鉴!  ...

24060
来自专栏python3

python 面向对象之类方法

类方法通过@classmethod装饰器实现,类方法和普通方法的区别是, 类方法只能访问类变量,不能访问实例变量

7620
来自专栏Golang语言社区

Go 语言数据类型

在 Go 编程语言中,数据类型用于声明函数和变量。 数据类型的出现是为了把数据分成所需内存大小不同的数据,编程的时候需要用大数据的时候才需要申请大内存,就可以充...

32670
来自专栏程序员互动联盟

【答疑解惑】Java中重载和重写的区别

今天群里有网友搞不清楚一个问题: ? 重载和重写属于Java面向对象中多态基础知识点,下面就给大家说说多态。 什么叫做多态? 多态指的是在继承关系中子类继承父类...

31470
来自专栏鸿的学习笔记

python的迭代器和生成器

迭代是数据处理的基础,迭代可以理解为是一种惰性求值。在python里迭代器和生成器是一回事,使用的是yield关键字。

8010
来自专栏JetpropelledSnake

Python入门之面向对象编程(二)python类的详解

本文通过创建几个类来覆盖python中类的基础知识,主要有如下几个类 Animal :各种属性、方法以及属性的修改 Dog :将方法转化为属性并操作的方法 Ca...

32590
来自专栏黑泽君的专栏

java基础学习_面向对象(下)02_day09总结

============================================================================= ==...

10020
来自专栏yl 成长笔记

链表

链表定义:一种递归的数据结构, 它是在集合类的抽象数据,它或者为空, 或者是指向一个节点 (node) 的引用, 该结点含有一个泛型的元素和一个指向另一条链表的...

20110
来自专栏ios 技术积累

Java 重写(Override)与重载(Overload)总结

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。 重写的好处在于子类可以根据需要,定义特定于自己的行为。 也就是说子类能够根...

14920
来自专栏jojo的技术小屋

原 三、基本概念

作者:汪娇娇 时间:2017年11月4日 一、语法 1、区分大小写 2、标识符 指变量、函数、属性的名字,采用驼峰大小写格式。 3、注释 单行:// 多行:/*...

26850

扫码关注云+社区

领取腾讯云代金券