java基础(十三)-----详解内部类——Java高级开发必须懂的

简介: java基础(十三)-----详解内部类——Java高级开发必须懂的 目录 为什么要使用内部类 内部类基础 静态内部类 成员内部类 成员内部类的对象创建 继承成员内部类 局部内部类 推荐博客 匿名内部类   正文 可以将一个类的定义放在另一个类的定义内部,这就是内部类。

java基础(十三)-----详解内部类——Java高级开发必须懂的

 

正文

可以将一个类的定义放在另一个类的定义内部,这就是内部类。

为什么要使用内部类

  为什么要使用内部类?在《Think in java》中有这样一句话:使用内部类最吸引人的原因是:每个内部类都能独立地继承一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。

      在我们程序设计中有时候会存在一些使用接口很难解决的问题,这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说,接口只是解决了部分问题,而内部类使得多重继承的解决方案变得更加完整。

复制代码
public interface Father {
 
}
 
public interface Mother {
 
}
 
public class Son implements Father, Mother {
 
}
 
public class Daughter implements Father{
 
    class Mother_ implements Mother{
        
    }
}
复制代码

    其实对于这个实例我们确实是看不出来使用内部类存在何种优点,但是如果Father、Mother不是接口,而是抽象类或者具体类呢?这个时候我们就只能使用内部类才能实现多重继承了

      其实使用内部类最大的优点就在于它能够非常好的解决多重继承的问题,但是如果我们不需要解决多重继承问题,那么我们自然可以使用其他的编码方式,但是使用内部类还能够为我们带来如下特性(摘自《Think in java》):

      1、内部类可以用多个实例,每个实例都有自己的状态信息,并且与其他外围对象的信息相互独立。

      2、在单个外围类中,可以让多个内部类以不同的方式实现同一个接口,或者继承同一个类。

      3、创建内部类对象的时刻并不依赖于外围类对象的创建。

      4、内部类并没有令人迷惑的“is-a”关系,他就是一个独立的实体。

      5、内部类提供了更好的封装,除了该外围类,其他类都不能访问。

内部类基础

  在这个部分主要介绍内部类如何使用外部类的属性和方法,以及使用.this与.new。

       当我们在创建一个内部类的时候,它无形中就与外围类有了一种联系,依赖于这种联系,它可以无限制地访问外围类的元素。

 

复制代码
public class OuterClass {
    private String name ;
    private int age;
 
    /**省略getter和setter方法**/
    
    public class InnerClass{
        public InnerClass(){
            name = "chenhao";
            age = 23;
        }
        
        public void display(){
            System.out.println("name:" + getName() +"   ;age:" + getAge());
        }
    }
    
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
    }
}
--------------
Output:
name:chenhao   ;age:23
复制代码

       在这个应用程序中,我们可以看到内部了InnerClass可以对外围类OuterClass的属性进行无缝的访问,尽管它是private修饰的。这是因为当我们在创建某个外围类的内部类对象时,此时内部类对象必定会捕获一个指向那个外围类对象的引用,只要我们在访问外围类的成员时,就会用这个引用来选择外围类的成员。

       其实在这个应用程序中我们还看到了如何来引用内部类:引用内部类我们需要指明这个对象的类型:OuterClasName.InnerClassName。同时如果我们需要创建某个内部类对象,必须要利用外部类的对象通过.new来创建内部类:OuterClass.InnerClass innerClass = outerClass.new InnerClass();。

       同时如果我们需要生成对外部类对象的引用,可以使用OuterClassName.this,这样就能够产生一个正确引用外部类的引用了。当然这点实在编译期就知晓了,没有任何运行时的成本。

复制代码
public class OuterClass {
    public void display(){
        System.out.println("OuterClass...");
    }
    
    public class InnerClass{
        public OuterClass getOuterClass(){
            return OuterClass.this;
        }
    }
    
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.getOuterClass().display();
    }
}
-------------
Output:
OuterClass...
复制代码

       到这里了我们需要明确一点,内部类是个编译时的概念,一旦编译成功后,它就与外围类属于两个完全不同的类(当然他们之间还是有联系的)。对于一个名为OuterClass的外围类和一个名为InnerClass的内部类,在编译成功后,会出现这样两个class文件:OuterClass.class和OuterClass$InnerClass.class。

       在Java中内部类主要分为静态内部类、成员内部类、局部内部类、匿名内部类。

静态内部类

静态内部类: 一般也称”静态嵌套类“,在类中用static声明的内部类。

因为是static,所以不依赖于外围类对象实例而独立存在,静态内部类的可以访问外围类中的所有静态成员,包括private的静态成员,但是它不能使用任何外围类的非static成员变量和方法。

同时静态内部类可以说是所有内部类中独立性最高的内部类,其创建对象、继承(实现接口)、扩展子类等使用方式与外围类并没有多大的区别。

复制代码
public class OuterClass {
  //外围类
    public int aa; //实例成员
    private static float f = 1.5f;//private的静态成员
    static void println() {
        System.out.println("这是静态方法");
    }
    protected static class StaticInnerClass{
  //protected的静态内部类
        float a;
        public StaticInnerClass() {
             a = f;// 外围类的private静态变量
             println();//外围类的静态方法
        }
    }
}
class OtherClass{
   public static void main(String[] args) {
       //创建静态内部类的对象
    OuterClass.StaticInnerClass staticInnerClass = new OuterClass.StaticInnerClass(); 
   } 
}
复制代码

成员内部类

成员内部类: 定义在类的内部,而且与成员方法、成员变量同级,即也是外围类的成员之一,因此 成员内部类 与 外围类 是紧密关联的。

注意:
这种紧密关联指的是,成员内部类的对象的创建必须依赖于外围类的对象(即没有外围类对象,就不可能创建成员内部类)。因此,成员内部类有以下3个特点:

  • 成员内部类可以访问外围类的所有成员,包括私有成员;

  • 成员内部类是不可以声明静态成员(包括静态变量、静态方法、静态成员类、嵌套接口),但有个例外---可以声明 static final的变量, 这是因为编译器对final类型的特殊处理,是直接将值写入字节码;

  • 成员内部类对象都隐式地保存了一个引用,指向创建它的外部类对象;或者说,成员内部类的入口是由外围类的对象保持着(静态内部类的入口,则直接由外围类保持着)

成员内部类中的 this,new关键字:

    • 获取外部类对象:OuterClass.this

    • 明确指定使用外部类的成员(当内部类与外部类的名字冲突时):
      OuterClass.this.成员名

    • 创建内部类对象的new:外围类对象.new

//先创建外围类对象
OuterClass outer=new OuterClass();
//创建成员内部类对象
OuterClass.InnerClass inner=outer.new InnerClass();

成员内部类的对象创建

  我们知道,成员内部类就像外围类的实例成员一样,一定要存在对象才能访问,即成员内部类必须绑定一个外围类的对象。上面已经介绍了成员内部类的创建格式了,我们直接看一个例子

复制代码
public class OuterClass {
  //外围类
    public int aa; //实例成员
    private static float f = 1.5f;//private的静态成员
    public void initInnerClass() {
        System.out.println("内部类的初始化方法");
    }
    public void createInnerClass() {
  //
        //外围类的成员方法中创建成员内部类对象
        InnerClass innerClass = new InnerClass();
    }
    class InnerClass{
  //成员内部类
        private double aa; //与围类的变量aa的名字重复
        public InnerClass(){
            this.aa = OuterClass.this.aa + f;//明确指定两个aa的所属
            initInnerClass();
        }
    }   
}
//其他类
class OtherClass{
    public static void main(String[] args) {
        //其他类中创建成员内部类
        OuterClass oc = new OuterClass();//外部类对象
        //创建内部类对象
        OuterClass.InnerClass innerClass = oc.new InnerClass();
    }
}
复制代码

补充几点:

  • 成员内部类可以继续包含成员内部类,而且不管一个内部类被嵌套了多少层,它都能透明地访问它的所有外部类所有成员;

  • 成员内部可以继续嵌套多层的成员内部类,但无法嵌套静态内部类;静态内部类则都可以继续嵌套这两种内部类。

复制代码
class InnerClass{
  //成员内部类
    private double aa; //与围类的变量aa的名字重复
    public InnerClass(){
        this.aa = OuterClass.this.aa + f;//明确指定两个aa的所属
        initInnerClass();
    }
    public  class InnerInnerCalss2{
  //成员内部类中的成员内部类
        protected double aa = OuterClass.this.aa;//最外层的外围类的成员变量
    }//InnerInnerCalss2
}//InnerClass
复制代码

继承成员内部类

在内部类的访问权限允许的情况下,成员内部类也是可以被继承的。由于成员内部类的对象依赖于外围类的对象,或者说,成员内部类的构造器入口由外围类的对象把持着。因此,继承了成员内部类的子类必须要与一个外围类对象关联起来。同时,子类的构造器是必须要调用父类的构造器方法,所以也只能通过父类的外围类对象来调用父类构造器。

下面的例子也是基于上面的例子的,只贴出多出的部分代码。

复制代码
class ChildClass extends OuterClass.InnerClass{
    //成员内部类的子类的构造器的格式
    public ChildClass(OuterClass outerClass) {
        outerClass.super();//通过外围类的对象调用父类的构造方法
    }
}
复制代码

局部内部类

局部内部类: 就是在方法、构造器、初始化块中声明的类,在结构上类似于一个局部变量。因此局部内部类是不能使用访问修饰符

局部内部类的两个访问限制

  • 对于局部变量,局部内部类只能访问final的局部变量。不过,后期JDK(忘了是JDK几了)局部变量可不用final修饰,也可以被局部内部类访问,但你必须时刻记住此局部变量已经是final了,不能再改变。

  • 对于类的全局成员,局部内部类定义在实例环境中(构造器、对象成员方法、实例初始化块),则可以访问外围类的所有成员;但如果内部类定义在静态环境中(静态初始化块、静态方法),则只能访问外围类的静态成员。

复制代码
public class OuterClass {
    private int a = 21;
    static {
  //静态域中的局部内部类
       class LocalClass1{
              //  int z = a; //错误,在静态的作用域中无法访问对象成员
       }
    }
    {
   //实例初始化块中的局部内部类
        class localClass2{          
        }
    }
    public OuterClass(){
        int x = 2;
        final int y = 3;
        // x = 3;//若放开此行注释,编译无法通过,因为局部变量x已经是final类型
        //构造器中的局部内部类
        class localClass3{
            int z = y; //可以访问final的局部变量
            int b = a;//可以访问类的所有成员
             //访问没有用final修饰的局部变量
            int c = x;
        }
    }
    public void createRunnable() {
        final int x = 4;
        //方法中的局部内部类
        class LocalClass4 implements Runnable {
  //
            @Override
            public void run() {
                System.out.println("局部final变量:"+x);
                System.out.println("对象成员变量:"+a);
            }
        }
    }
}
复制代码

推荐博客

  程序员写代码之外,如何再赚一份工资?

匿名内部类

匿名内部类: 与局部内部类很相似,只不过匿名内部类是一个没有给定名字的内部类,在创建这个匿名内部类后,便会立即用来创建并返回此内部类的一个对象引用。

作用:匿名内部类用于隐式继承某个类(重写里面的方法或实现抽象方法)或者实现某个接口。

匿名内部类的访问限制: 与局部内部类一样,请参考局部内部类;

匿名内部类的优缺点:
优点: 编码方便快捷;
缺点:

  • 只能继承一个类或实现一个接口,不能再继承其他类或其他接口。

  • 只能用于创建一次对象实例;

下面的例子是我们创建线程时经常用到的匿名内部类的方式来快速地创建一个对象的例子:

复制代码
class MyOuterClass {
    private int x = 5;
    void createThread() {
        final int a = 10;
        int b = 189;
        // 匿名内部类继承Thread类,并重写Run方法
        Thread thread = new Thread("thread-1") {
            int c = x;  //访问成员变量
            int d = a;  //final的局部变量
            int e = b; //访问没有用final修饰的局部变量
            @Override
            public void run() {
                System.out.println("这是线程thread-1");
            }
        };
        // 匿名内部类实现Runnable接口
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程运行中");
            }
        };
    }
}
复制代码
原文地址 https://www.cnblogs.com/java-chen-hao/p/10412677.html
相关文章
|
23天前
|
Java API Maven
如何使用Java开发抖音API接口?
在数字化时代,社交媒体平台如抖音成为生活的重要部分。本文详细介绍了如何用Java开发抖音API接口,从创建开发者账号、申请API权限、准备开发环境,到编写代码、测试运行及注意事项,全面覆盖了整个开发流程。
70 10
|
21天前
|
监控 Java API
如何使用Java语言快速开发一套智慧工地系统
使用Java开发智慧工地系统,采用Spring Cloud微服务架构和前后端分离设计,结合MySQL、MongoDB数据库及RESTful API,集成人脸识别、视频监控、设备与环境监测等功能模块,运用Spark/Flink处理大数据,ECharts/AntV G2实现数据可视化,确保系统安全与性能,采用敏捷开发模式,提供详尽文档与用户培训,支持云部署与容器化管理,快速构建高效、灵活的智慧工地解决方案。
|
11天前
|
Java 开发者 微服务
Spring Boot 入门:简化 Java Web 开发的强大工具
Spring Boot 是一个开源的 Java 基础框架,用于创建独立、生产级别的基于Spring框架的应用程序。它旨在简化Spring应用的初始搭建以及开发过程。
27 6
Spring Boot 入门:简化 Java Web 开发的强大工具
|
3天前
|
算法 Java API
如何使用Java开发获得淘宝商品描述API接口?
本文详细介绍如何使用Java开发调用淘宝商品描述API接口,涵盖从注册淘宝开放平台账号、阅读平台规则、创建应用并申请接口权限,到安装开发工具、配置开发环境、获取访问令牌,以及具体的Java代码实现和注意事项。通过遵循这些步骤,开发者可以高效地获取商品详情、描述及图片等信息,为项目和业务增添价值。
33 10
|
6天前
|
JavaScript 安全 Java
java版药品不良反应智能监测系统源码,采用SpringBoot、Vue、MySQL技术开发
基于B/S架构,采用Java、SpringBoot、Vue、MySQL等技术自主研发的ADR智能监测系统,适用于三甲医院,支持二次开发。该系统能自动监测全院患者药物不良反应,通过移动端和PC端实时反馈,提升用药安全。系统涵盖规则管理、监测报告、系统管理三大模块,确保精准、高效地处理ADR事件。
|
22天前
|
开发框架 Java 关系型数据库
Java哪个框架适合开发API接口?
在快速发展的软件开发领域,API接口连接了不同的系统和服务。Java作为成熟的编程语言,其生态系统中出现了许多API开发框架。Magic-API因其独特优势和强大功能,成为Java开发者优选的API开发框架。本文将从核心优势、实际应用价值及未来展望等方面,深入探讨Magic-API为何值得选择。
29 2
|
23天前
|
监控 前端开发 Java
【技术开发】接口管理平台要用什么技术栈?推荐:Java+Vue3+Docker+MySQL
该文档介绍了基于Java后端和Vue3前端构建的管理系统的技术栈及功能模块,涵盖管理后台的访问、登录、首页概览、API接口管理、接口权限设置、接口监控、计费管理、账号管理、应用管理、数据库配置、站点配置及管理员个人设置等内容,并提供了访问地址及操作指南。
|
22天前
|
IDE Java 编译器
开发 Java 程序一定要安装 JDK 吗
开发Java程序通常需要安装JDK(Java Development Kit),因为它包含了编译、运行和调试Java程序所需的各种工具和环境。不过,某些集成开发环境(IDE)可能内置了JDK,或可使用在线Java编辑器,无需单独安装。
48 1
|
29天前
|
SQL 安全 Java
安全问题已经成为软件开发中不可忽视的重要议题。对于使用Java语言开发的应用程序来说,安全性更是至关重要
在当今网络环境下,Java应用的安全性至关重要。本文深入探讨了Java安全编程的最佳实践,包括代码审查、输入验证、输出编码、访问控制和加密技术等,帮助开发者构建安全可靠的应用。通过掌握相关技术和工具,开发者可以有效防范安全威胁,确保应用的安全性。
48 4
|
1月前
|
缓存 监控 Java
如何运用JAVA开发API接口?
本文详细介绍了如何使用Java开发API接口,涵盖创建、实现、测试和部署接口的关键步骤。同时,讨论了接口的安全性设计和设计原则,帮助开发者构建高效、安全、易于维护的API接口。
84 4