温故而知新——java内部类

最新推荐文章于 2022-08-30 23:27:52 发布
最新推荐文章于 2022-08-30 23:27:52 发布
阅读量246 收藏
点赞数
分类专栏： J2SE 文章标签： 内部类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ww951993/article/details/53418713
版权

引言

　　大部分时候，类被定义为一个独立的单元。在某些时候，也会把一个类放在另一个类的内部定义，这个定义在其他类内部的类就被称为内部类（有的地方也叫嵌套类），包含内部类的类也被称为外部类（有的地方也叫宿主类〉。
　　
　　Java从JDK1.1开始引入内部类，内部类主要有如下作用：

  • 　　内部类提供更好地封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问。

  • 　　内部类成员可以直接访问外部类的私有数据，因为内部类被当成其外部类成员，同一个类的成员之间可以互相访问。但外部类不能访问内部类的实现细节，例如内部类的成员变量。

    　　定义内部类的方法：
    　　从语法角度来看，定义内部类与定义外部类的语法大致相同，内部类除了需要定义在其他类里面之外，还存在如下两点区别：

  • 　内部类比外部类可以多使用三个修饰符：private、protected、static一一外部类不可以使用这三个修饰符。　

  • 　非静态内部类不能拥有静态成员。
  • 　在编译完之后，会出现（外部类.class）和（外部类$内部类.class）两个类文件名。
  • 　内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量

内部类的分类

　　java内部类分为： 成员内部类、静态嵌套类、方法内部类、匿名内部类 。

成员内部类

　　成员内部类可以等同于外部类的成员变量。

class Outer {
    class Inner{}
} 
//编译上述代码会产生两个文件：Outer.class和Outer$Inner.class

　　成员内部类的特点如下：
　　
- 　可以用访问控制权限的修饰符修饰，public,protected,private,缺省(默认,default)。
- 　不能在成员内部类里面声明静态方法和静态变量。
- 　如果内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量

代码实例

public class _01_OuterClass{

    //静态变量
    private static String s1 = "A";

    //成员变量
    private String s2 = "B";

    //静态方法
    private static void m1(){
        System.out.println("static's m1 method execute!");
    }

    //成员方法
    private void m2(){
        System.out.println("m2 method execute!");
    }

    //成员内部类
    class InnerClass{

        //静态变量
        //static int i = 9999;
        //静态方法
        //public static void m3(){}

        //成员方法
        public void m4(){
            System.out.println(s1);
            m1();

            System.out.println(s2);
            m2();
        }
    }
    //相当于: InnerClass ...

    //入口
    public static void main(String[] args){

        //创建外部类对象
        _01_OuterClass oc = new _01_OuterClass();
        //怎么访问一个成员内部类
        //外部类对象的引用名.new 内部对象

        InnerClass inner = oc.new InnerClass();

        inner.m4();
    }

}

方法内部类 （局部内部类）

　　顾名思义，就是把类放在方法里。　　

class Outer {
    public void doSomething(){
        class Inner{
            public void seeOuter(){
            }
        }
    }
}

　　方法内部类的特点如下：　

- 　局部内部类不能用访问控制权限修饰符修饰。
- 　能访问外部方法的局部变量，但是局部变量必须用final修饰 , java8以后，可以不写final修饰。
- 　局部内部类中，不能声明静态变量和静态方法，只能声明成员变量和成员方法。
- 　如果外部方法是静态方法,那内部类中就不能访问外部类的成员变量和成员方法。
- 　局部内部类等同于局部变量。
代码实例

public class _03_OuterClass{

         int i1 = 222;
        static int i2 = 255;
    //方法
//-------------------------成员方法里面的内部类测试------------
    public  void m1(){//成员方法

        //局部变量
        final int i = 10;//java8以后,局部内部类访问方法的局部变量,可以不加final修饰

        //局部内部类
        class InnerClass{

            //局部内部类不能有静态声明
            //public static void m1(){}            
            //成员方法
            public void m2(){
                System.out.println(i); // 10  访问局部变量
                System.out.println( i1 );//访问外类的成员变量
                System.out.println( i2 );//访问外类的静态变量
            }                
        }

        //调用m2
        InnerClass inner = new InnerClass();
        inner.m2();        
    }
//-----------------------------静态方法里面的内部类测试--------
    public static void m11(){//静态方法
            //局部变量
        final int i = 10;//java8以后,局部内部类访问方法的局部变量,可以不加final修饰

        //局部内部类;
        //局部内部类不能用访问控制权限修饰符修饰。

        //局部内部类
        class InnerClass{

            //局部内部类不能有静态声明
            //public static void m1(){}

            //成员方法
            public void m22(){
                System.out.println(i); // 10  访问局部变量
               // System.out.println( i1 );//访问外类的成员变量
                System.out.println( i2 );//访问外类的静态变量
            }                
        }

        //调用m2
        InnerClass inner = new InnerClass();
        inner.m22();
    }

    //入口
    public static void main(String[] args){
        _03_OuterClass oc = new _03_OuterClass();
        oc.m1();
        oc.m11();       
    }    
}

另一个简洁示例：

class Outer {
    public void doSomething(){
        final int a =10;
        class Inner{
            public void seeOuter(){
                System.out.println(a);
            }
        }
        Inner in = new Inner();
        in.seeOuter();
    }
//入口
    public static void main(String[] args) {
        Outer out = new Outer();
        out.doSomething();
    }
}

匿名内部类

　　顾名思义，没有名字的内部类。表面上看起来它们似乎有名字，实际那不是它们的名字。在方法调用时，方法需要传入某个类对应的对象实参，但是也可以直接new一个某个类型的一个对象，这个对象没有名字。
　　匿名内部类的特点如下：　

- 　没有构造方法(因为匿名内部类是没有类名的)。
- 　不能定义任何变量(静态，成员)，不能定义任何方法(静态，成员)，不能定义任何类。
- 　匿名内部类不能使public，protected，private，static。
- 　只能创建匿名内部类的一个实例。
- 　匿名类和内部类中的中的this : 有时候，我们会用到一些内部类和匿名类。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。
- 　匿名内部类能访问外部的静态变量和静态方法，私有的也能，但是不能访问成员变量和成员方法。
- 　一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
　　　继承式的匿名内部类

public class Car {
    public void drive(){
        System.out.println("Driving a car!");
    }
    //入口
    public static void main(String[] args) {
        Car car = new Car(){  //匿名内部类，Car的匿名子类
            public void drive() {
                System.out.println("Driving another car!");
            }
        };
        car.drive();
    }
}

结果输出的是：Driving another car!
car是Car匿名子类的对象


　　接口式的匿名内部类
　　

interface Vehicle {
    public void drive();
}

class Test{
    public static void main(String[] args) {
        Vehicle v = new Vehicle(){
            public void drive(){
                System.out.println("Driving a car!");
            }
        };    //使用匿名内部类的特点，大括号后有分号作为结尾
        v.drive();
    }
}//接口式的匿名内部类是实现了一个接口的匿名类，而且只能实现一个接口。


　　参数式的匿名内部类

class Bar{
    void doStuff(Foo f){
        f.foo();
    }
}

interface Foo{
    void foo();
}

class Test{
    static void go(){
        Bar b = new Bar();
        b.doStuff(new Foo(){
            public void foo(){
                System.out.println("foofy");
            }
        });
    }
}

静态嵌套类

　　可以等同看做静态变量，可以访问外部类的静态变量和静态方法，但是不能直接访问外部类的成员变量和成员方法(要有对象引用，如同main()，也是静态的，有引用，就什么都能调用)，并且，能声明任意变量和任意方法。
　　静态前套类的特点：
　
- 　可以用访问控制权限的修饰符修饰
- 　内部可以声明静态变量和成员变量,静态方法和成员方法
- 　可以访问外部的静态变量和静态方法,不能直接访问成员变量和成员方法(需要有对象引用)
- 　在静态方法中定义的内部类也是静态内部类

class Outer{
    static class Inner{}
}

class Test {
    public static void main(String[] args){
        Outer.Inner n = new Outer.Inner();
    }
}

另一个示例：

public class _02_OuterClass{

    //静态变量
    private static String s1 = "A";

    //成员变量
    private String s2 = "B-------";

    //静态方法
    private static void m1(){
        System.out.println("static's m1 method execute!");
    }

    //成员方法
    private void m2(){
        System.out.println("m2 method execute!");
    }

    //静态内部类
    static class InnerClass{

        //静态方法
        public static void m3(){
            System.out.println(s1);
            m1();

            //也有外部静态类,性质一样
            //成员变量和成员方法:无法从静态上下文中引用非静态 变量 s2
            _02_OuterClass a = new _02_OuterClass();
            System.out.println(a.s2+"kkkkkkkkkkkkk");//调用成员属性,有对象引用就行
            //m2();
        }

        //成员方法
        public void m4(){
            System.out.println(s1);
            m1();

            //System.out.println(s2);
            //m2();
        }
    }


    //入口
    public static void main(String[] args){

        //执行m3
        _02_OuterClass.InnerClass.m3();

        //执行m4
        InnerClass inner = new _02_OuterClass.InnerClass();
        inner.m4();
    }

}
学海无涯1993
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
内部类和异常
Hello_zbs的博客
03-29 260
内部类 内部类，即类内部的类。类中类。形式如下： public class Outter{ // 外部类 class Inner{ // 内部类 } } 内部类的作用 内部类可以很好的实现隐藏 一般的非内部类，是不允许有 private 与protected权限的，但内部类可以 内部类拥有外围类的所有元素的访问权限 可以实现多重继承 匿名内部类优化接口 隐藏细节 平时我们对类的访问权限，都是...
Java 内部类
weixin_55827941的博客
03-17 398
Java 内部类 [理解]内部类的概念和分类 [理解]内部类编译成 class ，文件的命名 [掌握]使用内部类的原因 [掌握]开发内部类的方式 概念 把类定义在另一个类的内部，该类就被称为内部类。 举例：把类Inner定义在类Outer中，类Inner就被称为内部类。 public class Outer { private int max = 1; public static int count = 2; public Outer() { } clas
温故而知新——java抽象类和接口
王武的博客
11-30 330
一般我们编写一个类时，常常会为该类定义一些方法，这些方法都有具体的实现。但是在某些情况下，父类只知道子类应该包含什么方法，但是不知道子类是怎么实现这个方法的。
JAVA内部类
qq_26425023的博客
08-30 132
JAVA内部类
javase集合 温故而知新.doc
07-09
javase集合 温故而知新 javase集合是Java语言中的一种数据结构，用于存储和操作数据。集合可以分为两大接口：Collection和Map。Collection接口的实现类有List、Set和Queue等，而Map接口的实现类有HashMap、TreeMap...
【温故而知新】Document对象.md
06-13
【温故而知新】Document对象
CPU 技术温故而知新.pdf
09-24
CPU 技术温故而知新.pdf
C# 温故而知新：stream篇
08-15
2.7 StreamReader 类的常用方法属性 2.8 StreamReader示例 3.1 为何介绍TextWriter? 3.2 TextWriter的构造,常用属性和方法 3.3 IFormatProvider的简单介绍 3.4 如何理解StreamWriter? 3.5 StreamWriter属性 3.6 ...
【温故而知新】JavaScript类、类继承、静态方法.md
06-13
【温故而知新】JavaScript类、类继承、静态方法
基于springboot的社区团购系统 源码+数据库（毕业设计）
08-18
基于Vue.js和SpringBoot的社区团购系统是一个高效、易用的电子商务平台，旨在为社区内的居民提供便捷的购物体验。该系统分为管理员和普通用户两个角色，管理员可以进行商品信息管理、商品类型管理、团购信息发布和用户管理等操作，而普通用户则可以浏览商品、参与团购、查看订单等。系统采用前后端分离的架构，前端使用Vue.js框架，后端使用SpringBoot框架，实现了模块化开发和快速迭代。商品信息模块允许管理员添加、编辑和删除商品信息，包括商品名称、价格、库存等；商品类型模块则用于分类管理，方便用户快速找到所需商品；团购信息模块支持管理员发布团购活动，设置团购价格和时间等；用户管理模块则用于管理用户信息，包括用户注册、登录、权限分配等。整个系统界面友好，操作简便，为社区团购提供了一个全面、高效的解决方案。 录屏：https://www.bilibili.com/video/BV1sQ4y1E7Mz 教程：https://space.bilibili.com/417412814/channel/collectiondetail?sid=2242844
Y便利商超数字化方案（43页 PPT）.pptx
08-18
Y便利商超数字化方案（43页 PPT）
毕业设计，基于VB+ACCESS开发的通讯录管理信息系统，内含完整源代码，数据库，开题报告，论文答辩，毕业论文
08-18
毕业设计，基于VB+ACCESS开发的通讯录管理信息系统，内含完整源代码，数据库，开题报告，论文答辩，毕业论文 本通讯录信息管理系统用计算机管理电子通讯录的一种计算机应用技术的创新,在计算机还未普及之前通讯管理都是由联系人采用名片,笔录手工记帐的方式来操作的.现在一般的通讯录管理都是采用计算机作为工具的实用的计算机通讯录管理程序来帮助人们进行更有效的通讯录信息管理。通讯录管理系统是典型的信息管理系统(MIS),其开发主要包括后台数据库的建立和维护以及前端应用程序的开发两个方面。对于前者要求建立起数据一致性和完整性强、数据安全性好的库。而对于后者则要求应用程序功能完备,易使用等特点。 经过分析,我们使用 MICROSOFT公司的 VISUAL BASIC开发工具,利用其提供的各种面向对象的开发工具,尤其是数据窗口这一能方便而简洁操纵数据库的智能化对象,首先在短时间内建立系统应用原型,然后,对初始原型系统进行需求迭代,不断修正和改进,直到形成用户满意的可行系统。 关键字: 通讯录信息管理,管理信息系统,visual basic ,access
Selenium：Selenium Grid.zip
08-18
史上最全软件测试技术全套教程，包括： Postman Selenium 单元测试 压力测试 回归测试 安全测试 性能测试 测试工具 集成测试 等流行技术的系列教程
计算机毕业设计jsp房屋出租出售系统vue论文
08-18
计算机毕业设计jsp房屋出租出售系统vue论文
Ruby on Rails中的XSS防御策略：构建安全的Web应用
08-18
跨站脚本攻击（XSS）是一种常见的网络安全威胁，它允许攻击者将恶意脚本注入到网页中，影响其他用户的浏览器。Ruby on Rails作为一个流行的服务器端Web应用框架，提供了一系列的机制来帮助开发者防止XSS攻击。本文将详细介绍如何在Ruby on Rails中采取有效的措施来预防XSS攻击，并提供代码示例。 通过上述措施，Ruby on Rails开发者可以有效地防止XSS攻击，保护Web应用和用户的数据安全。记住，安全是一个持续的过程，需要不断地学习、适应和改进。 通过本文的介绍和示例，你应该能够理解如何在Ruby on Rails中构建XSS防护措施。随着Web技术的不断发展，新的安全威胁和防护手段也在不断出现，保持对最新安全实践的了解是非常重要的。 Rails社区和框架本身都非常注重安全，通过遵循最佳实践和利用Rails提供的工具，开发者可以创建出既安全又可靠的Web应用。随着你对Rails的深入使用，你将更加熟悉如何在开发过程中整合这些安全措施。
计算机毕业设计jsp大学生企业推荐系统vue论文
08-18
计算机毕业设计jsp大学生企业推荐系统vue论文
液晶配板点屏型号报表液晶配板点屏型号报表液晶配板点屏型号报表
08-18
液晶配板点屏型号报表液晶配板点屏型号报表液晶配板点屏型号报表
多模态学习：图像识别的全感官之旅
最新发布
08-18
图像识别是一种让计算机“看懂”图像的技术。它通过分析图像中的特征来识别和分类图像中的物体或场景。下面是一些简化后的关键点： 1. **技术基础**：使用算法处理图像，提取关键信息，如形状、颜色和纹理。 2. **主要任务**： - **分类**：确定图像属于哪个预设类别。 - **检测**：找出图像中所有指定类型的物体。 - **分割**：将图像分割成多个部分，以便单独识别。 3. **核心技术**：深度学习，尤其是卷积神经网络（CNN），它能够自动从图像中学习复杂的特征。 4. **CNN的作用**：通过多层结构自动提取图像特征，并用于识别图像内容。 5. **训练过程**：使用大量带标签的图像数据来训练模型，使其学会识别不同的物体或场景。 6. **性能评估**：通过准确率、召回率和F1分数等指标来衡量模型识别图像的准确性。 7. **应用场景**：广泛应用于医疗诊断、自动驾驶、安全监控和零售分析等领域。 8. **面临的挑战**：包括图像中的遮挡问题、不同光照条件下的识别准确性，以及某些类别样本数量不足导致的类别不平衡问题。 9. **发展趋势**：图像识别技术
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值