精华内容
下载资源
问答
  • 主要给大家介绍了关于Java匿名内部类的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java匿名内部类什么是匿名内部类?匿名内部类的使用场景?匿名内部类如何创建?匿名内部类的实现和使用例1(实现接口)例2(继承类) 什么是匿名内部类? 匿名内部类,顾名思义,就是不知道这个类到底是什么名字,也...

    什么是匿名内部类?

    匿名内部类,顾名思义,就是不知道这个类到底是什么名字,也就是不知道类名。

    匿名内部类的使用场景?

    匿名内部类适合创建那种只需要使用一次的类,也就是说创建一个匿名内部类,只需要用一次即可。

    匿名内部类如何创建?

    new 类名(参数) | 实现接口()
    {
    // 匿名内部类的类体部分
    }
    从上面的定义可以看出,匿名内部类必须继承一个父类,或实现一个接口,但最多只能继承一个父类,或者实现一个接口。
    两个规则:
    	匿名内部类不能是抽象类。
    	匿名内部类不能定义构造器。由于匿名内部类没有类名,所以无法定义构造器,但匿名内部类可以初始化块,可以通过初始化块来完成构造器需要完成的工作。
    

    匿名内部类的实现和使用

    例1(实现接口)

    首先,定义一个匿名类要实现的接口,代码如下

    public interface Product{
     double getPrice();
     String getName();
    

    然后,定义一个实体类,实体类定义一个方法,方法的参数为上述的接口对象,到时候会传入一个匿名类对象,这个匿名类实现了上述创建的接口,代码如下

    public class Anony{
    	public void test(Product product){
    	System.out.println("购买了一个"+product.getName()+",花掉了"+product.getPrice());
    	}
    }
    

    最后测试运行:

    pubic class Test{
    	public static void main(String[] args){
    		Anony anony=new Anony();
    		// 注意,此处要传入一个匿名类对象
    		anony.test(new Product(){
    			@Override
    			public double getPrice(){
    					return 578.6;
    				}
    			@Override
    			public String getName(){
    					return "联想笔记本";
    				}
    			}
    		);
    	}
    }
    

    输出:

    购买了一个联想笔记本,花掉了578.6
    

    总结:此处匿名内部类的作用就是实现了一个接口,创建了一个实现了该接口的类的对象,然后重写了这个接口中的方法。

    例2(继承类)

    首先,定义一个匿名类需要实现的抽象类,代码如下:

    public abstract class Device{
    	private String name;
    	public abstract double  getPrice();
    	public String getName(){
    	 	return name;
    	}
    	public Device(){}
    	public Device(String name){
    		this.name=name;
    	}
    } 
    

    然后,定义一个实体类,实体类定义一个方法,方法的参数为上述的抽象类对象,到时候会传入一个匿名类对象,这个匿名类继承了上述创建的抽象类,代码如下

    public class Anony {
    
        public void test(Device device){
            System.out.println("购买了一个"+device.getName()+"花费了"+device.getPrice());
        }
    }
    

    最后测试运行:

    pubic class Test{
    	public static void main(String[] args){
    		Anony anony=new Anony();
    		// 注意,此处要传入一个匿名类对象
    		anony.test(new Device("海尔电视机"){
    			@Override
    			public double getPrice(){
    					return 578.6;
    				}
    		);
    		Device device=new Device(){
    			@Override
    			public double getPrice(){
    				return 556.56;
    			}
    			@Override
    			public String getName(){
    				return "美的电视机";
    			}
    		};
    		annoy.test(device);
    	}
    }
    

    输出:

    购买了一个海尔电视机,花掉了578.6
    购买了一个美的电视机,花掉了556.56
    

    总结:对象匿名类中继承抽象类,对于抽象类里面的抽象方法,必须要重写,对象抽象类里面的非抽象方法,可重写也可以不重写。

    展开全文
  • Java匿名内部类

    2020-07-17 18:21:26
    Java匿名内部类 什么是匿名内部类 匿名内部类,顾名思义,就是没有名字的类,一个带具体实现的父类或者父接口的匿名的`子类对象。匿名内部类格式如下 new name([参数列表]){ //name为父类或者是接口的名字 //方法...

    Java匿名内部类

    什么是匿名内部类

    匿名内部类,顾名思义,就是没有名字的类,一个带具体实现的父类或者父接口的匿名的`子类对象。匿名内部类格式如下

    new name[参数列表]{   //name为父类或者是接口的名字
    	//方法重写
    	Override
    	..........
    }

    特点

    1.匿名内部类不能定义任何静态成员、方法。

    在这里插入图片描述
    在这里插入图片描述

    2.匿名内部类中的方法不能是抽象的;
    因为在创建匿名内部类的时候,会立即创建它的实例,可知匿名内部类不能是抽象类,必须实现接口或抽象父类的所有抽象方法。
    3.匿名内部类访问的外部类成员变量或成员方法必须用static修饰;
    在这里插入图片描述
    4.匿名内部类 必须和创建对象一起存在
    在这里插入图片描述
    5.匿名内部类创建的对象一定是普通类或抽象类的子类,一定是接口的实现类对象

    6.匿名内部类常用于重写父类或者接口中的方法,也可以定义新的属性和方法,但是上转型对象无法调用子类新增的属性和方法(同多态)

    在这里插入图片描述

    7.匿名内部类因为没有类名,可知匿名内部类不能定义构造器

    8.当匿名内部类和外部类有同名变量(方法)时,默认访问的是匿名内部类的变量(方法),要访问外部类的变量(方法)则需要加上外部类的类名。
    在这里插入图片描述

    此时为了输出外部类的weight需要使用外部类名.变量名来调用
    在这里插入图片描述

    展开全文
  • 主要介绍了Java局部内部类和匿名内部类,结合实例形式分析了java局部内部类和匿名内部类相关定义、原理与用法,需要的朋友可以参考下
  • 主要简单给我们介绍了java匿名内部类构造函数,并附上了简单的示例,有需要的小伙伴可以参考下。
  • Java 匿名内部类

    2017-08-02 22:58:32
    Java 匿名内部类的学习demo
  • 主要介绍了Java匿名内部类原理与用法,结合实例形式分析了Java匿名内部类的概念、原理、应用与相关操作注意事项,需要的朋友可以参考下
  • 主要介绍了java 内部类详解及实例代码的相关资料,需要的朋友可以参考下
  • 下面小编就为大家带来一篇老生常谈java匿名内部类。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • java匿名内部类和lambda(匿名方法)

    千次阅读 2019-07-28 13:05:21
    匿名内部类 内部类分4种:成员内部类,静态内部类,局部内部类和匿名内部类。我们今天讨论的就是其中最常见的匿名内部类。从名称可以看出,就是没有名字的类,因为没有名字,所以总归和其它普通类有一些些区别: ...

    匿名内部类

    内部类分4种:成员内部类,静态内部类,局部内部类和匿名内部类。我们今天讨论的就是其中最常见的匿名内部类。从名称可以看出,就是没有名字的类,因为没有名字,所以总归和其它普通类有一些些区别:

    1. 类如果没有名字,就只能在定义类的时候直接实例化,否则这个类永远得不到使用,也就没有意义。但这样也就代表这个类不能重复使用,不能在其它地方继续实例化了。
    2. 类如果没有名字,那怎么创建这个对象的引用呢?所以匿名内部类必须继承一个父类或者实现一个接口,然后通过父类引用匿名内部类实例,再通过多态特性调用方法。不过,只能继承一个父类,或实现一个接口。
    3. 定义完就立刻需要实例化,也就代表这个类不可能是抽象类,所以也就不能拥有任何抽象方法。
    4. 类没有名字,所以也不存在类变量,类方法,类初始化块,也没有构造函数。
    5. 匿名内部类如果需要访问外部类局部变量,则只能是final局部变量(java8开始可以不用final修饰,但必须是final使用格式),这是为了保证数据的一致性,外部类局部变量会成为匿名内部类的成员变量。

    按上面的限制,我们看demo。

    先定义一个输出对象的接口:

    public interface IOut {
    
        void println(String msg);
    
    }

    再定义一个抽象类:

    public abstract class BaseOut implements IOut {
        private final int bufferSize;
    
        public BaseOut() {
            bufferSize = 1024;
        }
    
        public BaseOut(int bufferSize) {
            this.bufferSize = bufferSize;
        }
    
        @Override
        public abstract void println(String msg);
    
    }

    开始演示:

    public class Run {
    
        public static void main(String[] args) {
            // 1.定义的时候直接实例化
            // 2.实现了接口
            final IOut out0 = new IOut() {
                // static String name;  // 4.不能有静态成员
                // static void print() {}   // 4.不能有静态方法
                // static {}    // 4.不能有静态初始化块
                // abstract void print();   // 3.不能有抽象方法
                @Override
                public void println(String msg) {
                    System.out.println(msg);
                }
            };
            // 2.继承了父类,无参构造函数
            BaseOut out1 = new BaseOut() {
                @Override
                public void println(String msg) {
                    out0.println(msg);  // 5.使用了外部类局部变量,final修饰
                }
            };
            // 2.继承了父类,有参构造函数
            BaseOut out2 = new BaseOut(2048) {
                @Override
                public void println(String msg) {
                    out1.println(msg);  // 5.使用了外部类局部变量,java8可以不用final修饰
                }
            };
        }
    
    }

    lambda(匿名方法)

    在演示lambda之前,先修改下IOut接口,添加默认方法和静态方法:

    @FunctionalInterface
    public interface IOut {
    
        void println(String msg);
    
        /**
         * 默认方法,由实现类调用
         */
        default void print(String msg) {
            System.out.print(msg);
        }
    
        /**
         * 静态方法
         */
        static void printf(String fmt, Object... args) {
            System.out.printf(fmt, args);
        }
    
    }

    最重要的,加了一个注解:@FunctionalInterface,表明这个接口是函数式接口:有且只有一个抽象方法的接口。这个注解是给编译器严格检查使用的,同时也代表:可以添加这个注解的接口,在创建对应的匿名内部类时,可以使用lambda:

    public class Run {
    
        public static void main(String[] args) {
            // 函数式接口,内部类实现只有一个函数,这个时候使用lambda
            IOut out0 = (msg) -> {
                System.out.println(msg);
            };
            // 参数列表只有一个参数,去掉括号
            IOut out1 = msg -> {
                System.out.println(msg);
            };
            // 方法体只有一条语句,去掉花括号和分号
            IOut out2 = msg -> System.out.println(msg);
            // 很巧的,方法体实现只是引用了其它对象的方法,使用方法引用
            IOut out3 = System.out::println;
        }
    
    }

    从上面的简单示例可以看出:如果一个接口是函数式接口,并且创建这个函数式接口的匿名内部类时,也只是实现了抽象方法,不添加任何其它方法,保证实现的方法唯一时,就可以使用lambda(匿名函数)。因为确定实现的就是那个函数,所以函数名可以省去,只要申明形参名(为了给方法体使用),形参类型都可以省去,然后使用符号->连接方法体。

    lambda的简化写法:

    1. 形参列表如果有且只有一个参数,可以省去括号。
    2. 方法体如果只有一条语句,可以省去花括号和分号。如果有返回值,连return都可以省去。
    3. 方法体如果只有一条语句,又正好满足一定的条件,可以使用更精简的方法引用和构造器引用(本篇不讨论这个)。

    lambda能实现的,匿名内部类都能实现,匿名内部类能实现的,lambda有时就无能为力了,主要有以下区别:

    1. 匿名内部类可以为任意接口或类创建匿名内部类,但lambda目标类型只能是函数式接口,只能是接口,就算是只有一个抽象方法的抽象类也不行。
    2. 匿名内部类可以有成员变量,初始化块,多个普通方法,实现或重写多个方法,但lambda只能有一个方法体。
    3. 匿名内部类可以调用父类或接口继承得到的默认方法,lambda不行。

    上面说的第3点,具体看demo:

    public class Run {
    
        public static void main(String[] args) {
            // 匿名内部类
            IOut out0 = new IOut() {
                @Override
                public void println(String msg) {
                    println(msg);    // 实例方法
                    IOut.printf(msg); // 静态方法
                }
            };
            // lambda
            IOut out1 = msg -> {
                // 无法调用继承得到的默认方法
                IOut.printf(msg);
            };
        }
    
    }

     

    展开全文
  • Java匿名内部类实现线程的创建

    千次阅读 2019-05-06 14:47:12
    Java匿名内部类实现线程的创建

    Java匿名内部类实现线程的创建

    package com.zr;
    /*
        匿名内部类实现线程的创建
     */
    public class DemoThread {
        public static void main(String[] args) {
            //主线程main
            for (int i = 0; i <20 ; i++) {
                //Thread.currentThread().getName()获取线程名
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
    
            //匿名内部类创建新线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i <20 ; i++) {
                        System.out.println(Thread.currentThread().getName()+"-->"+i);
                    }
                }
            }).start();
        }
    }
    
    
    展开全文
  • 主要介绍了java匿名内部类实例代码详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 转载自: ... /** * @author hgl * @data 2019年1月10日 * @description 接口 */ public interface TestInterface { ... public void innerMethod();... System.out.println("匿名内部类调用了外部类方法"); } }
  • 主要介绍了Java 匿名内部类详解及实例代码的相关资料,需要的朋友可以参考下
  • 匿名内部类适合创建那种只需一次使用的类,匿名内部类的语法有点奇怪,创建匿名内部类时会立即创建一个该类的实例,这个类的定义立即消失,匿名内部类不能重复使用。 下面用实现接口的方式来介绍匿名内部类: //...
  • 掌握java四中匿名内部类
  • java匿名内部类的使用方法

    千次阅读 2018-07-24 09:51:25
     * 匿名内部类的使用方法:当需要对父类的方法进行复写时所用的,特点是内部类的方法尽可能少,一般就是只有一个  * 弊端:如果想多次调用的话就得重复的写匿名内部类。  * 格式:new 父类(){方法体}.方法名字 ...
  • 匿名类是不能有名称的,所以没办法引用它们,必须在创建时,作为new语句的一部分来声明它们,需要了解更多的可以参考本
  • 为什么说Java匿名内部类是残缺的闭包

    千次阅读 多人点赞 2017-09-14 22:18:36
    这时候就得考虑一下Java虚拟机的运行时数据区域了,dog变量是位于方法内部的,因此dog是在虚拟机栈上,也就意味着这个变量无法进行共享,匿名内部类也就无法直接访问,因此只能通过值传递的方式,传递到匿名内部类中...
  • java匿名内部类详解

    千次阅读 2018-02-06 20:56:44
    匿名内部类,顾名思义,就是没有名字的类,匿名内部类格式如下: new name(parameter) { ...... } name:父类或是接口的名字。 parameter:若name为父类,则parameter为父类构造函数的参数。 匿名...
  • 匿名内部类前提:局部内部类必须继承或实现一个外部类或接口。 格式: new 父类名 or 接口名 (){ 子类内容 }; public class NiMinNeiBuLei { public static void main(String[] args) { new Outer().method()...
  • 匿名内部类形式 DataStream<UserBehavior> pvData = timeData .filter( new FilterFunction<UserBehavior>() { @Override public boolean filter(UserBehavior userBehavior) throws Exception ...
  • 继承 public abstract class AbstructClass { abstract void pri(); } public class TestClass2 { public AbstructClass te(){ return new AbstructClass(){ void pri() { System....
  • 今日在看到Enumeration 借口的源码时发现,Enumeration 接口的asIterator 方法返回了一个迭代器,并使用匿名内部类(实现接口的匿名内部类)。对迭代器中的方法进行了实现 default Iterator&lt;E&gt; ...
  • java匿名内部类序列化问题

    千次阅读 2018-01-04 20:40:52
    遇到一个序列化问题。...匿名内部类的对象会伴随主对象的整个生命周期,并且匿名类必然不会继承序列化接口支持序列化,所以在执行序列化时会发生无法序列化外部类的情况,因为匿名类对象也是一个需要序列化的成员。
  • Java 匿名类(匿名内部类)

    千次阅读 多人点赞 2020-12-25 23:41:48
    Java匿名类(匿名内部类) 学习的参考博文:无恨之都 1. 初识 匿名类 标准说法: 内部类包括:成员类、局部类、匿名类(匿名内部类)。 匿名类概念: 匿名类可以使你的代码更加简洁 (JDK8之后Lambda更简洁)。 你可以...
  • java匿名内部类(通过接口实现)

    千次阅读 2018-08-22 02:47:59
    java匿名内部类通过接口的方式进行实现   package 匿名内部类接口实现; public interface PowerSupply { //开通电源 void Open(); //关闭电源 void Close(); } package 匿名内部类接口实现; public ...
  •  对于这个问题,首先我们应该明确的一点是对于匿名内部类,它可能引用三种外部变量:外部类的成员变量外部方法或作用域内的局部变量外部方法的参数而第一种变量是不需要声明为final的,但后两种是需要声明为final的...
  • Java匿名内部类与回调函数

    千次阅读 2018-07-02 14:55:28
    阅读原文摘要: 之所以将匿名内部类和回调函数两个知识点一起写,是因为最近学习zookeeper的时候正好遇到这么一个例子。详细内容请参考:https://www.w3cschool.cn/zookeeper/zookeeper_api.html 以下是与ZooKeeper...
  • 关于java匿名内部类初始化法

    千次阅读 2018-12-02 13:55:26
    最近无意间发现一种对象的初始化方法:匿名内部类初始化法 List&lt;String&gt; list = new ArrayList&lt;String&gt;(){{ add("爱飘de小子"); add("flyingkid"); }}; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 146,852
精华内容 58,740
关键字:

java匿名内部类

java 订阅