Java基础之（二十二）内部类

最新推荐文章于 2023-03-02 12:25:08 发布
最新推荐文章于 2023-03-02 12:25:08 发布
阅读量568 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jxq1994/article/details/52195885
版权

说明
在 Java 中，允许在一个类（或方法、语句块）的内部定义另一个类，称为内部类(Inner Class)，有时也称为嵌套类(Nested Class)。包含内部类的类也被称为外部类（Outer Class），或者宿主类（Hast Class）。

内部类和外层封装它的类之间存在逻辑上的所属关系，一般只用在定义它的类或语句块之内，实现一些没有通用意义的功能逻辑，在外部引用它时必须给出完整的名称。

非静态内部类

定义内部类非常简单，只要把一个类放在另一个类内部定义即可。此处的“类内部”包含类中的任何位置，甚至在方法中也可以定义内部类（方法里定义的内部类被称为局部内部类），内部类定义语法格式如下：

public class outerClass{
    //此处定义内部类
}

大部分时候，内部类都被作为成员内部类定义。成员内部类是一种与Field、方法、构造器和初始化块相似的类成员；局部内部类和匿名内部类则不是类成员。

成员内部类分为两种：静态内部类和非静态内部类，使用static修饰的成员内部类是静态内部类。

因为内部类作为其外部类的成员，所以可以使用任意访问控制修饰符如private、protected、public等修饰。

请看下面的例子： 

public class Outer {
    private int size;
    public class Inner {
        private int counter = 10;
        public void doStuff() {
            size++;
        }
    }
    public static void main(String args[]) {
        Outer outer = new Outer();
        Inner inner = outer.new Inner();
        inner.doStuff();
        System.out.println(outer.size);
        System.out.println(inner.counter);
        // 编译错误，外部类不能访问内部类的变量
        System.out.println(counter);
    }
}

这段代码定义了一个外部类 Outer，它包含了一个内部类 Inner。

在非静态内部类里可以直接使用外部类的所有变量和方法，即使是 private 的。外部类要想访问内部类的成员变量和方法，则需要通过内部类的对象来获取。

将错误语句注释掉，编译，会生成两个 .class 文件：Outer.class 和 Outer$Inner.class。也就是说，内部类会被编译成独立的字节码文件。

注意：必须先有外部类的对象才能生成内部类的对象，因为内部类需要访问外部类中的成员变量，成员变量必须实例化才有意义。

如果外部类成员变量、内部类成员变量和局部变量同名，则可通过使用this、外部类名.this来区分。

看下面的例子：

class A{
     String prop = "外部类的实例变量";

    class B{
    String prop = "内部类的实例变量";
        void funB(){
            String prop = "局部变量";
            System.out.println(A.this.prop);
            System.out.println(this.prop);
            System.out.println(prop);
        }

    }
}

public class printObject {
    public static void main(String[] args)
    {
        A a = new A();
        A.B b = a.new B();
        b.funB();
    }
}

输出结果：
外部类的实例变量
内部类的实例变量
局部变量

Java不允许在外部类的静态成员中直接使用非静态内部类。如下程序所示：

public class StaticTest{
    //定义一个非静态内部类，是一个空类
    public class In(){}
    //外部类的静态方法
    public static void main(String[] args){
    //下面代码引发编译异常，因为静态成员（main方法）无法访问非静态成员（In类）
    new In();
    }   
}

Java不允许在非静态内部类中定义静态成员。如下程序所示：

public class InnerNoStatic
{
    private class InnerClass
    {
        /*
        下面三个静态声明都将引发如下编译错误:
        非静态内部类不能有静态声明
        */
        static
        {
            System.out.println("==========");
        }
        private static int inProp;
        private static void test(){};
    }
}

非静态内部类中不能声明任何 static 成员。因此上面三个静态声明都会出错。

静态内部类

用static关键字修饰的内部类称为静态内部类，有的地方也被称为类内部类。静态内部类属于外部类本身，而不属于外部类的某个对象。

静态内部类可以包含静态成员，也可以包含非静态成员。静态内部类不能访问外部类的实例成员，只能访问外部类的类成员。静态内部类的实例方法也不能访问外部类的实例成员，只能访问外部类的静态成员。看下面的程序：

public class TestStaticInnerClass
{
    private int prop1 = 5;
    private static int prop2 = 9;
    static class StaticInnerClass
    {
        //静态内部类可以包含静态成员
        private static int age;
        public void accessOuterProp()
        {
            //下面代码出现错误：静态内部类无法访问外部类的实例成员
            System.out.println(prop1);
            //下面代码正常
            System.out.println(prop2);
        }
    }
}

静态内部类是外部类的静态成员，因此外部类的静态方法、静态初始化中可以使用静态内部类来定义变量、创建对象等。
外部类可以使用静态内部类的类名作为调用者来访问静态内部类的类成员和实例成员。看下面程序：

public class AccessStaticInnerClass
{
    static class StaticInnerClass
    {
        private static int prop1 = 5;
        private int prop2 = 9;
    }
    public void accessInnerProp()
    {
        //System.out.println(prop1);
        //上面代码出现错误，应改为如下形式：通过类名访问静态内部类的类成员
        System.out.println(StaticInnerClass.prop1);
        //System.out.println(prop2);
        //上面代码出现错误，应改为如下形式：通过实例访问静态内部类的实例成员
        System.out.println(new StaticInnerClass().prop2);
    }
}

Java也允许在接口中定义内部类，接口里定义的内部类默认使用public static修饰，也就是说接口内部类只能是静态内部类。

使用内部类

定义类的主要作用就是定义变量、创建实例和作为父类被继承。定义内部类的主要作用也如此，但使用内部类定义变量和创建实例则与外部类存在一些小小的差异。

  1. 使用内部类中定义的非静态变量和方法时，要先创建外部类的对象，再由“outObjectName.new”操作符创建内部类的对象，再调用内部类的方法，如下所示： 
public class Demo{
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.dostuff();
    }
}
class Outer{
    private int size;
    class Inner{
        public void dostuff() {
            size++;
        }
    }
}
  1. static 内部类相当于其外部类的 static 成员，它的对象与外部类对象间不存在依赖关系，因此可直接创建。示例如下： 
public class Demo{
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.dostuff();
    }
}

class Outer{
    private static int size;
    static class Inner {
        public void dostuff() {
            size++;
            System.out.println("size=" + size);
        }
    }
}
输出结果：
size = 1;
  1. 由于内部类可以直接访问其外部类的成分，因此当内部类与其外部类中存在同名属性或方法时，也将导致命名冲突。所以在多层调用时要指明，如下所示： 
public class Outer{
    private int size;
    public class Inner{
        private int size;
        public void dostuff(int size){
            size++;  // 局部变量 size;
            this.size;  // 内部类的 size
            Outer.this.size++;  // 外部类的 size
        }
    }
}

局部内部类

局部内部类(Local class)是定义在方法中的类。它们只在定义它们的方法中是可见的。由于局部内部类不能在外部类的方法以外的地方使用，因此局部内部类也不能使用访问控制符和static修饰符修饰。

局部类有几个重要特性：

  • 仅在定义了它们的代码块中是可见的；

  • 可以使用定义它们的代码块中的任何局部 final 变量；

  • 可以使用定义它们的代码块中的任何局部 final 变量；

  • 局部类不可以用 public、private、protected 修饰，只能使用缺省的；

  • 局部类可以是 abstract 的。

    看下面的代码：

public class Outer {
    public static final int TOTAL_NUMBER = 5;
    public int id = 123;
    public void func() {
        final int age = 15;
        String str = "http://www.weixueyuan.net";
        class Inner {
            public void innerTest() {
                System.out.println(TOTAL_NUMBER);
                System.out.println(id);
                // System.out.println(str);不合法，只能访问本地方法的final变量
                System.out.println(age);
            }
        }
        new Inner().innerTest();
    }
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.func();
    }
}
输出结果：
5
123
15

匿名内部类

匿名内部类是局部内部类的一种特殊形式，也就是没有变量名指向这个类的实例，而且具体的类实现会写在这个内部类里面。

注意：匿名类必须继承一个父类或实现一个接口。

匿名内部类适合创建那种只需要使用一次的类，创建匿名内部类时会立即创建一个该类的实例，这个类定义立即消失，匿名内部类不能重复使用。

定义匿名内部类的语法格式如下：

new 父类构造器（实参列表）|（实现接口）（）{
    //匿名内部类的类体部分
}

从上面的定义看，匿名内部类必须继承一个父类或必须实现一个接口，但最多只能继承一个父类或实现一个接口。

关于匿名内部类还有两条规则：

  • 匿名内部类不能是抽象类。因为系统在创建匿名内部类时，会立即创建匿名内部类的对象。

  • 匿名内部类不能定义构造器，因为匿名内部类没有类名。但匿名内部类可以定义实例初始化块，通过实例初始化块来完成构造器需要完成的事情。

最常用的创建匿名内部类的方式是需要创建某个接口类型的对象，如下程序所示：

interface Product
{
    public double getPrice();
    public String getName();
}
public class printObject {
    public void test(Product p)
    {
        System.out.println("购买了一个" + p.getName() + "，花掉了" + p.getPrice());
    }
    public static void main(String[] args) 
    {
        printObject ta = new printObject();
        //调用test方法时，需要传入一个Product参数，此处传入其匿名实现类的实例
        ta.test(new Product()
        {
            public double getPrice()
            {
                return 567.8;
            }
            public String getName()
            {
                return "AGP显卡";
            }
        });
    }
}

输出结果：
购买了一个AGP显卡，花掉了567.8

上面程序中定义了一个test方法，该方法需要一个Product对象作为参数，但Product只是一个接口，无法直接创建对象，因此此处考虑创建一个Product接口实现类的对象传入该方法——如果该接口实现类需要重复使用，则应该将该实现类定义成独立类；如果这个Product接口实现类只需一次使用，则可采用上面程序的方式，定义一个匿名类。

正如上面程序中看到的，定义匿名内部类无需class关键字，而是在定义匿名类时直接生成该匿名类的对象。下面代码部分就是匿名内部类的类体部分。

{
            public double getPrice()
            {
                return 567.8;
            }
            public String getName()
            {
                return "AGP显卡";
            }
        }

由于匿名内部类不能是抽象类，所以匿名内部类必须实现它的抽象父类或者接口里包含的所有抽象方法。

对于上面的代码，我们可以用下面的代码具体实现如下：

interface Product
{
    public double getPrice();
    public String getName();
}

class ImPlementProduct implements Product{
    public String getName(){
        return "AGP显卡";
    }

    @Override
    public double getPrice() {
        // TODO Auto-generated method stub
        return 567.8;
    }
}

public class printObject {
    public void test(Product p)
    {
        System.out.println("购买了一个" + p.getName() + "，花掉了" + p.getPrice());
    }
    public static void main(String[] args) 
    {
        printObject ta = new printObject();
        ImPlementProduct IP = new ImPlementProduct(); 
        //调用test方法时，需要传入一个Product参数
        ta.test(IP);
    }
}

当通过实现接口来创建匿名内部类时，匿名内部类也不能显式创建构造器，因此匿名内部类只有一个隐式的无参数构造器，故new接口名后的括号里不能传入参数值。

匿名类继承一个父类的情况 :

abstract class Person {
    public abstract void eat();
}

class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}
输出结果：
eat something

可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用。但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？

这个时候就引入了匿名内部类。使用匿名内部类实现： 

abstract class Person {
    public abstract void eat();
}

public class Demo {
    public static void main(String[] args){

        // 继承 Person 类
        new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        }.eat();
    }
}

可以看到，匿名类继承了 Person 类并在大括号中实现了抽象类的方法。

匿名内部类访问外部局部变量

如果匿名内部类需要访问外部类的局部变量，则需要使用final修饰符来修饰外部类的局部变量，否则会出错：

interface A
{
    void test();
}
public class TestA
{
    public static void main(String[] args) 
    {
        int age = 0;
        A a = new A()
        {
            public void test()
            {
                //下面语句将提示错误：匿名内部类内访问局部变量必须使用final修饰
                System.out.println(age);
            }
        };
    }
}
jxq1994
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础内部类.xmind文件
01-23
Java基础内部类.xmind文件
Java笔记---内部类的使用
GuLu_GuLu_jp的专栏
02-05 639
一、介绍 定义 将一个类的定义放在另一个类的定义的内部，放在内部的类就叫内部类，包裹在外面的就是外围类 种类 内部类分为4种： 1. 普通内部类 2. 局部内部类 3. 匿名内部类 4. 嵌套类 二、普通内部类 定义内部类 普通内部类的使用就和其定义一样，就是简单的将类定义放在另一个类定义中。如下： public class OuterClass...
java基础（三）内部类
Cherry_lzy的博客
05-10 293
内部类，位于一个类内部的类，可以看出内部类依然是一个类，所有依旧能被编译成独立的.class文件。但是内部类属于外部类的成员，依附于外部类而存在，所以编译成的.class文件前面冠以外部类的类名和"$"具体说一说内部类有哪些特点吧。一、特点1.不能被public修饰        一个.java文件可以有很多个类，但是只有一个类可以被public修饰，并且这个类的类名必须与文件名相同。在这种情况下...
Java内部类
weixin_41163113的博客
02-23 137
内部类基础： public class OuterClass { private String name; //外部类的两个pravate成员变量 private int age; public String getName(){ return name; } public void setName(String name){ ...
(1) 红牛农场；(2)内部类的使用；
csdnVIP071210的博客
03-02 424
代码填空：(1) 红牛农场；(2)内部类的使用；
题目：在如下例子：pubic class OuterClass {private double d1 = 1.0； // insert code here}，下面哪几个内部类的定义是正确的___
qq_42449963的博客
03-22 991
题目：在如下例子：pubic class OuterClass {private double d1 = 1.0; // insert code here}，下面哪几个内部类的定义是正确的___ A：class InnerOne { public static double methoda() { return d1; } } B：public class InnerOne { static double methoda() { return d1; } } C：private class InnerOn
Java 基础之内部类详解及实例
08-30
主要介绍了 Java 基础之内部类详解及实例的相关资料,需要的朋友可以参考下
java基础java内部类
03-29
java基础java内部类
Java基础内容-内部类学习笔记
最新发布
03-21
根据老师讲解写的笔记
java内部类
08-09
高效的课件，详细的内容介绍，针对性的代码展示，提高性的练习题目。适合新手或者基础薄弱人员学习，一个PPT解决你编程中常见的错误，最重要的是一人下载多人使用，不受限制，没有隐藏密码
黑马程序员_内部类
liliangyzq的专栏
10-10 457
------- android培训、java培训、期待与您交流！ ---------- 什么是内部类？     内部类（Inner Classes）就是讲一个类定义在另一个类里面，对里面的那个类就称为内部类也称为内置类、嵌套类。A类可以直接访问B类成员，B类访问A类的成员需要创建对象。针对这种情况，java提出了内部类： class Outer { priva
JAVA基础-内部类
xiaomojing_的博客
06-28 89
内部类分为静态内部类，成员内部类，局部内部类和匿名内部类 一.静态内部类 静态内部类是指被声明为static得内部类，它可以不依赖于外部类实例而实例化，而通常的内部类需要在外部类实例化后才能实例化。静态内部类不能与外部类有相同得名字，不能访问外部类的普通成员变量，智能访问外部类中得静态成员和静态方法（包括私有类型） public class Outer { public static int a = 1; public int b = 2; private static int c ...
Java练习：实验四
Dtruth的博客
01-06 557
1．请先阅读下面的程序，确定它的输出结果。再将程序上机运行，验证自己分析的输出结果是否正确。 class Yuan { int r; String name; static int z= 5; Yuan(int r){ this.r=r; } int a(){ return z*r*r; } int p(){ return 5*z*r; } void value (){ name="china"; } } class testOverride extends Yuan { int h;
内部类的使用
qq_1450107587的博客
03-06 174
内部类分类： 1.成员内部类 2.局部内部类（包含匿名内部类） 3.静态内部类 成员内部类： 以身体和心脏的关系为例： /* * 成员内部类定义格式： * 修饰符 class 外部类名称{ * 修饰符 class 内部类名称{ * //... * } * //... * } * * 注意：内用外，随意访问；外用内，一定需要借助内部类对象。 ...
Java学习-局部内部类的final问题
qq_44813352的博客
02-17 210
/* 局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。 备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。 原因： new出来的对象在堆内存当中。 局部变量是跟着方法走的，在栈内存当中。 方法运行结束之后，立刻出栈，局部变量就会立刻消失。 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。 */ public cla...
Java 不能在方法内部直接定义另一个方法
seabiscuityj的博客
03-03 6364
有一段时间没有看Java，基础知识遗忘了不少。出于尽快熟悉的目的，几天来跟着教程做一些小题目的代码敲写。今天码字时犯了一个低级错误，详见如下。 //实现矩阵转置 public class ArrayRowColumnSwapDemoWrong { public static void main(String[] args) { int[][] array = new i...
java 内部类（inner class）详解
weixin_33824363的博客
06-30 1092
一、为何使用内部类 内部类提供了更好的封装，只有外部类能访问内部类 内部类可以独立继承一个接口，不受外部类是否继承接口影响 内部类中的属性和方法即使是外部类也不能直接访问，相反内部类可以直接访问外部类的属性和方法，即使private 利于回调函数的编写 一个内部类的例子： public class OuterClass { ...
Java 四种内部类
Calvin's Blog
05-01 955
1、静态内部类 不依赖与外部类，因此在静态内部类中无法访问外部类的普通成员变量，只能访问静态变量和方法 public class OuterClass { //有static关键字 static class InnerClass{ public void show(){ System.out.println("staic inner clas
【Java基础】之深入讲解内部类
王廷云的博客
05-04 242
这篇文章将详细介绍 Java 的内部类知识 什么是内部类 在类中定义的类就是内部类 为什么要使用内部类 使用内部类最大的优点就在于它能够非常好的解决多重继承的问题，但是如果我们不需要解决多重继承问题，那么我们自然可以使用其他的编码方式，但是使用内部类还能够为我们带来如下特性: 内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立 在单个外围类中，可以让多个内部类...
java内部类 构造方法 【java基础】
07-28
Java内部类的构造方法与普通类的构造方法有一些区别。在内部类中，构造方法的调用需要通过外部类的实例来进行。 首先，内部类可以分为成员内部类和局部内部类。对于成员内部类，它是外部类的一个成员，可以访问外部...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值