浅谈java内部类

最新推荐文章于 2024-09-15 21:16:10 发布
最新推荐文章于 2024-09-15 21:16:10 发布
阅读量106 收藏 1
点赞数
分类专栏： Java 基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adsdaas/article/details/108620801
版权

今天把以前所学的知识点 (内部类) 整理一下，传到博客上大家一起学习学习，共同进步。

目录

在这里插入图片描述

1、什么是内部类

    内部类可以理解为在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
    内部类可以分为：成员内部类、静态内部类、局部(方法)内部类、匿名内部类这四种下面会一一列举。

//这是外部类
public class A {
	
	//这是内部类 内部类可以继承外部类的所有属性和方法
	class B {
		
	}
}

2、为什么要用内部类

每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。——《java 编程思想》

也就是说内部类拥有类的基本特征。(eg：可以继承父类，实现接口。)在实际问题中我们会遇到一些接口无法解决或难以解决的问题，此时我们可以使用内部类继承某个具体的或抽象的类，间接解决类无法多继承引起的一系列问题。（注：内部类可以嵌套内部类，但是这极大的破坏了代码的结构，这里不推荐使用。）


// 1. Outer类继承了ClassA，实现了IFunctionA
public class Outer extends ClassA implements IFunctionA{ 
	//Inner类继承了ClassB，实现了IFunctionB
	public class Inner extends ClassB implements IfunctionB{
	//
	} 
}

除了上面的优点之外还有如下四点：

1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
2、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
3、内部类提供了更好的封装，除了该外围类，其他类都不能访问。
4、创建内部类对象的时候并不依赖于外围类对象的创建。

具体来说，内部类信息（属性、方法）可以和外部类重名；内部类是具有类的基本特征的独立实体；可以利用访问修饰符隐藏内部类的实施细节，提供了更好的封装；静态内部类使用时可直接使用，不需先创造外部类。

3、如何使用内部类

简单的总结如图：
在这里插入图片描述
我们通过一些案例来了解内部类。

(一) 成员内部类

1、内部类与外部类
/**
 * 外部类、成员内部类的定义
 */
public class Outer {

    private int outerVariable = 1;
    private int commonVariable = 2;
    private static int outerStaticVariable = 3;
    //省略getter/setter
     
    /**
     * 成员方法
     */
    public void outerMethod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /**
     * 静态方法
     */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }

    /**
     * 内部类
     */
    public class Inner {
    
        private int commonVariable = 20;

        /**
         * 构造方法
         */
        public Inner() {
        }

        /**
         * 成员方法，访问外部类信息（属性、方法）
         */
        public void innerShow() {
            //当和外部类冲突时，直接引用属性名，是内部类的成员属性
            System.out.println("内部的commonVariable:" + commonVariable);
            //内部类访问外部属性
            System.out.println("outerVariable:" + outerVariable);
            //当和外部类属性名重叠时，可通过外部类名.this.属性名
            System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
            System.out.println("outerStaticVariable:" + outerStaticVariable);
            //访问外部类的方法
            outerMethod();
            outerStaticMethod();
        }
    }
    
    /**
     *	外部类访问内部类信息
     */
    public void outerShow() {
        Inner inner = new Inner();
        inner.innerShow();
    }
}
2、其他类使用成员内部类
/*
*	其他类使用成员内部类
 */
public class Other {
    
    public static void main(String[] args) {
        //外部类对象
        Outer outer = new Outer();
        //创造内部类对象
        Outer.Inner inner = outer.new Inner();
        inner.innerShow();
        /*
        * 可在Outer中定义get方法，获得Inner对象,那么使用时，只需outer.getInnerInstance()即可。
        * public Inner getInnerInstance(Inner类的构造方法参数){
        *   return new Inner(参数);
        * }
        */
    }
}
3、运行结果

在这里插入图片描述

4、小结【可以把成员内部类当成外部类的属性去理解】
  1. 可以是任何的访问修饰符。
  2. 内部类的内部不能有静态信息。
  3. 内部类也是类,该继承继承，该重写重写，该重载重载，this和super随便用。
  4. 外部类如何访问内部类信息，必须new之后打点访问。
  5. 内部类可以直接使用外部类的任何信息，如果属性或者方法发生冲突，调用外部类.this.属性或者方法。
  6. 其他类如何访问成员内部类
//创建外部类对象
Outer other = new Other();
//通过外部类对象创建内部类对象
other.Inner inner = other.new Inner();
//调用内部类方法
inner.innerShow()

(二) 静态内部类

1、外部类、内部类
/**
 * 外部类、内部类定义
 */
public class Outer {

    private int outerVariable = 1;

    /**
     * 外部类定义的属性(重名)
     */
    private int commonVariable = 2;
    
    private static int outerStaticVariable = 3;

    static {
        System.out.println("Outer的静态块被执行了……");
    }

    /**
     * 成员方法
     */
    public void outerMothod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /*
    *	静态方法
    */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }


    /**
     * 静态内部类
     */
    public static class Inner {
        /**
         * 成员信息
         */
        private int innerVariable = 10;
        private int commonVariable = 20;

        static {
            System.out.println("Outer.Inner的静态块执行了……");
        }

        private static int innerStaticVariable = 30;

        /**
         * 成员方法
         */
        public void innerShow() {
            System.out.println("innerVariable:" + innerVariable);
            System.out.println("内部的commonVariable:" + commonVariable);
            System.out.println("outerStaticVariable:"+outerStaticVariable);
            outerStaticMethod();
        }

        /**
         * 静态方法
         */
        public static void innerStaticShow() {
        	//被调用时会先加载Outer类
            outerStaticMethod();
            System.out.println("outerStaticVariable"+outerStaticVariable);
        }
    }

    /**
     * 外部类的内部如何和内部类打交道
     */
    public static void callInner() {
        System.out.println(Inner.innerStaticVariable);
        Inner.innerStaticShow();
    }
}
2、其他类使用成员内部类
public class Other {

    public static void main(String[] args) {
        //访问静态内部类的静态方法，Inner类被加载,此时外部类未被加载，独立存在，不依赖于外围类。
        Outer.Inner.innerStaticShow();
        //访问静态内部类的成员方法
        Outer.Inner oi = new Outer.Inner();
        oi.innerShow();
    }
}
3、运行结果（注意加载顺序）

在这里插入图片描述

4、小结【和成员内部类对比理解（区别异同）】
  1. 内部可以包含任意的信息。
  2. 静态内部类的方法只能访问外部类的static关联的信息。
  3. 利用 外部类.内部类 引用变量 = new 外部类.内部类(); 然后利用引用.成员信息(属性、方法)调用。
  4. 访问内部类的静态信息，直接外部类.内部类.静态信息就可以了。
  5. 静态内部类可以独立存在，不依赖于其他外围类。

(三) 局部内部类

1、外部类、内部类
/**
 *	外部类、内部类
 */
public class Outer {
    /**
     * 属性和方法
     */
    private int outerVariable = 1;
    /**
     * 外部类定义的属性
     */
    private int commonVariable = 2;
    /**
     * 静态的信息
     */
    private static int outerStaticVariable = 3;

    /**
     * 成员外部方法
     */
    public void outerMethod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /**
     * 静态外部方法
     */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }

    /**
     * 程序的入口
     */
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerCreatMethod(100);
    }

    /**
     * 成员方法，内部定义局部内部类
     */
    public void outerCreatMethod(int value) {
        /**
         * 女性
         */
        boolean sex = false;

        /**
         * 局部内部类，类前不能有访问修饰符
         */
        class Inner {

            private int innerVariable = 10;
            private int commonVariable = 20;
			/**
			*	局部内部类方法
			*/
            public void innerShow() {
                System.out.println("innerVariable:" + innerVariable);
                //局部变量
                System.out.println("是否男性:" + sex);
                System.out.println("参数value:" + value);
                //调用外部类的信息
                System.out.println("outerVariable:" + outerVariable);
                System.out.println("内部的commonVariable:" + commonVariable);
                System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
                System.out.println("outerStaticVariable:" + outerStaticVariable);
                outerMethod();
                outerStaticMethod();
            }
        }
        //局部内部类只能在方法内使用
        Inner inner = new Inner();
        inner.innerShow();
    }
}
2、运行结果

在这里插入图片描述

3、小结【局部内有很多局限性，应注意作用域】
  1. 类前不能有访问修饰符。
  2. 仅在此方法内使用。
  3. 无法创造静态信息。
  4. 可以直接访问方法内的局部变量和参数（有限制，下面详谈），但是不能更改。
  5. 可以随意的访问外部类的任何信息。
4、局部内部类访问局部变量的限制

Variable ‘xxx’ is accessed from within inner class, needs to be final or effectively final

它的意思是：变量’xxx’从内部类中访问，需要final或有效的final

具体限制如下：

  1. 直接被final修饰的变量。
  2. 已被赋值且始终未改变的变量（有且仅有赋值一次）,引用指向不能改变。JDK8以前（不包括8）只能访问被final修饰的变量。eg:
    在这里插入图片描述

就会产生如下错误：传入局部内部类所在方法的参数同理，如果一直不变则可使用，反之则会报错。
在这里插入图片描述

(四) 匿名内部类

1、定义接口
/**
*	接口中方法默认为public 
*/
public interface IAnimal{
	void speak();
}
2、匿名内部类使用
/**
*	外部内、内部类
*/
public class Outer {

    public static IAnimal getInnerInstance(String speak){
        return new IAnimal(){
            @Override
            public void speak(){
                System.out.println(speak);
            }};
        	//注意上一行的分号必须有
    }
    
    public static void main(String[] args){
    	//调用的speak()是重写后的speak方法。
        Outer.getInnerInstance("老板 996").speak();
    }
}
3、结果

老板 996

4、小结【匿名内部类常常被用来重写某个或某些方法】
  1. 匿名内部类是没有访问修饰符的。
  2. 使用匿名内部类时，这个new之后的类首先是要存在的，其次我们要重写new后的类的某个或某些方法。
  3. 匿名内部类访问方法参数时也有和局部内部类同样的限制。
  4. 匿名内部类没有构造方法。
咖啡味的茶
关注
专栏目录
浅谈Java内部类——静态内部类
08-24
本文将主要介绍Java静态内部类的相关知识，帮助大家更好地理解和学习Java内部类的相关知识。 什么是静态内部类？ ----------------- 在Java中，静态内部类是指使用static关键字修饰的内部类。静态内部类与普通内部...
【Java|基础篇】内部类
云泽野の编程日记
05-29 1万+
内部类就是在一个类中再定义一个类,内部类也是封装的体现.它可以被声明为public、protected、private 或默认访问控制符。内部类可以访问外部类的所有成员变量和方法，包括私有成员。内部类可以用来实现一些特殊的功能，比如实现回调函数、事件处理等。常见的内部类包括实例内部类(成员内部类)、静态内部类、本地内部类、匿名内部类等。内部类在Java中的一个重要特性,要重点掌握实例内部类,静态内部类和匿名内部类.希望这篇文章能帮到你!专栏:《从零开始的Java学习之旅》在不断更新中,欢迎订阅!
Java内部类（超详细）
m0_63785629的博客
08-15 4486
内部类就是在一个类或方法中定义的类。内部类又分为成员内部类，静态内部类，匿名内部类和局部内部类。 成员内部类是定义在类的内部，作为类的成员的类。 特点如下： 内部类可以直接访问外部类的
Java内部类，看这一篇就够了！
最新发布
2301_79201049的博客
09-15 1948
在 Java 中，我们通常将不同的类组织到一个包下，对于一个包中的类来说，它们是同一个层次，可以说在没有使用继承等条件下，类与类之间是没有联系的。还有一种类，它是定义在另一个类或者一个方法的内部，这样的类叫做内部类。内部类也是封装的一种体现 ~注意：内部类和外部类共用同一个 java 源文件，但是经过编译之后，内部类会形成单独的字节码文件一般来说，内部类分为成员内部类、局部内部类、匿名内部类和静态内部类成员内部类。
java中的内部类
yahid的博客
07-22 1万+
匿名内部类是没有名称的内部类。在Java中调用某个方法时，如果该方法的参数是接口类型，除了可以传接口实现类外，还可以使用实现接口的匿名内部类作为参数，在匿名内部类中直接完成方法的实现。}}@OverrideSystem.out.println("学生韩梅梅正在吃饭");}}@OverrideSystem.out.println("老师李华正在吃饭");}}}}}}}@OverrideSystem.out.println("学生韩梅梅正在吃饭");}...
​java-内部类详解
热门推荐
我是香菜
10-11 1万+
​java-内部类详解 内部类 定义:把类定义在其他类的内部，这个类被称为内部类（嵌套类）。 分类:根据其所在位置及形式的不同,分为成员内部类、静态内部类、局部内部类、匿名内部类。 1、成员内部类(联想到成员变量和成员方法，内部类所在位置和类的成员同级) // 外部类class OuterClass01 { // 成员内部类 class InnerClass01 { } } 观察一下生成的字节码文件，有两个：OuterClass01.class、OuterClass01$In..
Java枚举类
yu的博客
02-03 5474
Java的内部类详解（成员内部类、静态内部类、局部内部类、匿名内部类）
浅谈Java内部类的四个应用场景
05-11
### 浅谈Java内部类的四个应用场景 #### 一、引言 在Java语言中，内部类（Inner Class）作为一种特殊的存在，为开发者提供了更为灵活的面向对象编程方式。通过本文，我们将深入探讨Java内部类的四个典型应用场景，...
浅谈Java中的class类
08-28
在Java中，反射机制允许我们在运行时分析和操作类的内部结构，这对于编写动态、灵活的代码非常有用。它可以用来实现插件系统、数据库元数据操作、XML序列化和反序列化、单元测试等领域。然而，由于反射打破了封装性...
Java内部类
cnds123的专栏
05-15 2343
Java内部类介绍
Java 内部类
我的博客
02-20 1456
当静态内部类对象存在时，并不存在一个被它寄生的外部类对象，静态内部类对象只持有外部类的类引用，没有持有外部类对象的引用。在非静态内部类里可以直接访问外部类的私有成员，是因为在非静态内部类的对象里保存了一个它所寄生外部类对象的引用。当调用非静态内部类的实例方法时，必须有一个非静态内部类的实例，非静态内部类实例必须寄生在外部类实例里。如果把一个内部类放在方法里定义，那这个内部类就是一个局部内部类，局部内部类仅在方法里有效。把 A 类定义在 B 类的内部，A——内部类（嵌套类），B——外部类（宿主类）。
Java内部类详解
StoNENee的博客
02-28 1063
内部类可以分为成员内部类、静态内部类、局部内部类和匿名内部类。
JAVA内部类
weixin_61611746的博客
05-21 798
java内部类
java实例内部类
qq_46075216的博客
04-08 4312
先贴一段整体代码，后续进行每个小点的说明 class OutClass{ public int data1 = 10; private int data2 = 20; public static int data3 = 30; /** * @Description:实例内部类 */ class InnerClass{ public int data4 = 40; private int data5 = 50;
【Java杂记】内部类：四个问题详解内部类
A minor
10-10 3209
1.内部类为什么存在 内部类 ( inner class ) : 定义在另一个类中的类 我们为什么需要内部类？或者说内部类为啥要存在？其主要原因有如下几点： 内部类方法可以访问该类定义所在作用域中的数据，包括被 private 修饰的私有数据 内部类可以对同一包中的其他类隐藏起来 内部类可以实现 java 单继承的缺陷 当我们想要定义一个回调函数却不想写大量代码的时候我们可以选择使用匿名内部类来实现 下面我们就一一来看这四点… 1.1 访问类作用域中的数据 当外部类的对象创建了一个内部类的对象时，
Java内部类（静态内部类、匿名内部类等）详解
????
04-25 2358
总结了常见的四大内部类（成员内部类、静态内部类、局部内部类、匿名内部类）相关知识，通过写代码详细讲解了静态内部类和匿名内部类，成员内部类和局部内部类使用较少就没有写代码举例。
Java IO学习精要与实战技巧
总结来说，Java的IO流系统提供了丰富的类来处理各种数据输入和输出场景。理解字节流、字符流和缓冲流的概念及其用法是Java开发中的重要基础。通过熟练掌握这些，开发者能够高效地实现数据的读写操作，无论是处理文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值