精华内容
下载资源
问答
  • 匿名内部类可以是抽象类吗
    2022-03-25 19:34:56

    问题1:

    首先我们都知道,接口和抽象都是不能用new来实例化的。

    疑问:那么为什么按钮单机事件setOnClickListener中new的是一个接口(OnClickListener)?

            这个问题先放一放。看见这个问题知道了,原来接口是可以new,只是不能实例化而已。那么又出来了一个问题。

    疑问:接口和抽象类new出来是个什么东西呢?

    可以使用匿名类的方式new出来,但必须实现接口中的所有接口方法和抽象类中的所有抽象方法。

    回到第一个疑问:那么为什么按钮单机事件setOnClickListener中new的是一个接口(OnClickListener)?

    这是实质上是使用匿名接口来实现匿名内部类的, 匿名接口这样写是会自动生成一个实现了该接口的匿名类。

    问题2:匿名内部类没有构造器,编译时又哪来的

    问题由来:局部内部类和匿名内部类只能访问局部final(局部变量和形参都必须用final),(jdk1.8之前需要人为加,在jdk1.8之后不需要加final因为局部变量和形参都默认添加了final)。

    探讨这个问题到匿名内部类访问外部形参的时候看到了:匿名内部类Test$1的构造器含有两个参数,一个是指向外部类对象的引用,一个是int型变量。(等等,匿名内部类不是没有构造器的吗?这是怎么来的)。

            匿名内部类是没有构造函数的,但是可以使用基类的构造函数。

    疑问:那用接口实现的匿名内部类是什么情况呢,它又没有构造函数。

            当通过接口来创建匿名内部类时,匿名内部类不能显示创建构造器,因此匿名内部类里只有一个隐式的无参构造器,故new接口名后的括号里不能传入参数值。

    总结:

            当通过接口来创建匿名内部类时,匿名内部类不能显示创建构造器,因此匿名内部类里只有一个隐式的无参构造器,故new接口名后的括号里不能传入参数值。

            如果通过继承父类来创建匿名内部类时,匿名内部类将拥有和父类相似的构造器,此处的相似指的是拥有相同的形参列表。

    当然,为了弥补没有构造器的缺陷,匿名内部类可以定义初始化块以初始化对象;

    更多相关内容
  • 由于接口和抽象类不能创建类对象,若一个接口的实现类需要使用一次,或者一个抽象类的子类需要使用一次,那么就可以使用匿名内部类;匿名内部类 只能创建一个对象。 类的本体就是大括号里面的所有内容。。 匿名内部...

    匿名内部类在接口和抽象类中的使用

    匿名内部类:

    匿名内部类:没有名字的内部类。
    由于接口和抽象类不能创建类对象,若一个接口的实现类需要使用一次,或者一个抽象类的子类需要使用一次,那么就可以使用匿名内部类;匿名内部类 只能创建一个对象。
    类的本体就是大括号里面的所有内容。。

    匿名内部类实现抽象类的子类:

    例如:

    package com.qfedu.inner.type;
    
    abstract class AbstractTestType {
        abstract public void testInnerType();
    }
    
    /**
     * 一个类继承了Abstract修饰的类,强制要求完成的代码块 testInnerType
     */
    class TestA extends AbstractTestType
    {
    
        @Override
        public void testInnerType() {
            System.out.println("一个类继承Abstract修饰的类,从而要求完成的方法!!!");
        }
    }
    
    /*
    我们要学习匿名类:
        没有名字的类!!!
        是没有类的本体吗???
            类的本体 就是大括号里面的所有内容!!!
     */
    
    public class Demo1 {
        public static void main(String[] args) {
            TestA testA = new TestA();
    
            testA.testInnerType();
    
            /*
            以下代码的大括号中,是一个普通类继承abstract修饰的抽象类,必须完成的
            abstract方法。这不过,当前大括号没有class + 类名,只有【类的本体】
    
            这里实际上创建的对象是一个abstract类的子类对象。
            这里隐含一个继承关系!!!
    
            而且这里使用了多态!!!
            AbstractTestType att 是父类的引用类型变量
            new 创建的是一个子类对象!!!
             */
            AbstractTestType att = new AbstractTestType() {
                @Override
                public void testInnerType() {
                    System.out.println("匿名内部类对象,调用该方法!!!");
                }
            };
    
            // 匿名内部类的对象调用方法!!!
            att.testInnerType();
    
            /*
            使用了一个匿名内部类,并且创建了一个对象,而这个对象也没有名字!!!
            匿名内部类的匿名对象
             */
            new AbstractTestType() {
    
                @Override
                public void testInnerType() {
                    System.out.println("匿名内部类的匿名对象,直接调用方法!!!");
                }
            }.testInnerType();
    
            // low
            test(testA);
    
            // 匿名内部类的匿名对象,直接作为方法的参数!!!
            test(new AbstractTestType() {
                @Override
                public void testInnerType() {
                    System.out.println("匿名内部类的匿名对象,直接作为方法的参数!!!");
                }
            });
        }
    
        public static void test(AbstractTestType t) {
            t.testInnerType();;
        }
    }
    

    匿名内部类接口的实现类:

    例如:

    package com.qfedu.inner.type;
    
    import java.util.Arrays;
    import java.util.Comparator;
    
    /*
    
     */
    interface A {
        public void testInterface();
    }
    
    interface B {
        public void print(int a);
    }
    
    class ZZ implements A {
    
        @Override
        public void testInterface() {
            System.out.println("ZZ类遵从A接口,实现testInterface方法");
        }
    }
    
    
    class SingleDogStaticPreson {
        private int id;
        private String name;
        private int salary;
    
        public SingleDogStaticPreson() {
        }
    
        public SingleDogStaticPreson(int id, String name, int salary) {
            this.id = id;
            this.name = name;
            this.salary = salary;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getSalary() {
            return salary;
        }
    
        public void setSalary(int salary) {
            this.salary = salary;
        }
    
        @Override
        public String toString() {
            return "SingleDogStaticPreson{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", salary=" + salary +
                    '}';
        }
    }
    
    public class Demo2 {
        public static void main(String[] args) {
            ZZ zz = new ZZ();
    
            zz.testInterface();
    
            A a = new A() {
                @Override
                public void testInterface() {
                    System.out.println("匿名内部类对象,调用类内的成员方法");
                }
            };
    
            a.testInterface();
    
            new A() {
                @Override
                public void testInterface() {
                    System.out.println("匿名内部类的匿名对象,直接调用类内的成员方法");
                }
            }.testInterface();
    
            SingleDogStaticPreson s1 = new SingleDogStaticPreson(1, "萌萌", 10);
            SingleDogStaticPreson s2 = new SingleDogStaticPreson(2, "超超", 5);
            SingleDogStaticPreson s3 = new SingleDogStaticPreson(3, "帅帅", 6);
            SingleDogStaticPreson s4 = new SingleDogStaticPreson(4, "嘉豪", 2);
            SingleDogStaticPreson s5 = new SingleDogStaticPreson(5, "托马斯冲", 3);
            SingleDogStaticPreson s6 = new SingleDogStaticPreson(6, "国梁", 0);
    
    
            SingleDogStaticPreson[] arr = {s1, s2, s3, s4, s5, s6};
    
            /*
            匿名内部类的匿名对象,直接作为方法的参数!!!
            超级常用:
                Project
                DBUtils
             */
            Arrays.sort(arr, new Comparator<SingleDogStaticPreson>() {
                @Override
                public int compare(SingleDogStaticPreson o1, SingleDogStaticPreson o2) {
                    return o1.getSalary() - o2.getSalary();
                }
            });
    
            System.out.println(Arrays.toString(arr));
        }
    }
    
    展开全文
  • 匿名内部类可以访问所有的外部类的成员,包括私有的; * 2.不能添加访问修饰符,因为匿名内部类也是一个局部变量; * 3.作用域 : 仅在定义它的方法或代码块中有效; * 4.匿名内部类 访问 外部类的成员的方式

    1.什么是匿名内部类

    定义 :
    1.匿名内部类是定义在类的局部位置,如方法中、代码块中,且没有明确的类名
    2.是一个内部类,本质还是一个类
    3.没有类名;
    4.同时还是一个对象

    2.匿名内部类的特性(关键)

     *         1.匿名内部类可以访问所有的外部类的成员,包括私有的;
     *         2.不能添加访问修饰符,因为匿名内部类也是一个局部变量;
     *         3.作用域 : 仅在定义它的方法或代码块中有效;
     *         4.匿名内部类 访问 外部类的成员的方式 : 直接访问;
     *         5.外部其他类 访问 匿名内部类的方式 : 不可以访问,匿名内部类是一个局部变量;
     *         6.如果 外部类 和 匿名内部类 的成员重名时,默认遵循就近原则,
     *           如果就是想访问 外部类的成员时,使用 【外部类名.this.成员】 的方式;
     *         7.匿名内部类是没有名字的,所以也无需写构造器;
     *         8.匿名内部类的运行时类型是 【外部类名+$+数字】
    

    3.匿名内部类的语法

     *  匿名内部类有两种实现方式:1.实现接口;2.继承一个类。
     *  格式如下 : 
     *         new 接口名/类名(args...){
     *             //内容
     *         };
    

    4.匿名内部类的示例代码

    4.1 声明一个接口

    package com.northcastle.B_niming_innerClass;
    
    /**
     * author : northcastle
     * createTime:2022/2/9
     */
    public interface InterfaceA {
        void sayHello();
    }
    
    

    4.2 声明一个抽象类

    package com.northcastle.B_niming_innerClass;
    
    /**
     * author : northcastle
     * createTime:2022/2/9
     */
    public abstract class ClassA {
        abstract void sayHi();
    }
    
    

    4.3 真正的匿名内部类的代码(核心代码,必看)

    package com.northcastle.B_niming_innerClass;
    
    /**
     * author : northcastle
     * createTime:2022/2/9
     */
    
    /**
     * 本案例演示 : 匿名内部类
     */
    public class NimingInnerClass {
    
        //1.外部类的成员
        private String field01 = "外部类的私有属性field01";
        public String field02 = "外部类的共有属性field02";
        //2.外部类的构造器
        public NimingInnerClass() {
        }
        public NimingInnerClass(String field01, String field02) {
            this.field01 = field01;
            this.field02 = field02;
        }
        //3.外部类的方法
    
        /**
         * 3.1 一个普通的方法
         */
        public void method01(){
            System.out.println("外部类的方法:method01");
        }
    
        /**
         * 3.2 实现接口的匿名内部类
         */
        public void method02(){
            //这个方法中包含实现接口的匿名内部类
            //1.匿名内部类的定义
            InterfaceA interfaceA_niming = new InterfaceA() {
                public String field01 = "接口+匿名内部类中的field01";
                @Override
                public void sayHello() {
                    System.out.println("接口+实现接口的匿名内部类对你说 : Hello");
                    //2.使用匿名内部类的属性
                    System.out.println("接口匿名内部类的field01 : "+field01);
                    System.out.println("外部类的field01 : "+NimingInnerClass.this.field01);
                    System.out.println("外部类的field02 : "+field02);
                }
            };
            //3.判断匿名内部类类型 : 编译类型、运行时类型
            System.out.println("接口+匿名内部类 的运行时类型 : "+interfaceA_niming.getClass());
            //4.运行匿名内部类对象的方法
            interfaceA_niming.sayHello();
    
        }
    
        /**
         * 3.3. 继承类的匿名内部类
         */
        public void method03(){
            //这个方法中包含实现类的匿名内部类
            //1.匿名内部类的定义
            ClassA classA_niming = new ClassA() {
    
                public String field01 = "类+匿名内部类中的field01";
    
                @Override
                void sayHi() {
                    System.out.println("类+匿名内部类对你说 : Hi");
                    //2.使用匿名内部类的属性
                    System.out.println("类+匿名内部类的field01 : "+field01);
                    System.out.println("外部类的field01 : "+NimingInnerClass.this.field01);
                    System.out.println("外部类的field02 : "+field02);
                }
            };
            //3.判断匿名内部类类型 : 编译类型、运行时类型
            System.out.println("类+匿名内部类 的运行时类型 : "+classA_niming.getClass());
            //4.运行匿名内部类的对象的方法
            classA_niming.sayHi();
    
        }
    
        /**
         * 3.4 作为实参的匿名内部类
         * @param interfaceA
         */
        public void method04(InterfaceA interfaceA){
            // 这里演示最常用的使用方式 : 匿名内部类作为实参传入方法中
            interfaceA.sayHello();
        }
    
    }
    
    

    4.4 外部其他类对匿名内部类的使用

    package com.northcastle.B_niming_innerClass;
    
    /**
     * author : northcastle
     * createTime:2022/2/9
     */
    public class Application {
        public static void main(String[] args) {
            //1.定义一个外部类的对象
            NimingInnerClass nimingInnerClass = new NimingInnerClass();
    
            //2.调用外部类对象的方法
            nimingInnerClass.method01();//普通方法
            System.out.println("==============================");
            
            nimingInnerClass.method02();//包含匿名内部类的方法
            System.out.println("==============================");
            
            nimingInnerClass.method03();//包含匿名内部类的方法
            System.out.println("==============================");
            
            nimingInnerClass.method04(new InterfaceA() { //匿名内部类作为参数的方法
                @Override
                public void sayHello() {
                    System.out.println("实参中的匿名内部类向你说 Hello啦");
                }
            });
        }
    }
    
    

    4.5 运行结果

    运行结果与特性中表述的一致。

    在这里插入图片描述

    5.完成

    Congratulations!
    You are one step closer to success!

    展开全文
  • 什么是匿名内部类,如何使用匿名内部类

    万次阅读 多人点赞 2020-11-12 14:09:48
    此时可以使用匿名内部类的方式,可以无需创建新的,减少代码冗余。 下面详细说明一下 假设当前有一个接口,接口中只有一个方法 public interface Interface01 { void show(); } 为了使用该接口的show方法,

    匿名内部类

    匿名内部类,就是没有名字的一种嵌套类。它是Java对类的定义方式之一。

    为什么要使用匿名内部类

    在实际开发中,我们常常遇到这样的情况:一个接口/类的方法的某个实现方式在程序中只会执行一次,但为了使用它,我们需要创建它的实现类/子类去实现/重写。此时可以使用匿名内部类的方式,可以无需创建新的类,减少代码冗余

    下面详细说明一下

    假设当前有一个接口,接口中只有一个方法

    public interface Interface01 {
        void show();
    }
    

    为了使用该接口的show方法,我们需要去创建一个实现类,同时书写show方法的具体实现方式

    public class Interface01Impl implements Interface01{
        @Override
        public void show() {
            System.out.println("I'm a impl class...");
        }
    }
    

    如果实现类Interface01Impl全程只使用一次,那么为了这一次的使用去创建一个类,未免太过麻烦。我们需要一个方式来帮助我们摆脱这个困境。匿名内部类则可以很好的解决这个问题。

    我们使用匿名内部类

    public static void main(String[] args) {
        Interface01 interface01 = new Interface01() {
            @Override
            public void show() {
                System.out.println("这里使用了匿名内部类");
            }
        };
        //调用接口方法
        interface01.show();
    }
    

    成功运行结果

    这里使用了匿名内部类

    如何使用匿名内部类

    基本格式

    new 接口/类名(参数1, 参数2...){
        实现方法1(){
            
        }
        实现方法2(){
            
        }
        ......
    };
    

    在上文的使用中,我们没有创建实现类就实现了具体的show方法。同时定义了接口的对象变量interface01。我们发现,这个变量和平常使用多态后的使用方式没有区别。

    通常,我们也习惯用这样的方式创建并启动线程

    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("我是一个线程");
        }
    }).start();
    

    常见问题

    1. 匿名内部类是怎么实现的

      在上文代码编译后,我们查看一下class文件的路径

    BxrQZd.png

    再反编译一下看看

    BxsW1f.png

    至此,我们可以得知,匿名内部类在编译期间,会生成一个名称以$编号结尾的class文件,即它被识别为一个真实的类,仅在编译前(java文件)为匿名的形态。

    1. 匿名内部类只可以使用在接口上吗

      不是的。匿名内部类可以用在具体类、抽象类、接口上,且对方法个数没有要求。

      举例说明:设存在具体类Class01,抽象类AbstractClass01,接口Interface01

      //具体类
      public class Class01 {
          public void show(String s){
              System.out.println("啦啦啦");
          }
      }
      
      //抽象类
      public abstract class AbstractClass01 {
          abstract void show(String s);
      }
      
      //接口
      public interface Interface01 {
          void show(String s);
      }
      

      测试类TestInner

      public class TestInner {
          public static void main(String[] args) {
              
              //重写具体类的方法
              new Class01(){
                  @Override
                  public void show(String s) {
                      System.out.println("我是一个" + s);
                  }
              }.show("具体类");
      
              //重写抽象类的抽象方法
              new AbstractClass01(){
                  @Override
                  void show(String s) {
                      System.out.println("我是一个" + s);
                  }
              }.show("抽象类");
      
              //实现接口的抽象方法
              new Interface01(){
                  @Override
                  public void show(String s) {
                      System.out.println("我是一个" + s);
                  }
              }.show("接口");
      
      
          }
      }
      

      运行结果

      我是一个具体类
      我是一个抽象类
      我是一个接口

    展开全文
  • java匿名内部类什么是匿名内部类匿名内部类的使用场景?匿名内部类如何创建?匿名内部类的实现和使用例1(实现接口)例2(继承) 什么是匿名内部类匿名内部类,顾名思义,就是不知道这个到底是什么名字,也...
  • /* * 使用接口创建匿名内部类的使用一般只是使用了一次的类*/ interface Product{ int getPrice();... * 使用抽象类创建匿名内部类*/ abstract class ProductTwo{ private String name; privat...
  • 一个方法可以修改传递引用所对应的变量值,而不能修改传递值调用所对应的变量值。 按值调用:包括八大基本数据类型都是按值调用。传值的时候,也就是说方法得到的是所有参数值的一个拷贝。 按引用调用:数组、对象...
  • public class TestClass { private InterfaceA a = new InterfaceA() { @Override public void testA() { ...//成员匿名类,例如在Android开发中常用的Handler。 public static void main(St...
  • 抽象方法,抽象类 (一)抽象方法: 定义:只声明而未实现的方法,即没有方法体的方法。 抽象方法使用 abstract 修饰,具有抽象方法的类也用 abstract 修饰。 即 具有抽象方法的类一定是抽象类,但抽象类中不一定有...
  • java 匿名内部类

    千次阅读 2022-04-10 09:07:39
    1. 匿名内部类介绍 使用 Java 编程时,常常需要创建不会被再次使用的对象。在这种情况下,非常适合使用一种特殊 的内部匿名内部类。这种没有名称,是在同一条语句中声明和创建的。 要使用匿名内部类,可将...
  • 程序员你真的理解匿名内部类吗?

    万次阅读 多人点赞 2019-10-10 22:22:30
    为了加深各位对匿名内部类的印象、好奇心以及求知的渴望,咋们先来看一个程序,如果提到线程你会不会立马想到接口和继承?如果提到接口和继承你会不会立马想到匿名内部类? 开篇甜点 为了加深各位对匿名内部类的...
  • Java基础之匿名内部类匿名内部类是什么?为什么要用匿名内部类匿名内部类详解。 什么是匿名内部类? 顾名思义 匿名 就是没有名字,一个没有名字的内部,称为匿名内部类。 下面先看一个例子,比如说你想和你的女...
  • 关于匿名内部类的一些理解

    千次阅读 2021-09-21 15:51:21
    内部就是将一个定义在某个或者方法里面,一共分为四种:成员内部、局部内部匿名内部类、静态内部 其中局部内部就是将一个定义在了一个方法之中,类似于 class Demo{ public void test(){ class ...
  • Java内部匿名内部类的用法

    万次阅读 多人点赞 2016-07-21 15:46:41
    Java内部类和匿名内部类的用法 【尊重原创,转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51981163一、内部类: (1)内部类的同名方法 内部类可以调用外部类的方法,如果内部类有同名方法...
  • 1. 匿名内部类总是默认实现某个接口或继承某个抽象类。 2.不能有构造方法,只能有一个实例。 3. 不能定义在任何静态成员、静态方法。 4. 不能是public.protected.private static. 5. 匿名内部类为局部的,所以...
  • 大家面试的时候肯定被问过java 接口、抽象类、具体类、内部类、匿名内部类的区别及它们之间的关系。那么下面我就来整理下它们之间的关系。
  • 今天复习java基础知识,发现了一个具有代表性的关于枚举的程序片段,很好的解释了枚举中的匿名内部类抽象方法 public enum Operation { PLUS{ public double eval(double x,double y){ return x+y; } }, ...
  • JAVA匿名内部类笔记(适合初学者)
  • 匿名内部类是不是就是在在参数列表中可以new 接口或者抽象类? 匿名内部类是不是就是在在参数列表中可以new 接口或者抽象类? 匿名内部类是不是就是在在参数列表中可以new 接口或者抽象类?
  • lambda表达式与匿名内部类

    万次阅读 2020-08-07 14:13:01
    Lambda表达式类似匿名函数,简单地说,它是没有声明的方法,也即没有访问修饰符、返回值声明和方法名。 Lambda允许把函数作为一个方法的参数(函数作为参数传递进方法中)。 Lambda表达式的语法 (parameters) -> ...
  • 广泛意义上的内部一般来说包括这四种:成员内部、局部内部匿名内部类和静态内部。 成员内部: 成员内部是最普通的内部,它的定义为位于另一个的内部。 例: class Test1{ private String ...
  • Lambda表达式与匿名内部类

    千次阅读 2019-04-24 19:27:55
    匿名内部类适合创建那种只需要一次使用的匿名内部类的语法有点奇怪,创建匿名内部类时会立即创建一个该的实例,这个定义立刻消失,匿名内部类不能重复使用(一次性的) 定义匿名内部类的格式如下: new...
  • Scala进阶_抽象类匿名内部

    千次阅读 2020-02-16 11:51:41
    和Java语言一样,scala中也可以定义抽象类 定义 如果类的某个成员在当前类中的定义是不包含完整的,它就是一个抽象类 不完整定义有两种情况: 方法没有方法体(抽象方法) 变量没有初始化(抽象字段) 定义抽象类...
  • 匿名内部类

    千次阅读 多人点赞 2019-10-22 20:28:46
    匿名内部类 匿名内部类:没有名称的,主要用来创建对象(只创建一次) 匿名内部类需要通过父类或者接口实现。 语法: 父类名/接口名 对象名 = new 父类名/接口名 { 重写的父类的方法 或 实现的接口中的...
  • 匿名内部类

    千次阅读 2022-03-16 17:44:12
    提示:这里可以添加系列文章的所有文章的目录,目录需要自己手动添加 例如:第一章 Python 机器学习入门之pandas的使用 提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录系列文章目录...
  • 官方解释:Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的实现,而这些实现可以具有不同的行为(功能)。 在接口中,它的方法...
  • 这是一个抽象类 package org.westos.demo7; abstract class Device { private String name; public abstract double getPrice(); public Device(){} public Device(String name){ this.n...
  • 匿名内部类也就是没有名字的内部正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口实例1:不使用匿名内部类来实现抽象方法...
  • 此篇和上一篇的“使用抽象类”方式相互印证。/*** 匿名内部类的概念和特性:* 1、匿名内部类只能也必须(有且仅有)继承一个父类或者实现一个接口,...* 4、匿名内部类可以定义初始化块以初始化对象,以弥补没有构造器...
  • Java 内部类、匿名内部类、抽象类

    千次阅读 2016-07-28 22:50:51
    何为内部类内部类是指 在一个中在定义一个 如: 1.成员内部类public class F { private int a; public void fun(){ //TODO } public class M{ private int a; public void fun(){ //TODO

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,106
精华内容 34,442
关键字:

匿名内部类可以是抽象类吗

友情链接: df3.rar