精华内容
下载资源
问答
  • 展开全部匿名类是一种特殊的内部类,它是在一个表达式内部包含一个完整的32313133353236313431303231363533e58685e5aeb931333337616531类定义。内部类是在一个类的内部嵌套定义的类,它可以是其它类的成员,也可以在...

    展开全部

    匿名类是一种特殊的内部类,它是在一个表达式内部包含一个完整的32313133353236313431303231363533e58685e5aeb931333337616531类定义。

    内部类是在一个类的内部嵌套定义的类,它可以是其它类的成员,也可以在一个语句块的内部定义,还可以在表达式内部匿名定义。

    匿名类与其他类的不同就在于匿名,也就是没有名称。

    Java中允许创建子类对象时,除了使用父类的构造方法外,还可以用类体。 匿名类就是一个没有类申明的类体,因为没有名称,所有匿名类不可以申明对象,但却可以创建对象。   例如:

    A是一个子类,那么下面的代码就是A的一个子类(匿名类)创建对象。

    new A(){

    匿名类的类体

    };

    由于匿名类是一个子类,所以和有一般子类的特征。可以继承父类的方法,同样也可以重写父类的方法。值得提醒的是,在使用匿名类时,一定是在某个类中直接用匿名类创建对象,因此匿名类必定是内部类,所以和其他匿名类一样可以访问外嵌类中的成员变量和方法,匿名类的类体中不可以什么。

    static成员变量和static方法。

    尽管匿名类没有申明的步骤,但可以在创建匿名对象时返回一个引用赋值给匹配参数。   匿名类的常用方式是向方法的参数传值。

    具体方法如下:abstract class Speak{

    public abstract void speakHello();

    }

    class Student{

    void f(Speak sp){

    sp.speakHello();

    }

    }

    public class AnonymousClassDemo {

    public static void main(String[] args) {

    Speak speak = new Speak(){

    public void speakHello(){

    System.out.println("大家好,祝工作愉快!");

    }

    };

    speak.speakHello();

    Student st = new Student();

    st.f(new Speak(){

    public void speakHello(){

    System.out.println("I am a student, how are you");

    }

    });

    }

    }

    上面代码的抽象类改成接口同样适用。

    展开全文
  • 匿名内部,顾名思义,就是不知道这个到底是什么名字,也就是不知道类名。 匿名内部的使用场景? 匿名内部适合创建那种只需要使用一次的,也就是说创建一个匿名内部,只需要用一次即可。 匿名内部...

    什么是匿名内部类?

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

    匿名内部类的使用场景?

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

    匿名内部类如何创建?

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

    匿名内部类的实现和使用

    例1(实现接口)

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

    public interface Product{
     double getPrice();
     double 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 Device{
    	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基础之匿名内部类,匿名内部类是什么?为什么要用匿名内部类,匿名内部类详解。 什么是匿名内部类? 顾名思义 匿名 就是没有名字,一个没有名字的内部类,称为匿名内部类。 下面先看一个例子,比如说你想和你的女...

    Java基础之匿名内部类,匿名内部类是什么?为什么要用匿名内部类,匿名内部类详解。

    什么是匿名内部类?

    顾名思义 匿名 就是没有名字,一个没有名字的内部类,称为匿名内部类。
    下面先看一个例子,比如说你想和你的女朋友去看春节档的《唐人街探案三》

    这个时候我们要先定义一个接口,去看唐探3的接口

    public interface MyInterface {
        // 看电影的抽象方法
        void watchFilm();
    }
    

    OK!现在我们有了一个接口,接口里面有一个看电影的抽象方法。而现在你要去看电影了,你要实现接口里面的方法,但是接口不能直接 new 出来,所以你就要先定义一个实现类去实现这个接口,代码如下:

    public class MyInterfaceImpl implements MyInterface{
    
        public void watchFilm() {
            System.out.println("实现方法里带着女朋友去看电影!");
        }
    }
    

    现在我们实现了这个接口,也可以去看电影了,我们现在要写一个主方法;

    public class GoWatchFilm {
        public static void main(String[] args) {
            MyInterfaceImpl myInterface = new MyInterfaceImpl();
            myInterface.watchFilm();
        }
    }
    

    而这个时候,我们要先 new 一个看电影的实现类,然后调用里面看电影的方法,如图:
    在这里插入图片描述
    现在你和你心爱的女朋友成功的看到了电影…
    因为我们已经知道多态,我们还可以使用多态的方式," = " 的左边时接口,右边是实现类也是没毛病的,
    在这里插入图片描述
    到这里!那么问题来了,这个电影你就看了一次,只有在 new 的时候才看了一次,没有再看第二次。所以这个时候我们就可以使用 匿名内部类 了。

    如果接口的实现类(或者父类的子类)只需要使用唯一一次,那么这种情况下我们就可以省略掉对该类的定义,而改为使用匿名内部类。

    匿名内部类的定义格式:
    上面我们有说到接口不能直接 new ,如果直接new就会报错,而这次,我们就直接new接口,但是这里的new和new对象又有一点小差别,格式如下:

    接口名称 对象名 = new 接口名称(){
    	 // 覆盖重写所有抽象方法
    }
    

    那我们就代码实现一下:
    在这里插入图片描述
    如上图,我们new了一个接口,而接口下面的 { } 里面就是一个匿名内部类,所以现在我们使用匿名内部类就可以带着女朋友把电影看玩了,而之前我们定义的一个实现类就可以不用了,虽然说这样写法有点怪异,但是我们是想带着女朋友看电影,并且这个电影只需要看一次就行了,往后就不看了,却还要写一个实现类去实现它,使用匿名内部类就可以省掉一个类的单独定义,看到这想必小伙伴已经对匿名内部类了解的差不多了,不过匿名内部类也有一些注意事项,我们接着往下看。

    匿名内部类的注意事项:

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

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

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

    3. {…} 这才是匿名内部类的内容; PS:没有class,没有名称

    另外还要注意以下几点问题:
    如果现在你的女朋友还想要看完电影去吃个海底捞,那么我们现在在接口里再写一个方法。并且第二天的时候你美丽的女朋友还要重复昨天做的事情,看电影,吃火锅,开始撸代码:

    public interface MyInterface {
        // 看电影的抽象方法
        void watchFilm();
        // 吃海底捞的抽象方法
        void eatHotPot();
    }
    
    public class GoWatchFilm {
        public static void main(String[] args) {
           /* MyInterface myInterface = new MyInterfaceImpl();
            myInterface.watchFilm();*/
            MyInterface day01 = new MyInterface() {
                @Override
                public void watchFilm() {
                    System.out.println("第一天在匿名内部类里面实现了带女朋友看电影了!!!!!!");
                }
                @Override
                public void eatHotPot() {
                    System.out.println("第一天看完电影我们去吃一个火锅吧!!!!");
                }
            };
            day01.watchFilm();
            day01.eatHotPot();
            // 来一条分割线
            System.out.println("-------------------------------------------------------------------------------------------");
            new MyInterface() {
                @Override
                public void watchFilm() {
                    System.out.println("第二天在匿名内部类里面实现了带女朋友看电影了!!!!!!");
                }
                @Override
                public void eatHotPot() {
                    System.out.println("第二天看完电影我们去吃一个火锅吧!!!!");
                }
            }.watchFilm();
            new MyInterface() {
                @Override
                public void watchFilm() {
                    System.out.println("第二天在匿名内部类里面实现了带女朋友看电影了!!!!!!");
                }
                @Override
                public void eatHotPot() {
                    System.out.println("第二天看完电影我们去吃一个火锅吧!!!!");
                }
            }.eatHotPot();
    
        }
    }
    

    输出内容:

    第一天在匿名内部类里面实现了带女朋友看电影了!!!!!!
    第一天看完电影我们去吃一个火锅吧!!!!
    -------------------------------------------------------------------------------------------
    第二天在匿名内部类里面实现了带女朋友看电影了!!!!!!
    第二天看完电影我们去吃一个火锅吧!!!!
    

    可以看到,当我们第一天的时候,看完电影再吃火锅时是用的匿名内部类,是有对象名称的,可以直接用对象名称调用吃火锅和看电影的方法,而当第二天想再次调用的时候如果我们是用到了匿名对象,是直接new接口没有对象名称就要new两次,然后分别调用看电影和吃火锅,并且每次都要重写接口里的所有方法。

    1、匿名内部类,在创建对象的时候只能使用一次,如果希望多次创建对象,而且内容一样的话,那么此时我们就要使用单独定义的实现类了。
    2、匿名对象,在调用方法的时候,只能调用唯一一次,如果希望同一个对象调用多次方法,就必须给对象起一个名字。
    3、匿名内部类是省略了“实现类/子类名称”,但是匿名对象是省略了“对象名称

    到这里小伙伴们差不多已经知道匿名内部类的含义了吧,并且我们什么时候能用到匿名内部类,什么时候要定义一个实现类去实现接口里的方法了吧!!!!

    展开全文
  • 目录 匿名类型 匿名类型说明 匿名类示例 ...匿名类型是没有名称的类,这一种方便的方法,可用...也就是,匿名类实际上就是没有类型名称,其他地方与类是一样使用的。 匿名类示例 先看一个普通的类,具有三个...

    目录

     

    匿名类型

    匿名类型说明

    匿名类示例

    匿名方法

    匿名方法说明

    匿名方法示例


    匿名类型

     

    匿名类型说明

    匿名类型是没有名称的类,这一种方便的方法,可用将一组只读属性封装到单个对象中,而无需首先显式定义一个类型,类型名由编译器生成,并且不能在源代码级使用

    也就是,匿名类实际上就是没有类型名称,其他地方与类是一样使用的。

     

    匿名类示例

    先看一个普通的类,具有三个变量和一个实例化函数,打印输出预先定义好的值

    class student
        {
            public int Sub;
            int Age;
            int Cls;
            public student()
            {
                Console.WriteLine("Student A:{0}{1}{2}",Sub,Age,Cls);
            }
        }

    在主函数中实例化

    static void Main(string[] args)
            {
                student st = new student();
                
            }

    运行得到的结果:

    那么如果用一个类似的匿名类来写,就是这样

     

     static void Main(string[] args)
            {
                student st = new student();
                var annoystudent = new
                {
                    aSub = "DatAnalyse",
                    aAge = 12,
                    aCls = "Middle 4"
                };
                Console.WriteLine("Data: {0}{1}{2}", annoystudent.aAge, annoystudent.aSub, annoystudent.aCls); 
            }

    为方便比较将两个写到一个程序中,全部代码如下

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    
    namespace DelegateTest
    {
        internal delegate void NumberChanger(int n);
        class student
        {
            public string Sub = "DatAnalyse";
            private int Age = 12;
            private int Cls = 4;
            public student()
            {
                Console.WriteLine("Stand Student A:{0},{1},{2}",Sub,Age,Cls);
                Console.ReadKey();
            }
        }
       
        class Program
        {
            static void Main(string[] args)
            {
                student st = new student();
                var annoystudent = new
                {
                    aSub = "DatAnalyse",
                    aAge = 12,
                    aCls = "Middle 4"
                };
                Console.WriteLine("Annoy Student Data: {0},{1},{2}", annoystudent.aAge, annoystudent.aSub, annoystudent.aCls);
                Console.ReadKey();
            }
        }
       
    }
    

    编译运行,可以看到最终的结果与非匿名类是一样的

    匿名类不能赋值,它的所有数值都是只读的

     

     

    匿名方法

     

    匿名方法说明

    创建匿名方法实际上是一种将代码块作为委托参数传递的方式,使用这一种方法如果建立新的线程可以减少内存的消耗,匿名方法不声明返回值类型,但是匿名方法的返回值类型必须和委托返回值一样。

     

    匿名方法示例

    先定义一个普通的函数

     static void TheMulti(int b)
            {
                var num = b * b;
                System.Console.WriteLine("{0}x{1} = {2}", b, b, b * b);
    
            }

    之后定义一个delegate匿名函数的声明,其中参数类型与普通函数的是一致的,这一句我定义到了类的外面,因此增加一个internal声明

     internal delegate void AutoCounter(int n);

                                                                                                                                                                                                              主函数是这样的:

                

    AutoCounter ac ; //实例化匿名方法AutoCounter
                ac = TheMulti; //赋予函数名称
                ac(12); //调用
                System.Console.ReadKey();

    程序的运行结果与通常调用函数是一致的

                          

     

    另外直接声明匿名方法块也是可以的,

    ac = delegate (int c)//声明
                {
                    var num = c + c;
                    System.Console.WriteLine("{0}+{1} = {2}", c, c, (c + c));
                };
                ac(33);//调用

      最终的函数如下:

       

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    
    namespace DelegateTest
    {
        internal delegate void AutoCounter(int n);
       
        class Program
        {
            static void Main(string[] args)
            {
                AutoCounter ac ;
                ac = TheMulti;
                ac(12);
                ac = delegate (int c)
                {
                    var num = c + c;
                    System.Console.WriteLine("{0}+{1} = {2}", c, c, (c + c));
                };
                ac(33);
                System.Console.ReadKey();
            }
            static void TheMulti(int b)
            {
                var num = b * b;
                System.Console.WriteLine("{0}x{1} = {2}", b, b, (b * b));
    
            }
        } 
       
    }
    

       运行结果

             

    展开全文
  • 匿名类指的就是没有类名的内部类,它必须在创建的时候使用new语句来声明类,今天要给大家介绍的就是和匿名类相关的内容,一起来进行一下详细的了解吧。语法形式:(这样的形式的new语句声明一个新的匿名类,它对一...
  • 1.什么是匿名内部匿名内部,即没有名字的内部,因为此类只需要使用一次,所以没有起名字的必要 创建匿名内部时,必须作为new语句的一部分来声明, 用法: 接口名/ 对象名 = new 接口名/(){ // 匿名...
  • 什么要使用匿名内部 在实际开发中,我们常常遇到这样的情况:一个接口/的方法的某个实现方式在程序中只会执行一次,但为了使用它,我们需要创建它的实现/子类去实现/重写。此时可以使用匿名内部的方式,...
  • 是什么匿名内部

    2021-03-05 16:00:53
    匿名内部原理
  • 什么是匿名内部

    千次阅读 2019-06-20 22:00:33
    匿名内部内部的简化写法。它的本质一个 带具体实现的 父类或者父接口的 匿名的 子类对象。 如果接口的实现(或者父类的子类)只需要使用唯一的一次, 那么这种情况下就可以省略掉该的定义,而改为...
  • 什么是Java匿名内部

    2017-11-20 14:58:41
    Q:上面的一段代码中,Thread类是匿名内部类吗? A:是匿名内部类(其实还不准确)。Thread本身并不是抽象类或接口,但此处重写了run方法,只有子类可以重写父类方法,所以new出的并不是Thread类,而是Thread类的...
  • Inter i = new Inter(){ @Override public void method(){ } }
  • 一:内部1:什么是内部?大部分时候,被定义成一个独立的程序单元。在某些情况下,也会把一个放在另一个的内部定义,这个定义在其他内部的就被称为内部(有些地方也叫做嵌套),包含内部也被...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,347
精华内容 1,338
关键字:

匿名类是什么