精华内容
下载资源
问答
  • 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
    

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

    展开全文
  • /* * 使用接口创建匿名内部类的使用一般只是使用了一次的类*/ interface Product{ int getPrice();... * 使用抽象类创建匿名内部类*/ abstract class ProductTwo{ private String name; privat...
    package yuwei.com;
    
    /*
     * 使用接口创建匿名内部类的使用一般只是使用了一次的类*/
    interface Product{
        int getPrice();
        String getName();
    }
    /*
     * 使用抽象类创建匿名内部类*/
    abstract class ProductTwo{
        private String name;
        private int Price;
        public abstract int getPrice();
        public  String getName()
        {
            return this.name;
        }
        public ProductTwo() {}
        public ProductTwo(String name) {
            this.name = name;
        }
    }
    class AnonymousClass{
        public void test(Product p) {
            System.out.println("Price:"+p.getPrice() + "\tName:" + p.getName());
        }
        public void test1(ProductTwo p) {
            System.out.println("Price:"+p.getPrice() + "\tName:" + p.getName());
        }
    }
    public class AnonymousClassDemo {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            AnonymousClass A = new AnonymousClass();
            A.test(new Product()
                    {
                        public int getPrice() {
                            return 10;
                        }
                        public String getName() {
                            return "AAAAAA";
                        }
                    });
    
            System.out.println("********************");
            //创建无参数构造器的匿名类
            A.test1(new ProductTwo()
                    {
                        public int getPrice() {
                            return 23;
                        }
                        //重写父类的getName()
                        public String getName() {
                            return "AD钙";
                        }
                    });
            System.out.println("********************");
            //创建无参数构造器的匿名类
            A.test1(new ProductTwo("蒙牛")
            {
                public int getPrice() {
                    return 98;
                }       
            });
    
        }
    
    }
    
    展开全文
  • 由于接口和抽象类不能创建类对象,若一个接口的实现类需要使用一次,或者一个抽象类的子类需要使用一次,那么就可以使用匿名内部类;匿名内部类 只能创建一个对象。 类的本体就是大括号里面的所有内容。。 匿名内部...

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

    匿名内部类:

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

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

    例如:

    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));
        }
    }
    
    展开全文
  • 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.成员内部类

    public class F {
    
        private int a;
        public void fun(){
            //TODO
        }
    
        public class M{
            private int a;
            public void fun(){
                //TODO
            }
        }
    
    }

    2.局部内部类

    public class F {
    
        private int a;
        public void fun(){
            //TODO
            class M{
                private int a;
                public void fun(){
                    //TODO
                }
            }
    
            M m = new M();
            m.fun();
        }
    
    }

    值得注意的是:

    1 . 无论是成员内部类还是局部内部类,内部类中定义的方法名和变量名可以和外部类相同。这是因为 当程序正确编译后,会生成两个class文件,即:F.class和F$M.class,且这两个class文件是两个不同的文件,故可以重名

    2 . 上述内部类实例的存在必须依赖于父类的实例,
    即:在外接使用内部类时,必须先new 一个F的实例,然后在调用F.new M()生成M的实例对象

    3 . 若内部类是static修饰过的,即静态内部类,这直接new一个静态内部类对象即可,注意要导入正确的包,它位于父类下。
    4. 静态内部类参数必须用final修饰的原因:

    静态内部类不依赖父类的实例的存在而存在

    我们知道静态方法、静态成员变量随着类的加载而产生,不依赖与任何对象的存在
    静态内部类解除了与外部类的关联,不持有外部类的引用

    Java 对象的初始化顺序:

    1. 静态对象-非静态对象-构造器
      其中静态对象包括:静态块,静态方法,静态属性
    2. 对于继承父类的对象的初始化顺序:父类静态对象-子类静态对象-父类构造方法-子类构造方法
      说明:在静态对象中初始话顺序实际上是按照声明的顺序执行的。

    3.匿名内部类
    在Android开发中常用到如:

    button.setOnClickListener(new Button.OnClickListener() { 
        @Override 
        public void onClick(View v) {
               // TODO
        } 
    }); 

    其中的new Button.onclickListener(){}即为匿名内部类的实例对象类

    匿名内部类要求
    1. 匿名内部类没有名字,因此只能使用一次,下次再使用重新创建对象。
    2. 匿名内部类的适用情形:某个类不是经常使用,如只使用一次,使用完后不保存该实例的对象,为了便于代码的编写常采用匿名内部类
    3. 使用匿名内部类的前提条件:必须继承一个父类或实现一个接口

    其他说明:

    无论是匿名内部类、接口或者抽象类,都不能实例化
    但我们常用到的new 一个匿名内部类、接口或者抽象类实际上是执行3步的合并,即:
    a.先定义一个子类,让该子类继承上述接口或实现上述抽象类;
    b.然后new一个该子类的对象;
    c.将该子类的一个引用赋值给接口或者抽象类变量(它是依据java多态特性:父类指向子类的引用)。

    上述说明事例代码:
    1. new 一个接口

    Runnable runnable = new Runnable() {
    
                @Override
                public void run() {
    
                }
            };
    1. 实际上的执行步骤为:
    a.
     class MyRunnable implements Runnable{
    
            @Override
            public void run() {
    
            }
    
        }
    b.  
    MyRunnable myRunnable = new MyRunnable();
    c.
    Runnable runnable = myRunnable;
    展开全文
  •  只有内部类可以拥有4种访问修饰符  当内部类为private的时候,有外部类提供方法来访问内部类   常规内部类  1.不能有静态属性和方法  2.内部类可以使用外部类的所有属性和方法  3.外部类不能直接使用...
  • 抽象方法,抽象类 (一)抽象方法: 定义:只声明而未实现的方法,即没有方法体的方法。 抽象方法使用 abstract 修饰,具有抽象方法的类也用 abstract 修饰。 即 具有抽象方法的类一定是抽象类,但抽象类中不一定有...
  • 1. 匿名内部类总是默认实现某个接口或继承某个抽象类。 2.不能有构造方法,只能有一个实例。 3. 不能定义在任何静态成员、静态方法。 4. 不能是public.protected.private static. 5. 匿名内部类为局部的,所以...
  • java中的匿名内部类总结 匿名内部类也就是没有名字的内部 ...正因为没有名字,所以匿名内部类只能...实例1:不使用匿名内部类来实现抽象方法 1 2 3 4 5 6 7 8 9 10
  • 大家面试的时候肯定被问过java 接口、抽象类、具体类、内部类、匿名内部类的区别及它们之间的关系。那么下面我就来整理下它们之间的关系。
  • Java内部匿名内部类的用法

    万次阅读 多人点赞 2016-07-21 15:46:41
    Java内部类和匿名内部类的用法 【尊重原创,转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51981163一、内部类: (1)内部类的同名方法 内部类可以调用外部类的方法,如果内部类有同名方法...
  • 匿名内部类是不是就是在在参数列表中可以new 接口或者抽象类? 匿名内部类是不是就是在在参数列表中可以new 接口或者抽象类? 匿名内部类是不是就是在在参数列表中可以new 接口或者抽象类?
  • 抽象类、接口和内部类 ★ abstract 修饰符  -- 修饰类和方法  ★ 抽象类:使用abstract修饰的类就是抽象类 总结为:有得有失  -- 得:增加了一个功能,可以包含抽象方法  -- 失:不能创建实例 ...
  • 抽象类是不能被实例化的,抽象必须被继承,也就是只能实例化抽象类的子类。 但是Java中有一段有趣的功能。 比如: ...可以在Main方法中实例化这个抽象类。 MyAbstractclass my=new MyAbstractclas...
  • 匿名内部类

    2015-11-22 17:57:42
     匿名内部类出现的前提:必须存在一个类,抽象类,或者接口,来让匿名内部类继承或实现。  匿名内部类的格式: new 类名或者接口名() { 重写类或者接口中的方法。 也可以自己定义新的方法。 }; 2、...
  • Scala进阶_抽象类匿名内部

    千次阅读 2020-02-16 11:51:41
    和Java语言一样,scala中也可以定义抽象类 定义 如果类的某个成员在当前类中的定义是不包含完整的,它就是一个抽象类 不完整定义有两种情况: 方法没有方法体(抽象方法) 变量没有初始化(抽象字段) 定义抽象类...
  • * 抽象父类 * @author x * */ abstract class Device { private String name; //抽象方法 public abstract double getPrice(); public Device(){} public Device(String name) { this
  • 一、内部类(Inner Classare the classes defined inside another class.) 在类内部的类 1.解决多继承 ...只有内部类可以拥有4种访问修饰符(package(默认)、public、private、protected) 当内部
  • 抽象类也是不断地向上抽取而来的。但是只抽取了方法声明,并不抽取具体的方法实现。...抽象类中,可以定义抽象内容让子类实现,也可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。
  • 匿名内部类抽象实现枚举

    千次阅读 2013-08-25 13:17:05
    /* 星期天: Sun.=Sunday 星期一: Mon.=Monday 星期二: Tues.=Tuesday 星期三: Wed.=Wednesday 星期四: Thur.=Thursday 星期五: Fri.=Friday 星期六: Sat.=Saturday ... // 构造函数私有化 不可以
  • 定义匿名内部类的前提:内部类必须是继承一个抽象类或者实现接口。只要一个类是抽象的或是一个接口,那么其子类中的方 法都可以使用匿名内部类来实现  3.匿名内部类的格式: new 父类或者接口(){定义子类的内容} ...
  • 什么是Java匿名内部类

    2017-11-20 14:58:41
    Thread本身并不是抽象类或接口,但此处重写了run方法,只有子类可以重写父类方法,所以new出的并不是Thread类,而是Thread类的匿名子类,即匿名内部类。如果不重写run方法,那么new出的就是Thread类本身,就不存在...
  • java内部:  格式:   类名一般都是由protected和private修饰符修饰.内部很好的体现了java的封装特性.可以使用封装来解决java只能单继承的问题 . 匿名内部类: ...java的匿名内部类的语法规则看

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,370
精华内容 29,748
关键字:

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