精华内容
下载资源
问答
  • 匿名内部实现和使用例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
    

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

    展开全文
  • 简单接口回调demo。
  • 匿名内部接口实现

    千次阅读 多人点赞 2018-08-19 08:32:56
    匿名内部类接口实现 1.匿名内部类 :是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类...如果接口的实现类(或者是父类的子类)只需要使用唯一的一次, 那么这种情况下就可以省略...

    匿名内部类接口实现

    1.匿名内部类 :是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。

    开发中,最常用到的内部类就是匿名内部类了。以接口举例,使用一个接口时,得做如下4步操作,

    1. 定义子类

    2. 重写接口中的方法

    3. 创建子类对象

    4. 调用重写后的方法

    如果接口的实现类(或者是父类的子类)只需要使用唯一的一次,

    那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】。

     

    匿名内部类的定义格式:

    接口名称 对象名 = new 接口名称() {

        // 覆盖重写所有抽象方法

    };

     

    对格式“new 接口名称() {...}”进行解析:

    1. new代表创建对象的动作

    2. 接口名称就是匿名内部类需要实现哪个接口

    3. {...}这才是匿名内部类的内容

    举例代码:

    1. 接口FlyAble

    public interface FlyAble {
        public abstract void Fly();
        public abstract void eat();
    }

     

    2. FiyAbleImpl类实现抽象方法

    package DemoTest.FlyAble;

    public class FlyAbleImpl implements FlyAble {
        @Override
        public void Fly() {
            System.out.println("实现类的间接调用!");
            System.out.println("心牵挂远方!");
        }

        @Override
        public void eat() {
            System.out.println("吃饭!");
        }
    }

     

    3.InnerDome测试类
    public class InnerDome {
        public static void main(String[] args) {
            FlyAble fly = new FlyAble() {
                @Override
                public void Fly() {
                    System.out.println("用匿名对象直接调用接口!");
                    System.out.println("心已经飞过千里!");
                }

                @Override
                public void eat() {
                    System.out.println("用匿名对象直接调用接口!");
                    System.out.println("吃好吃的!");
                }
            };
            fly.Fly();
            fly.eat();
            System.out.println("=================");
            FlyAbleImpl flyAble = new FlyAbleImpl();
            flyAble.Fly();
            flyAble.eat();
        }
    }

    4.结果:                      

    用匿名对象直接调用接口!

    心已经飞过千里!

    用匿名对象直接调用接口!

    吃好吃的!

    =================

    实现类的间接调用!

    心牵挂远方!

    吃饭!

    3、注意事项:

    1. 匿名内部类,在【创建对象】的时候,只能使用唯一一次。

    如果希望多次创建对象,而且类的内容一样的话,那么就需要使用单独定义的实现类了。

    2. 匿名对象,在【调用方法】的时候,只能调用唯一一次。

    如果希望同一个对象,调用多次方法,那么必须给对象起个名字。

    3. 匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】

    展开全文
  • 匿名内部

    千次阅读 2019-10-22 20:28:46
    匿名内部需要通过父类或者接口实现。 语法: 父类名/接口名 对象名 = new 父类名/接口名 { 重写的父类的方法 或 实现的接口中的方法 }; 示例1: 父类: public class A { public void fun(){ ...

    匿名内部类

    匿名内部类:没有名称的类,主要用来创建对象(只创建一次)
    匿名内部类需要通过父类或者接口实现。
    语法:

    父类名/接口名 对象名 = new 父类名/接口名 {
       重写的父类的方法
       或
       实现的接口中的方法
    };
    

    示例1:普通父类

    • 父类:
    public class A {
        public void fun(){
            System.out.println("A fun");
        }
    }
    
    • 测试代码:
    public static void main(String[] args) {
        class B1 extends  A{
    
        }
        B1 obj1 = new B1();
        obj1.fun();
    
        class B2 extends  A{
            @Override
            public void fun() {//重写父类的方法
                System.out.println("B2 fun");
            }
        }
        B2 obj2 = new B2();
        obj2.fun();
    
        
    
        A obj11 = new A(){
    
        };
        obj11.fun();
    
        A obj22 = new A(){
            @Override
            public void fun() {
                System.out.println("22 fun");
            }
        };
        obj22.fun();
    
        new A(){
            @Override
            public void fun() {
                System.out.println("33 fun");
            }
        }.fun();
    }
    

    示例:抽象父类

    • 抽象父类:
    public abstract class CC {
    	public void fun() {
    		System.out.println("fun");
    	}
    	public abstract void fun2();
    }
    
    • 测试代码:
    public static void main(String[] args) {
    	CC obj = new CC() {
    
    		public void fun2() {
    			System.out.println("xixi");
    		}
    
    	};
    	obj.fun2();
    	
    	new CC() {
    
    		public void fun2() {
    			System.out.println("xixi");
    		}
    
    	}.fun2();
    }
    

    示例:接口

    • 接口:
    public interface A {
         void fun();
    }
    
    • 测试代码:
    public static void main(String[] args) {
    
        class B2 implements A {
            @Override
            public void fun() {//重写父类的方法
                System.out.println("B2 fun");
            }
        }
        B2 obj2 = new B2();
        obj2.fun();
    
        
    
        A obj22 = new A() {
            @Override
            public void fun() {
                System.out.println("22 fun");
            }
        };
        obj22.fun();
    
        new A() {
            @Override
            public void fun() {
                System.out.println("33 fun");
            }
        }.fun();
    }
    
    展开全文
  • JAVA可以使用如下方法来创建基于接口的匿名实现类对象 new<接口名>(){ //重写方法 }; package hello2; /** * 创建匿名的接口实现类对象:临时创建了一个没有命名的接口实现类 * 代码简约化 * */ ...

    JAVA可以使用如下方法来创建基于接口的匿名实现类对象

    new<接口名>(){
    //重写方法
    };
    
    
    package hello2;
    
    /**
     * 创建匿名的接口实现类对象:临时创建了一个没有命名的接口实现类
     * 代码简约化
     *
     */
    interface ISay{
    	void sayHello();
    }
    class ISayImpl implements ISay{
    	@Override
    	public void sayHello() {
    		System.out.println("Hello java! 2 ");
    	}
    }
    public class Hello{
    	
    	public static void main(String []args) {
    		//匿名类创建
    		ISay isay = new ISay() {
    			public void sayHello() {
    				System.out.println("Hello java!");
    			}
    		};
    		//匿名类使用
    		isay.sayHello();
    		
    		//非匿名类
    		ISayImpl isay2 = new ISayImpl();
    		isay2.sayHello();
    		
    	}
    }
    
    
    
    展开全文
  • Java中匿名类的两种实现方式

    千次阅读 2018-06-07 06:10:18
    使用匿名内部课使代码更加简洁、紧凑,模块化程度更高。内部能够访问外部内的一切成员变量和方法,包括私有的,而实现接口或继承做不到。实例化一个接口并实现其方法。即在定义的同时,新建这个的实例。...
  • Java 匿名类(匿名内部)

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

    万次阅读 多人点赞 2019-10-10 22:22:30
    为了加深各位对匿名内部的印象、好奇心以及求知的渴望,咋们先来看一个程序,如果提到线程你会不会立马想到接口和继承?如果提到接口和继承你会不会立马想到匿名内部? 开篇甜点 为了加深各位对匿名内部的...
  • 直接new一个接口,但是接口再被实现后,再new这个接口,并写上实现这个接口的方法,那么new的这个接口如果没有赋值引用,那么new的这个接口就是一个匿名类,这么理解对不
  • Java多线程-39-匿名内部类实现多线程

    千次阅读 2018-08-28 23:26:22
    有时候,我们会使用匿名内部实现多线程,因为这样做代码更加简单。下面,就用匿名类分别实现Thread继承和实现Runnable接口的两个多线程方式。 package thread; public class Demo3_Thread { public static ...
  • Java匿名内部类实现线程的创建

    千次阅读 2019-05-06 14:47:12
    Java匿名内部类实现线程的创建
  • 实现接口的方法:类实现:重写接口所有方法 抽象子类:抽象子类继承接口 有朋友问:你的匿名对象实现接口怎么实现的... 还记的上面那个临时创建的实现类吗,他全部重写了接口方法,只是方法体是空的。我虽然只重写了部
  • 可以。而且必须实现接口或继承其他
  • 一个匿名内部类一定是继承一个类或者实现一个接口,new了这个父类或接口名的内部类还带内容,我就想问能不能还能不能继承其他类或实现其他接口。 如果我表达不好,不好理解, 那...匿名内部类能不能实现多个接口??
  • package com.yy.thread; public class Demo4_Thread { public static void main(String[] args) { demo1(); //匿名内部,第一种,继承Thread demo2(); //匿名内部,第二种,实现Runnable接口 } ...
  • 上代码 接口: interface OnBind { ... onBindChildViewData(holder: String, itemData: Any, position: Int) ...抽象时,先实现抽象中的抽象方法,用构造方法构造出一个对象后,再给到 object
  • Java的内部匿名类 , 您了解过吗?

    千次阅读 多人点赞 2020-07-23 08:35:30
    内部 内部是指在一个外部的内部再定义一个,内部作为...内部允许吧一些逻辑相关的组织在一起,并且控制内部代码的可视性,将包含此内部称为外部匿名类 匿名类,也就是之前所...
  • 在java提高篇—–详解内部中对匿名内部做了一个简单的介绍,但是...  在这里我们看到使用匿名内部我们必须要继承一个父类或者实现一个接口,当然也仅只继承一个父类或者实现一个接口。同时它也是没有class关
  • 这次我们说下通过匿名内部类实现按钮点击事件,其实大家可以发现匿内部主要的作用就是创建一个实现OnClickListener接口,那么我们就可以在setOnClickListener方法中直接new出来一个接口,当然这样肯定是可以 ...
  • 抽象 接口 匿名类的区别

    千次阅读 2015-07-29 15:28:11
    1 抽象  当编写一个时,常常会为该定义一些方法...但在某些情况下,某个父类并不需要实现,因为它只需要当做一个模板,而具体的实现,可以由它的子类来实现。比如说一个长方体的表面积和一个立方体的表面积
  • Java内部匿名内部的用法

    万次阅读 多人点赞 2016-07-21 15:46:41
    Java内部匿名内部的用法 【尊重原创,转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51981163一、内部: (1)内部的同名方法 内部可以调用外部的方法,如果内部有同名方法...
  • 实现Comparator的匿名内部

    千次阅读 2020-05-14 09:07:15
    有时我们只需要一次用到自定义比较规则的compare方法,此时又想利用Comparator实现,所以可以直接使用匿名内部完成相关操作。 用一道例题梳理匿名内部的使用方法 前K个高频单词 给一非空的单词列表,返回前 k 个...
  • 匿名内部类实现接口

    千次阅读 2016-05-19 23:02:59
    最近在研究回调,发现回调与接口联系十分密切,且通常使用匿名内部的写法,现在记录一下,有了更深的体会,随时更新。一个接口A:public interface InterfaceA { public void sayA(); } 另一个接口B:public ...
  • 可以实现某接口,但不用implements。匿名内部,就是没有名字的内部。故没有构造器,必须调用基类的构造器。所以是继承基类的。匿名内部经常被用来覆盖基类的某些方法:class A{ public void a(){ System....
  • public class TestClass { private InterfaceA a = new InterfaceA() { @Override public void testA() { ...//成员匿名类,例如在Android开发中常用的Handler。 public static void main(St...
  • 匿名内部类实现接口,继承

    千次阅读 2016-06-28 22:54:46
    先定义一个接口: interface Contents {  int value(); } 再定义一个(构造函数不是默认的): public class Wrapping {  private int i;  public Wrapping(int x) { i = x;...先实现接口:
  • Lambda表达式与匿名内部

    千次阅读 2019-04-24 19:27:55
    匿名内部适合创建那种只需要一次使用的匿名内部的语法有点奇怪,创建匿名内部时会立即创建一个该的实例,这个定义立刻消失,匿名内部重复使用(一次性的) 定义匿名内部的格式如下: new...
  • Thread 构造方法: public Thread():分配一个新的线程对象。 public Thread(String name):分配一个指定名字的新的线程对象。 public Thread(Runnable target):分配一个带有指定目标新的线程对象。 public Thread...
  • 实现的接口: public interface Inner { ...“实现”接口的外部: class Outer{ public static Inner method(){ return new Inner() { @Override public void show() { System.out

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 252,139
精华内容 100,855
关键字:

匿名类能实现类吗