内部类和匿名内部类

已于 2022-01-19 15:50:58 修改
阅读量238 收藏 1
点赞数
文章标签： java 开发语言 后端
于 2022-01-19 15:49:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46954550/article/details/122582705
版权

内部类：

        把类定义在其他类的内部，我们称之为内部类

内部类有哪些特点：

        1、内部类可以访问外部类的成员，包括私有

        2、外部类要想访问内部类的成员，必须要创建内部类的对象

class Outer{
    private int num = 10;

    class Inner{
        public void show(){
            System.out.println(num);
        }
    }

    public void fun(){
//        show();
        //创建内部类对象
        Inner inner = new Inner();
        inner.show();
    }

}


public class InnerClassDemo1 {
    public static void main(String[] args) {
        Outer outer = new Outer();
//        outer.show();
        outer.fun();
    }
}

内部类位置

        成员位置（成员内部类）

        局部位置（局部内部类）

class Outer2{
    //定义在成员的位置上（成员内部类）
    class Inner2{

    }

    public void fun(){
        //定义在局部范围内（局部内部类）
        class Inner3{

        }
    }


}


public class InnerClassDemo2 {
}

成员内部类：

        1、定义在类的成员的位置上

        2、内部类可以访问外部类的成员，包括私有

正确创建成员内部类对象的格式：

        外部类名.内部类名 对象名=new 外部类名().new 成员内部类名();

class Outer3{
    private int num = 10;

    class Inner{
        public void show(){
            System.out.println(num);
        }
    }
}


public class InnerClassDemo3 {
    public static void main(String[] args) {
        //需求：我现在要想在测试类中访问到Inner类中的show方法，咋办，就必须得创建对象
//        Inner inner3 = new Inner();

        //正确创建成员内部类对象的格式
        //外部类名.成员内部类名 对象名 = new 外部类名().new 成员内部类名();
//        Outer3.Inner oi3 = new Outer3().new Inner();
//        oi3.show();

        Outer3 outer3 = new Outer3();
        Outer3.Inner inner = outer3.new Inner();
        inner.show();
    }
}

成员内部类常见的修饰符：

        private：其他类不能直接创建内部类的对象，要想使用被private修饰的类，就要间接的使用方法调用内部类的方法

        static：内部类如果是被static修饰的时候，只能访问外部类中的成员

当内部类被静态修饰的时候，创建内部类的另一种方式：

        外部类名.内部类名 对象名=new 外部类名.内部类名();

class Outer4 {
    //    private int num = 200;
    private static int num = 200;

//    private class Inner4{
//        public void fun(){
//            System.out.println(num);
//        }
//    }

    static class Inner4 {
        public static void fun() {
            System.out.println(num);
        }
    }

//    public void show() {
//        Inner4 inner4 = new Inner4();
//        inner4.fun();
//    }

}

public class InnerClassDemo4 {
    public static void main(String[] args) {
//        Outer4.Inner4 oi4 = new Outer4().new Inner4();
//        oi4.fun();
//        Outer4 outer4 = new Outer4();
//        outer4.show();

//        Outer4.Inner4 oi4 = new Outer4.new Inner4();
        //当内部类是被静态所修饰的时候，出现了另外一种创建内部类的方式
        //格式如下：
        //外部类名.内部类名 对象名 = new 外部类名.内部类名();
//        Outer4.Inner4 oi4 = new Outer4.Inner4();
//        oi4.fun();

        //直接通过类名直接调用
        Outer4.Inner4.fun();

    }
}

局部内部类：

        1、定义在方法中的类

        2、局部内部类可以直接用外部类中的所有成员

        3、在局部内部类中引用的本地变量是最终变量（存在局部内部类的方法中定义局部变量自动加上final关键字）

在jdk1.8之后加上final

class Outer6{
    private int num = 10;

    public void fun(){
        int num2 = 20;//无法修改值，因为前面有一个final修饰
        class Inner6{
            int num3 = 300;
            public void show(){
                num3 = 30;
                //在局部内部类中引用的本地的变量必须是最终变量或者实际上的最终变量
                //通过反编译工具观察发现，存在局部内部类的方法中定义的局部变量自动加上了final关键字
                //在JDK1.8之后会自动加上final关键字
//                num2 = 22;
                num = 44;

                System.out.println(num);
                System.out.println(num2);
                System.out.println(num3);
            }
        }

        Inner6 inner6 = new Inner6();
        inner6.show();
    }



}

public class InnerClassDemo6 {
    public static void main(String[] args) {
        Outer6 outer6 = new Outer6();
        outer6.fun();
    }
}

匿名内部类

        语句定义格式：

                new 类名（可以是抽象类也可以具体的类）/接口（）{

                        要重写的方法;

                };匿名内部类对象

interface Inter{
    public abstract void show();
    public abstract void show2();
}

//class B implements Inter{
//
//    @Override
//    public void show() {
//
//    }
//
//    @Override
//    public void show2() {
//
//    }
//}

//Inter i = new B()

class Outer7{
    public void fun(){
        //使用匿名内部类的形式创建对象调用show方法
        new Inter(){
            @Override
            public void show() {
                System.out.println("这是show方法");
            }

            @Override
            public void show2() {
                System.out.println("这是show2方法");
            }
        }.show();

        //使用匿名内部类的形式创建对象调用show2方法
        new Inter(){
            @Override
            public void show() {
                System.out.println("这是show方法");
            }

            @Override
            public void show2() {
                System.out.println("这是show2方法");
            }
        }.show2();

        System.out.println("======================================");

        //想一想，我现在的接口中，只有两个方法，方法的个数比较少，没调用一个方法，都要new一下，并且new之后的内容都是一样的
        //如果以后接口中的方法很多的时候，你再用这样的方法，就会很麻烦
        //怎么改进呢？
        //利用接口多态的形式给匿名内部类起名字
        Inter inter = new Inter(){
            @Override
            public void show() {
                System.out.println("这是show方法");
            }

            @Override
            public void show2() {
                System.out.println("这是show2方法");
            }
        };

        inter.show();
        inter.show2();



    }
}


public class InnerClassDemo7 {
    public static void main(String[] args) {
        Outer7 outer7 = new Outer7();
        outer7.fun();
    }
}

匿名内部类存在的前提：

        要存在一个类或者是一个接口，这个类可以是具体的类也可以是抽象的类

        利用接口多态为匿名内部类取个名字接收

        匿名内部类在开发中的使用

        调用一个方法后继续调用方法，说明第一个方法是有返回值的

匿名内部类：

1、有参构造方法参数是接口类型的时候

interface Outer11{
    public abstract void fun();
}
//有参构造方法参数是接口类型的时候
class Inter11{
    Outer11 outer11;
    Inter11(Outer11 outer11){
        this.outer11=outer11;
    }

}
//有参构造方法的作用就是初始化变量
public class InterfaceDemo11 {
    public static void main(String[] args) {
        //使用接口多态为方法初始化
        Outer11 outer11=new Outer11() {
            @Override
            public void fun() {
                System.out.println("xuexi");
            }
        };
        outer11.fun();
    }
}

2、当成员方法的参数是接口类型的时候

interface Outer12{
    public abstract void fun();
}
//当成员方法的参数是接口类型的时候
class Inter12{
    Outer12 outer12;
    public void show(Outer12 outer12){
        outer12.fun();
    }

}
public class InterfaceDemo12 {
    public static void main(String[] args) {
        Inter12 inter12=new Inter12();
        inter12.show(new Outer12() {
            @Override
            public void fun() {
                System.out.println("学习");
            }
        });
    }
}

3、当返回值类型是接口的成员方法的时候

interface Outer13{
    public abstract void fun();
}
//当返回值类型是接口的成员方法的时候
class Inter13{
    Outer13 outer13;
    public Outer13 show(){
        Outer13 outer13=new Outer13() {
            @Override
            public void fun() {
                System.out.println("学习");
            }
        };
        return outer13;
    }
}
public class InterfaceDemo13 {
    public static void main(String[] args) {
        Inter13 inter13=new Inter13();
        //inter13.outer13.fun();NullPointerException这个时候调用的是Inter13中的fun方法而不是返回值里面的fun方法
        inter13.show().fun();
    }
}

m0_46954550
关注
Java内部类和匿名内部类的用法说明
08-18
内部类可以访问外部类的成员变量和方法，而匿名内部类则是内部类的一种特殊形式，下面我们将详细介绍Java内部类和匿名内部类的用法说明。 一、内部类 内部类是指在一个类中定义的另一个类，它可以访问外部类的成员...
c#入门-匿名类
zms9110750的博客
01-02 1678
声明局部变量时可以使用一种特殊的语法声明匿名类。匿名类没有名字，所以不需要带类型名（但编译器还是会做出一个实体类来）。只能使用var声明变量，所以只能作为局部变量。值的那边使用new+对象初始化器声明并赋值内容。匿名类和元组类似，但是他的值都是只读属性。不可更改也不可获得引用。并且只能声明属性，不能声明方法。
一篇文章带你学会匿名内部类，由浅入深，一定手把手教会你
m0_70325779的博客
07-14 2680
听名字就能看得出来，内部类，就是定义类中的一个类。在A类中定义一个B类，那么B类就是A类的内部类。通过上面我所展示的和解释的，我们应该明白以下几点（1）什么是匿名内部类？匿名内部类不是真的没有名字，只是在代码中没有体现出来，在编译时，会单独将他编译成一个类并赋予默认的名字。（2）匿名内部类可以在什么位置？匿名内部类既可以定义在成员位置，也可以定义在局部位置；当我们将匿名内部类定义在成员位置，他就是成员匿名内部类；当我们把它定义在方法体之内，他就是局部匿名内部类。（3）格式的细节。
匿名内部类
qq_52280112的博客
02-18 639
例子：//源于hsp 1.有一个铃声接口 Bell，里面有个 ring 方法。2.有一个手机类 Cellphone，具有闹钟功能 alarmClock，参数是 Bell 类型3.测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印：懒猪起床了 4.再传入另一个匿名内部类(对象)，打印：小伙伴上课了 package com_cc.Private; /** * @author cc! * @version 1.0 * 匿名内部类 */ public class 匿...
【匿名内部类】
syp_snowy的博客
03-17 4176
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可
C#中的匿名类型
zls365365的博客
08-27 2112
这节来讲一下C#中的匿名类型。匿名类在C#中，我们可以不去显示的声明一个类，而是通过匿名类去临时声明一个类结构去帮助我们去完成一些功能。声明一个匿名类，我们可以像下面这样做：var Anonymous=new {name="charles",year=18};//声明匿名类对象需要注意的是，匿名类成员只能声明公共的只读属性，不能在匿名类中声明方法，因此匿名类的作用主...
Java局部内部类和匿名内部类定义与用法实例分析
08-25
"Java 局部内部类和匿名内部类定义与用法实例分析" Java 局部内部类和匿名内部类是 Java 编程语言中两种重要的内部类定义方式，它们在 Java 面向对象程序设计中扮演着重要的角色。本文将详细介绍 Java 局部内部类和...
Java的内部类和匿名类剖析
01-21
在那些修改中，引人注目的是内部类和匿名类。如运用得当，它们可使程序更易理解和维护。本文介绍内部类和匿名类在Java代码中是如何具体工作的，如何正确使用它们，以及如何避免一些常见的错误。 下面来看看这些特性...
全面了解Java中的内部类和匿名类
09-01
匿名内部类是另一种特殊的内部类，它没有名称，通常用于快速实现接口或抽象类的简短回调。在Java中，当只需要用一次的类实现某个接口或者继承某个类时，可以使用匿名内部类。例如： ```java Runnable r = new ...
匿名内部类以及Lambda表达式（Java和C#）
RBK的博客
06-09 2625
就来说一说这个匿名内部类，用Java做例子，后面插一点c#。这个东西我之前也知道了很久，一直没有认真去看过，这次就来看看吧，今天的代码量相对很多。 匿名内部类 这里就说匿名内部类，关于其他内部类老规矩，以后有空了再说 匿名内部类的使用 好像很多地方都不说这具体是个什么东西，都是直接上代码说话。 顾名思义，是没有名字的内部类，举个栗子 new View.OnClickListener(){ ...
C#中匿名类的声明及使用
最新发布
忧郁的蛋的专栏
11-12 911
C#中声明方法或类时，可以不指定的类或方法的名字，也就是匿名类和匿名的方法。以下主要介绍C#中匿名类的声明及使用。
匿名对象、内部类、匿名内部类
是小朱啊的博客
02-05 378
匿名对象 概念 创建对象时，只有创建对象的语句，却没有对象地址值复制给某个变量。虽然是创建对象的简化写法，但是应用场景非常有限。 格式： new 类名(参数列表) 举例： new Scanner(System.in); 应用场景 创建匿名对象直接调用方法，没有变量名 new Scanner(System.in).nexInt(); 一旦调用两次方法，就是创建了两个对象，造成浪费 new Scanner(System.in).nexInt(); new Scanner(System.in
匿名内部类可以有构造方法_java匿名内部类
weixin_36329899的博客
01-17 3524
什么是内部类？将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。成员内部类定义在类中方法外的类。定义格式：class 外部类 { class 内部类{ } }在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类Car 中包含发动机类Engine ，这时，Engine就可以使用内部类来描述，定义在成员位置。代码举例：class...
匿名内部类_匿名
cunchi8090的博客
07-19 168
匿名内部类Anonymous Types in C# C＃中的匿名类型 by Ivo Stoykov 通过伊沃·斯托伊科夫（Ivo Stoykov） Anonymous Types are useful when we do not need to follow usual work-flow -- crea...
【笔记】【LINQ编程技术】第一章 使用匿名类型
极客神殿
03-28 451
匿名类型使用关键字var。简而言之，匿名类型就是说你不用指定具体的类型。只要写上var即可，CSharp将计算出右侧表达式所定义的数据类型。然后CSharp编译器指定所定义的变量为该类型。类型被指定以后就相当于强类型，且由编译器在运行时进行类型检查。 请记住，你无需编写类型定义，因为CSharp会帮你计算出来。这一点很重要，因为在查询语言中，你所请求的以及所获取到的任何特定类型都是根据上下文(查询结果)来定义的。简单地说，查询结果可能会返回一个之前没有定义的类型。 1. 使用匿名类型时需要遵守的一些基本
局部内部类和匿名内部类
09-14
局部内部类和匿名内部类是Java中的两种特殊类型的内部类。 局部内部类是定义在方法或者代码块内部的类。它的作用域被限定在所属的方法或代码块内部，不能在外部访问。局部内部类可以访问所属方法或代码块的局部变量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值