Java内部类

最新推荐文章于 2022-08-19 15:06:47 发布
最新推荐文章于 2022-08-19 15:06:47 发布
阅读量162 收藏 1
点赞数 1
分类专栏： java 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lamp113/article/details/79165910
版权

参考资料

[1]. 疯狂Java讲义（第三版） 李刚

内部类

非静态内部类

内部类因为是视同类成员，所以有四种权限，定义语法格式如下：

[public|protected|private]   class   类名
{
// 类体
}

示例程序如下：

package com.qunar;
/**
 * Cow interface
 *
 * @author shuaige
 * @date 2018/01/23
 */
public class Cow {
    /**
     * 重量
     */
    private double weight;

    /**
     * 外部类的构造器
     */
    public Cow(){}

    /**
     * 外部类的构造器
     * @param weight
     */
    public Cow(double weight){
        this.weight = weight;
    }

    /**
     * 定义一个非静态内部类
     */
    class Cowleg
    {
        /**
         * 非静态内部类的实例变量，长
         */
        private double length;
        /**
         * 非静态内部类的实例变量，颜色
         */
        private String color;



        /**
         * 内部类的构造器
         */
        public Cowleg(){}

        /**
         * 内部类的构造器
         */
        public Cowleg(double length, String color)
        {
            this.length = length;
            this.color = color;
        }

        /**
         * getLength
         * @return double
         */
        public double getLength() {
            return length;
        }


        /**
         * setLength
         * @param length
         */
        public void setLength(double length) {
            this.length = length;
        }

        /**
         * getColor
         * @return
         */
        public String getColor() {
            return color;
        }

        /**
         * setColor
         * @param color
         */
        public void setColor(String color) {
            this.color = color;
        }


        /**
         * 非静态内部类的实例方法
         */
        public void info()
        {
            System.out.println("当前牛腿的颜色是：" + color + "高：" + length);
            // 直接访问外部类的private修饰的成员变量
            System.out.println("本牛腿所在奶牛重："  + weight);
        }
    }

    /**
     * 测试方法
     */
    public void test()
    {
        Cowleg cl = new Cowleg(1.12, "黑白相间");
        cl.info();
    }

    /**
     * 执行
     * @param args
     */
    public static void main(String[] args){
        Cow cow = new Cow(378.9);
        cow.test();
    }
}

在内部类里，有下面的代码：

// 直接访问外部类的private修饰的成员变量
System.out.println("本牛腿所在奶牛重："  + weight);

在CowLeg类的方法内直接访问其外部类的private实例变量，这是因为在非静态内部类对象里，保存了一个它所寄生的外部类对象的引用（当调用非静态内部类的实例时，必须有一个非静态内部类实例，非静态内部类实例必须寄生在外部类实例里）。如下图所示：
这里写图片描述
不同类型的变量的访问方式：

/**
 * DiscernVariable class
 *
 * @author shuaige
 * @date 2018/01/23
 */
public class DiscernVariable {
    /**
     * 外部类的实例变量
     */
    private String prop = "外部类的实例变量";

    /**
     * InClass class
     *
     * @author shuaige
     * @date 2018/01/23
     */
    private class InClass
    {
        /**
         * 内部类的实例变量
         */
        private String prop = "内部类的实例变量";
        public void info()
        {
            /**
             * 局部变量
             */
            String prop = "局部变量";
            // 通过外部类类名.this.varName 访问外部类实例变量
            System.out.println("外部类的实例变量值：" + DiscernVariable.this.prop);
            // 通过this.varName访问内部类实例的变量
            System.out.println("内部类的实例变量值：" + this.prop);
            // 直接访问局部变量
            System.out.println("局部变量的值：" +prop);
        }
    }

    /**
     * 测试方法
     */
    public void test()
    {
        InClass in = new InClass();
        in.info();
    }

    /**
     * 执行方法
     * @param args
     */
    static public  void main(String[] args)
    {
        new DiscernVariable().test();
    }
}

如果需要从外部类访问内部类里的细节，代码如下：

/**
 * Outer class
 *
 * @author shuaige
 * @date 2018/01/23
 */
public class Outer {
    private int outProp = 9;
    class Inner
    {
        private int inProp = 5;
        public void acessOuterProp()
        {
            // 非静态内部类可以直接访问外部类的private成员变量
            System.out.println("外部类的outProp值：" + outProp);
        }
    }

    public void accessInnerProp()
    {
        // 外部类不能直接访问非静态内部类的实例变量
        // 下面代码出现编译错误
        // System.out.println("内部类的inProp值：" + inProp);
        // 如需访问内部类的实例变量，必须显示创建内部类对象
        System.out.println("内部类的inProp值：" + new Inner().inProp);
    }

    /**
     * 执行类
     * @param args
     */
    public static void main(String[] args)
    {
        Outer out = new Outer();
        out.accessInnerProp();
    }

}

在静态方法里无法访问作为实例类成员的内部类，示例代码如下：

/**
 * StaticTest class
 *
 * @author shuaige
 * @date 2018/01/23
 */
public class StaticTest {
    /**
     * 内部类
     */
    private class In{}

    /**
     * 执行方法
     * @param args
     */
    public static void main(String[] args)
    {
        // 下面代码引发编译异常，因为静态成员（main()方法）
        // 无法访问非静态成员（In类）
        new In();
    }
}

Java不允许在非静态内部类里定义静态成员，代码如下：

/**
 * InnerNoStatic class
 *
 * @author shuaige
 * @date 2018/01/23
 */
public class InnerNoStatic {
    private class InnerClass
    {
        /**
         * 下面三个静态声明都将引发如下编译错误：
         * 非静态内部类不能有静态声明
         */

        /**
         * 静态初始化块
         */
        static
        {
            System.out.println("--------");
        }

        /**
         * 静态成员变量inProp
         */
        private static int inProp;

        /**
         * 静态方法test
         */
        private static void test(){}
    }
}

静态内部类

如果使用static来修饰一个内部类，则这个内部类就属于外部类本身，而不属于外部类的某个对象。因此使用static修饰的内部类被称为类内部类或静态内部类。
静态内部类只能访问外部类的静态成员，代码如下：

/**
 * StaticInnerClassTest class
 *
 * @author shuaige
 * @date 2018/01/25
 */
public class StaticInnerClassTest {
    /**
     * 实例变量
     */
    private int prop1 = 5;
    /**
     * 静态变量
     */
    private static int prop2 = 9;
    /**
     * StaticInnerClass class
     *
     * @author shuaige
     * @date 2018/01/25
     */
    static class StaticInnerClass
    {
        /**
         * 可以包含静态成员变量
         */
        private static int prop2;
        static public void accessOuterProp()
        {
            // 下面代码出现错误
            // 静态内部类无法访问外部类的实例变量
            // System.out.println(prop1);
            // 但可以访问静态变量
            System.out.println(StaticInnerClassTest.prop2);
        }
    }
}

外部类如何访问静态内部类：

/**
 * AccessStaticInnerClass class
 *
 * @author shuaige
 * @date 2018/01/25
 */
public class AccessStaticInnerClass {

    /**
     * StaticInnerClass class
     *
     * @author shuaige
     * @date 2018/01/25
     */
    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(new StaticInnerClass().prop2);
    }
}

使用内部类

在外部类内部使用内部类

不要在外部类的静态成员（包括静态方法和静态初始化块）中使用非静态内部类，因为静态成员不能访问非静态成员。

在外部类以外使用非静态内部类

内部类的权限列表：
1. 省略访问控制符的内部类，只能被与外部类处于同一个包中的其他类所访问。
2. 使用protected修饰的内部类，可被与外部类处于同一个包的其他类和外部类的子类所访问。
3. 使用public修饰符的内部类，可以在任何地方被访问。
4. 使用private修饰符的内部类，只能在外部类中使用。
在外部类以外的地方创建非静态内部类的对象，并把它赋给非静态内部类类型的变量，代码如下：
定义含有内部类的外部类

/**
 * Out class
 *
 * @author shuaige
 * @date 2018/01/25
 */
public class Out {
    /**
     * 定义一个内部类，不使用访问控制符，
     */
   final class In
    {
        /**
         *
         * @param msg
         */
        public In(String msg)
        {
            System.out.println(msg);
        }
    }
}

调用：

/**
 * CreateInnerInstance class
 *
 * @author shuaige
 * @date 2018/01/25
 */
public class CreateInnerInstance {
    public static void main(String[] args)
    {
        /**
         * 使用外部类访问内部类
         */
        Out.In in = new Out().new In("测试信息");
        /*
          上面的代码可以可以改为如下三行代码
          使用OutterClass.InnerClass的形式定义内部类变量
           Out.In in;
           创建外部类实例，非静态内部类实例将寄生在该实例中
           Out out = new Out();
           in  = out.new In("测试信息");
         */
    }
}

当创建一个子类时，子类构造器总会调用父类的构造器，因此在创建非静态内部类的子类时，必须保证让子类构造器可以调用非静态内部类的构造器，调用非静态内部类的构造器时，必须存在一个外部类对象。下面程序定义了一个子类继承了Out类的非静态内部类In类：
简单来说就是扩展内部静态类

/**
 * SubClass class
 *
 * @author shuaige
 * @date 2018/01/25
 */
public class SubClass extends Out.In{
    /**
     * 显示定义SubClass的构造器
     * @param out
     */
    public SubClass(Out out) {
        // 通过传入的Out对象显式调用In的构造器
        // 非静态内部类In类的构造器必须使用外部类对象来调用
        // out代表外部类对象
        // super代表调用In类的构造器
        // 所以才能调用Out类的子类In类的构造器
        out.super("hello");
    }
}

在外部类以外使用静态内部类

定义一个带静态内部类的类

package com.qunar;
/**
 * StaticOut class
 *
 * @author shuaige
 * @date 2018/01/25
 */
public class StaticOut {
    // 定义一个静态内部类，不使用访问控制符
    // 即同一个包中的其他类可以访问该内部类
    static class StaticIn
    {
        public StaticIn()
        {
            System.out.println("静态内部类的构造器");
        }
    }
}

调用的时候会调用构造器

/**
 * CreateStaticInnerInstance class
 *
 * @author shuaige
 * @date 2018/01/25
 */
public class CreateStaticInnerInstance {
    public static void main(String[] args)
    {
        StaticOut.StaticIn in = new StaticOut.StaticIn();
        /*
        上面代码可改为如下两行代码
        使用OuterClass.InnerClass的形式定义内部类变量
        StaticOut.StaticIn in;
        通过new来调用内部类构造器创建静态内部类实例
        in = new StaticOut.StaticIn();
         */
    }
}

局部内部类

局部内部类的使用不多，在实际开发中不建议使用，示例代码如下。

package com.qunar;
/**
 * LocalInnerClass class
 *
 * @author shuaige
 * @date 2018/01/25
 */
public class LocalInnerClass {
    public static void main(String[] args)
    {
        /**
         * 定义局部内部类
         */
        class InnerBase
        {
            int a;
        }

        /**
         * 定义局部内部类的子类
         */

        class InnerSub extends InnerBase
        {
            int b;
        }

        // 创建局部内部类的对象
        InnerSub is = new InnerSub();
        is.a = 5;
        is.b = 8;
        System.out.println("InnerSub对象的a和b实例变量是：" + is.a + "," + is.b);
    }
}

匿名内部类

匿名内部类适合创建只需要一次使用的类，匿名内部类的语法格式如下：
new 实现类() | 父类构造器（实参列表）
{
// 匿名内部类的类体部分
}

实现一个接口的匿名内部类，必须实现它的全部方法

package com.qunar;
/**
 * AnonymousTest class
 *
 * @author shuaige
 * @date 2018/01/23
 */
public class AnonymousTest {
    /**
     * 测试方法，此处因为使用了ProductClass接口
     * 所以需要传入一个匿名类，来实现接口里面所有的方法
     * @param p
     */
    public void test(ProductClass p)
    {
        System.out.println("购买了一个" + p.getName() + "，花掉了" + p.getPrice());
    }


    public static void main(String[] args)
    {
        AnonymousTest ta = new AnonymousTest();
        // 调用test方法时，需要传入一个Product参数
        // 此处传入其匿名实现类的实例
        ta.test(new ProductClass() {

            /**
             * 初始化块
             */
            {
                System.out.println("这里是初始化块");
            }

            /**
             * 获取价格
             * @return
             */
            @Override
            public double getPrice() {
                return 1100;
            }

            /**
             * 获取名称
             * @return
             */
            @Override
            public String getName() {
                return "iphone-x";
            }
        });
    }
}

实现一个抽象类，代码如下：
抽象类

/**
 * Device abstract class
 *
 * @author shuaige
 * @date 2018/01/23
 */
abstract class Device {
    /**
     * 名称
     */
    private String name;

    /**
     * 抽象方法getPrice
     * @return
     */
    public abstract double getPrice();

    /**
     * 无参构造器
     */
    public Device(){}

    /**
     * 带参数构造器
     * @param name
     */
    public Device(String name)
    {
        this.name = name;
    }

    /**
     * 获取name
     * @return
     */
    public String getName() {
        return name;
    }

    /**
     * 设置name
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }
}

实现示例：

/**
 * AnonymousInner  class
 *
 * @author shuaige
 * @date 2018/01/23
 */
public class AnonymousInner {
    public void test(Device d)
    {
        System.out.println("购买了一个" + d.getName() + "，花掉了" + d.getPrice());
    }

    public static void main(String[] args)
    {
        AnonymousInner ai = new AnonymousInner();
        // 调用有参数的构造器创建Device匿名实现类的对象
        ai.test(new Device("电子示波器") {
            /**
             * 获取价格
             * @return
             */
            @Override
            public double getPrice() {
                return 67.8;
            }
        });

        // 调用无参数的构造器穿件Device匿名实现类的对象
        Device d = new Device() {
            // 初始化块
            {
                System.out.println("匿名内部类的初始化块...");
            }

            /**
             * 获取价格
             * @return
             */
            @Override
            public double getPrice() {
                return 56.2;
            }

            /**
             * 获取名称
             * @return
             */
            @Override
            public String getName() {
                return "键盘";
            }
        };
        ai.test(d);

    }
}

在Java 8之前，Java要求被局部内部类、匿名内部类访问的局部变量必须使用final修饰，Java 8更加智能，如果局部变量被匿名内部类访问，那么该局部变量相当于自动使用了final修饰，代码如下：
接口

/**
 * InterfaceAA  interface
 *
 * @author shuaige
 * @date 2018/01/23
 */
public interface InterfaceAa {
    /**
     * test
     */
    void test();
}

传入匿名类实现

/**
 * ATest  class
 *
 * @author shuaige
 * @date 2018/01/23
 */
public class ATest {
    public static void main(String[] args){
        int age = 8;
        InterfaceAa a = new InterfaceAa() {
            @Override
            public void test() {
                System.out.println(age);
                // 如果在这里再次改变age变量，将会报错
                a = 100;
            }
        };
        // 传入匿名类
        a.test();
    }
}

Java 8将这个功能称为“effectively final”，它的意思是对于被匿名内部类访问的局部变量，可以用final修饰，也可以不用final修饰，但必须按照有final修饰的方式使用，也就是一次赋值后，以后不能重新赋值。

lamp113
关注
专栏目录
java声明内部类_java内部类
weixin_35964207的博客
02-21 1596
为什么在Java中需要内部类？总结一下主要有以下四点：1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整，2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。3.方便编写事件驱动程序4.方便编写线程代码个人觉得第一点是最重要的原因之一，内部类的存在使得Java的多继承机制变得更加完善。◆Jav...
java声明内部类_Java 内部类详解
weixin_33863049的博客
02-21 3269
什么定义在一个类内部的类，称为内部类(累不累)，如下：public class A {private int c = 1;public class C {public void test() {System.out.println("c:" + c);}}}C称为A的内部类，简称内部类A称为C的外部类，简称外部类而且内部类能访问外部类的成员(静态成员、实例成员)，当然有一些限制，限制如下4种声明方...
Java内部类的使用小结
weixin_34221112的博客
08-29 278
内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。 *内部类可以是静态static的，也可用public，default，protected和private修饰。（而外部顶级类即类名和文件名相同的只能使用public和default）。 注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的...
java内部类详解
hefangxuxing的博客
08-19 3035
java内部类的介绍与解析
java内部类最全详解
热门推荐
weixin_46972127的博客
03-20 4万+
1、成员内部类 内部类与外部类的关系 a.成员内部类的创建需要依赖于外部类对象-（成员方法必须通过对象调用），在没有外部类实例之前无法创建成员内部类对象 b.内部类与外部类相对独立，不是is a 的关系（发动机-汽车） c.私有属性的互相访问，内部类可以直接访问外部类，而外部类访问内部类需要内部类的对象来访问 d.创建内部类的语法 1.在外部类内部创建内部类对象（Inner inner = new Inner()） 2.在外部类外部创建内部类对象，外部类.内部类 inner = new O
初识JAVA内部类
程序媛泡泡的博客
03-21 3万+
1 内部类概述 如果一个类存在的意义就是为指定的另一个类，可以把这个类放入另一个类的内部。 就是把类定义在类的内部的情况就可以形成内部类的形式。 A类中又定义了B类，B类就是内部类,B类可以当做A类的一个成员看待: 2 特点 1) 内部类可以直接访问外部类中的成员，包括私有成员 2) 外部类要访问内部类的成员，必须要建立内部类的对象 3) 在成员位置的内部类是成员内部类 4) 在局部位置的内部类是局部内部类 3 练习 : 内部类入门案例 创建包: cn.tedu.innerclass 创建类
Java内部类以及使用场景
ylx1066863710的博客
12-15 4558
所谓内部类，即定义在另一个类中的类。那么，为什么会有内部类这个概念，他的使用场景又是什么呢？首先，来看一下内部类的特点： 1. 它体现了一种代码的隐藏机制和访问控制机制，内部类与所在外部类有一定的关系，往往只有该外部类调用此内部类，所以没有必要专门用一个Java文件存放这个类。 public class Outer { 　　private int num; 　　private class Inner { 　　　　private int num; 　　} } 一般的类是不允许用private修饰符
Java内部类和外部类
weixin_41924879的博客
10-18 1661
Java内部类和外部类 在Java语言中，可以把一个类定义到另外一个类的内部，在类里面的这个类就叫作内部类，外面的类叫作外部类。在这种情况下，这个内部类可以被看成外部类的一个成员(与类的属性和方法类似)。还有一种类被称为顶层(Top-level)类，指的是类定义代码不嵌套在其他类定义中的类。 内部类 内部类主要有四种类型： 静态内部类(Static Inner Class） 成员内部类(Me...
java内部类与外部类
m0_51779342的博客
01-14 3320
java内部类与外部类 一、内部类的作用 提供良好的封装环境 二、内部类分类 成员内部类、局部内部类、匿名内部类 一、成员内部类 在类的内部定义一个类，与成员方法和成员变量同级，成员内部类又分为静态内部类和非静态内部类 1、非静态内部类 1）非静态内部类相当于是特殊的成员变量， 2）非静态内部类可以在内部类中直接调用外部类的所有权限的成员变量和成员方法，外部类不能直接调用内部类的成员变量和成员方法 3）与成员变量和局部变量的优先级一致，当外部类与内部类存在同名属性时，优先访问内部类属性，要访问
Java 内部类
05-08
Java 内部类是Java语言特性中的一个重要组成部分，它允许我们在一个类的内部定义另一个类。内部类可以访问外部类的所有成员，包括私有成员，这使得内部类在实现复杂逻辑和封装上具有很大的灵活性。下面我们将详细...
java内部类
08-09
高效的课件，详细的内容介绍，针对性的代码展示，提高性的练习题目。适合新手或者基础薄弱人员学习，一个PPT解决你编程中常见的错误，最重要的是一人下载多人使用，不受限制，没有隐藏密码
JAVA 内部类详解及实例
09-01
Java 内部类详解及实例 Java 内部类是一种特殊类型的类，它定义在一个类的内部。这种设计模式在 Java 中提供了许多便利，比如封装、抽象和代码复用。以下将详细介绍内部类的种类、特性以及如何使用它们。 1. 成员...
java 内部类（匿名类，匿名对象，静态内部类）详解及实例
08-31
Java内部类是Java语言中一个独特且强大的特性，它允许在一个类的定义内定义另一个类。内部类可以访问外部类的所有成员，包括私有成员，这使得内部类成为实现复杂设计和封装的有力工具。本篇文章将深入探讨内部类的三...
Java内部类原理、概述与用法实例详解
08-26
Java内部类原理、概述与用法实例详解 Java内部类是一种特殊的类，它定义在其他类的内部。 Java内部类的特点是可以直接访问外部类的成员，包括私有成员。外部类要访问内部类的成员，必须创建对象。 Java内部类可以...
Java 8 新增的DateTimeFormatter类
新手专用的博客
01-13 2万+
参考资料 [1]. 疯狂Java讲义（第三版） 李刚 使用DateTimeFormatter完成格式化 DateTimeFormatter[] formatters = new DateTimeFormatter[]{ // 直接使用常量创建DateTimeFormatter格式器 DateTimeFormatter.ISO_LOCAL_DATE,
Spring 项目常用的依赖（pom文件）
新手专用的博客
03-30 2万+
properties属性 <properties> <!--使用utf-8编码--> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <!--web--> <spring.ver...
OkHttpClient的使用方法
新手专用的博客
03-22 6697
参考资料 https://github.com/square/okhttp/wiki https://github.com/square/okhttp/wiki/Recipes 使用方法 get // 获取OkHttpClient private final OkHttpClient client = new OkHttpClient(); // 执行方法 public void r...
Java 单例（Singleton）类
新手专用的博客
01-30 3339
参考资料 [1]. 疯狂Java讲义（第三版） 李刚 单例（Singleton）类 虽然Java 系统允许，但是类成员还是不要访问实例成员。 如果一个类始终只能创建一个实例，则这个类被称为单例类。 一个简单的单例类，代码如下： class Singleton { // 使用一个类变量来缓存曾经创建的实例 private static Singleton instan
详解Java内部类类型与实践
Java内部类是Java语言中一个重要的特性，它允许在类的内部定义并使用类，提供了封装和信息隐藏的能力。本文将深入讲解Java的几种内部类类型及其特点，帮助读者更好地理解和运用这一概念。 1. **成员内部类**: 成员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值