精华内容
下载资源
问答
  • 匿名内部类可以声明为private
    万次阅读 多人点赞
    2019-11-12 11:37:18

    什么是匿名内部类?

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

    匿名内部类的使用场景?

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

    匿名内部类如何创建?

    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匿名内部类详解

    千次阅读 2015-09-14 11:41:56
    声明】此文转载自:http://blog.csdn.net/zhandoushi1982/article/details/8778487 ——感谢分享,尊重作者,交流无限! ...记得JAVA中抽象是不能创建实例的,... 匿名类是不能有名称的,所以没办法引用它

    【声明】此文转载自:http://blog.csdn.net/zhandoushi1982/article/details/8778487

    ——感谢分享,尊重作者,交流无限!


    记得JAVA中抽象类是不能创建实例的,但是在代码中总会看见new 抽象类名的用法。如果不太清楚这个原因,需要了解匿名抽象类这个概念。

            匿名类是不能有名称的类,所以没办法引用它们。必须在创建时,作为new语句的一部分来声明它们。Java中内部匿名类用的最多的地方也许就是在Frame中加入Listener了吧。如下:

    [java]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. import java.awt.*;     
    2. import java.awt.event.*;     
    3.     
    4. public class QFrame extends Frame {     
    5.     public QFrame() {     
    6.            this.setTitle(\"my application\");     
    7.     
    8.            addWindowListener(new WindowAdapter() {     
    9.                    public void windowClosing(WindowEvent e) {     
    10.                    dispose();     
    11.                    System.exit(0);     
    12.                 }     
    13.             });       
    14.     
    15.           this.setBounds(10,10,200,200);     
    16.      }     
    17. }  

    上面的new语句,建立一个 WindowAdapter对象 ,后面一个 {} 表示这个括号中的操作作用于这个默认的对象。打开 WindowAdapter 的代码可以发现,它是一个抽象类。它是对 WindowListener 接口的一个实现。

    (1)怎样判断一个匿名类的存在?

     先看段伪代码
    abstract class Father(){
          ....
    }
    public class Test{
          Father f1 = new Father(){ .... }; //这里就是有个匿名内部类
    }

            一般来说,new 一个对象时小括号后应该是分号,也就是new出对象该语句就结束了。但是出现匿名内部类就不一样,小括号后跟的是大括号,大括号中是该new 出对象的具体的实现方法。因为我们知道,一个抽象类是不能直接new 的,必须先有实现类了我们才能new出它的实现类。上面的伪代码就是表示new 的是Father的实现类,这个实现类是个匿名内部类。其实拆分上面的匿名内部类可为:
    class SonOne extends Father{
           ...//这里的代码和上面匿名内部类,大括号中的代码是一样的
    }
    public class Test{
           Father f1 = new SonOne() ;
    }

    (2)匿名内部类的注意事项

         A,匿名内部类不能有构造方法。

         B,匿名内部类不能定义任何静态成员、方法和类。

         C,匿名内部类不能是public,protected,private,static。 

         D,只能创建匿名内部类的一个实例。

         E,一个匿名内部类一定是在new的后面,用其隐含实现一个接口或实现一个类。  
         F,因匿名内部类为局部内部类,所以局部内部类的所有限制都对其生效。

         G,匿名类和内部类中的中的this:有时候,我们会用到一些内部类和匿名类。当在匿名类中用this时,这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话,则应该加上外部类的类名。

    (3)匿名内部类实例,在安卓中,典型的也是各种Listener,比如按键的监听

    [java]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. Button button_stop = (Button) findViewById(R.id.button2);  
    2.         button_stop.setOnClickListener(new Button.OnClickListener(){  
    3.             public void onClick(View v){  
    4.                             stopService(new Intent("org.allin.android.facedetcting2"));      
    5.                 }  
    6.             });  
    展开全文
  • 主要简单给我们介绍了java中匿名内部类构造函数,并附上了简单的示例,有需要的小伙伴可以参考下。
  • 主要介绍了Java内部匿名内部类的用法说明,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • java中匿名内部类详解

    2020-08-30 19:47:50
    主要对java中的匿名内部类的详细总结,需要的朋友可以参考下
  • 匿名内部类可以访问所有的外部的成员,包括私有的; * 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!

    展开全文
  • 本篇文章介绍了,java中匿名内部类解读分析。需要的朋友参考下
  • Java 匿名(匿名内部类)

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

    Java 匿名类(匿名内部类)

    学习的参考博文:无恨之都

    1. 初识 匿名类

    标准说法: 内部类包括:成员类、局部类、匿名类(匿名内部类)。

    匿名类概念:

    • 匿名类可以使你的代码更加简洁 (JDK8之后Lambda更简洁)。
    • 你可以定义一个类的同时对其进行实例化
    • 它与局部类很相似,不同的是它没有类名,如果某个局部类你只需要使用一次,就可以使用匿名类代替局部类
    • 匿名类是表达式,而非常规的类

    匿名类的使用场景:

    • 一个局部类只需要使用一次的时候
    • 由于匿名类没有类名,那么除了定义它的地方,其他地方无法调用,所以匿名类也可以叫匿名内部类

    2. 通过示例分析局部类和匿名类区别

    sayHello方法中有局部类和匿名类分别实现HelloWorld接口的方法

    public class HelloWorldAnonymousClasses {
    
        interface HelloWorld {
            public void greet();
            public void greetSomeone(String someone);
        }
    
        public void sayHello() {
    
            /**
             * 1、局部类:EnglishGreeting实现了HelloWorld接口
             */
            class EnglishGreeting implements HelloWorld {
                String name = "无参";
                @Override
                public void greet() {
                    greetSomeone(name);
                }
                @Override
                public void greetSomeone(String someone) {
                    name = someone;
                    System.out.println("局部类:" + name);
                }
            }
            // 创建局部类EnglishGreeting的实例化对象,使用接口类型接收
            HelloWorld englishGreeting = new EnglishGreeting();
            // 局部类:无参方法
            englishGreeting.greet();
            // 局部类:带参方法
            englishGreeting.greetSomeone("带参");
    
    
            /**
             * 2、匿名类实现HelloWorld接口并创建了实例化对象:frenchGreeting
             */
            HelloWorld frenchGreeting = new HelloWorld() {
                String name = "无参";
                @Override
                public void greet() {
                    greetSomeone(name);
                }
                @Override
                public void greetSomeone(String someone) {
                    name = someone;
                    System.out.println("匿名类:" + name);
                }
            };
    
            // 匿名类:无参方法
            frenchGreeting.greet();
            // 匿名类:带参方法
            frenchGreeting.greetSomeone("带参");
        }
    
        public static void main(String... args) {
            HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
            myApp.sayHello();
        }
    

    【输出】

    局部类:无参
    局部类:带参
    匿名类:无参
    匿名类:带参
    

    【分析】
      代码里局部类和匿名类实现的功能是一样的,内部的方法实现的代码是也一样的,区别只在实现HelloWorld接口的地方

    局部类的格式是:

    1. 创建局部类并且实现接口:class EnglishGreeting implements HelloWorld {...}
    2. 创建局部类的实例化对象并用接口类型接收:HelloWorld englishGreeting = new EnglishGreeting();
    3. 调用实例化对象的方法

    匿名类的格式是:

    1. 创建匿名类实现接口同时对其进行实例化:HelloWorld frenchGreeting = new HelloWorld() {...}
    2. 调用实例化对象的方法

    【区别】

    1. 局部类EnglishGreeting实现HelloWorld接口,有自己的类名:EnglishGreeting,定义完成后需要再对其实例化对象:englishGreeting才能可以使用方法
    2. 匿名类在定义时就已经实例化成对象:frenchGreeting,定义完了就可以直接使用方法
    3. 匿名类是一个表达式,因此在定义的最后用分号结束

    3. 匿名内部类的语法

    3.1 匿名类实现接口

    其实上面的示例中的匿名类就是实现接口的方式,这个示例将实现更复杂的功能

    public class InterfaceTest {
        public static void main(String[] args) {
            TomInterface tif = new TomInterface() {
                String name = "汤姆";
                @Override
                public void getName() {
                    System.out.println(name);
                }
    
                TomInterface setName(String name){
                    this.name = name;
                    return this;
                }
            }.setName("杰瑞");
            tif.getName();
        }
    }
    
    interface TomInterface{
        void getName();
    }
    

    【结果】

    杰瑞
    

    【分析】

    1. main方法创建匿名类实现TomInterface接口并实例化:new TomInterface{...}
    2. 调用匿名类对象的setName方法,将杰瑞赋值给匿名类的成员变量name,并返回当前实例this给接口变量tif
    3. main方法调用匿名类对象的方法tif.getName(),而此时的匿名类的成员变量name的值已经被替换成杰瑞,所以最后输出杰瑞而不是汤姆

    3.2 匿名类继承父类 (匿名子类)

    匿名类继承父类,调用父类构造,重写父类方法

    public class ExtendTest {
    
        public static void main(String[] args) {
            String name = "李四";
            // 创建父类对象,打印原始name值
            PartherClass partherClass = new PartherClass();
            System.out.println("父类的getName方法=" + partherClass.getName());
            // 使用匿名类继承父类,并打印name值
            PartherClass pc = new PartherClass(name){
                @Override
                public String getName(){
                    return "匿名类 - "+super.getName();
                }
            };
            System.out.println(pc.getName());
        }
    }
    
    class PartherClass{
        private String name = "张三";
        public PartherClass(){}
        public PartherClass(String name){
            this.name = name;
        }
        public String getName(){
            return this.name;
        }
    }
    

    【结果】

    父类的getName方法=张三
    匿名类 - 李四
    

    【分析】

    1. 创建父类对象并调用getName方法,这个不用细说
    2. 创建匿名类继承父类并实例化对象:pc,本次匿名类调用的是父类的带参构造,将参数赋值给了父类的name
    3. 调用匿名类重写的getName方法,得到新的name

    3.3 区别

    Demo demo = new Demo(xxx){...}
    
    1. 操作符:new
    2. 一个要实现的接口或要继承的类,示例3.1 是实现接口,示例3.2 是继承类
    3. 一对括号,如果是匿名子类,那么父类有构造参数就填,不带参就空着;如果匿名类是实现接口,那么括号里需要空着
    4. {...},括号里括着的是匿名类的声明主体
    5. 末尾的;号,因为匿名类的声明是一个表达式,是语句的一部分,所以需要分号结尾
    6. 表面上看匿名类没有类名,没有构造参数。但其实在编译的时候,编译器会给匿名类分配类名和构造器,只是我们无法操作也不能复用。如需验证,可以看编译后的class文件,多出一个命名格式:匿名类定义类$?.class的文件。例如示例3.2,匿名类的class文件就是:ExtendTest$1.class
    展开全文
  • 匿名类是不能有名称的,所以没办法引用它们,必须在创建时,作为new语句的一部分来声明它们,需要了解更多的可以参考本
  • Java内部匿名内部类的用法

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

    千次阅读 2021-03-09 06:35:27
    匿名类是指没有类名的内部类,必须在创建时使用 new 语句来声明类。其语法形式如下:new(){//的主体};这种形式的 new 语句声明一个新的匿名类,它对一个给定的进行扩展,或者实现一个给定的接口。使用匿名类可使...
  • 将一个A定义在另一个B里面,里面的那个A就称为内部,B则称为外部匿名内部类 :是内部的简化写法。它的本质是一个带具体实现的父类或者父接口的 匿名的 子类对象。
  • 关于匿名内部类的一些理解

    千次阅读 2021-09-21 15:51:21
    内部就是将一个定义在某个或者方法里面,一共分为四种:成员内部、局部内部匿名内部类、静态内部 其中局部内部就是将一个定义在了一个方法之中,类似于 class Demo{ public void test(){ class ...
  • 1. 匿名内部类 没有(或者不需要)命名来初始化,就称为匿名内部类。 在这四种内部中,以后的工作可能遇到最多的是匿名内部类,所以说匿名内部类是最常用的一种内部。 什么是匿名对象? 如果一个对象只要...
  • 内部概述内部概述内部的定义内部访问的特点匿名内部类 内部概述 首先要分清楚 在一个java文件中,可以有多个平级的。如图1,需要注意的是只有跟文件名相同名字的才可以用修饰符修饰。但是Demo1, Demo2...
  • JAVA匿名内部类笔记(适合初学者)
  • lambda表达式与匿名内部类

    万次阅读 2020-08-07 14:13:01
    Lambda表达式类似匿名函数,简单地说,它是没有声明的方法,也即没有访问修饰符、返回值声明和方法名。 Lambda允许把函数作为一个方法的参数(函数作为参数传递进方法中)。 Lambda表达式的语法 (parameters) -> ...
  • 什么说Java匿名内部类是残缺的闭包

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

    千次阅读 2019-01-04 10:49:02
    前端时间在写.net项目中,一直错将.cs里的两个class当作内部,原来是一个文件里的两个而已,这让我想起了Java中的内部,比较内部,那么还有两个,那就是匿名匿名内部类。今天我想就Java中的这三种类...
  • 下面小编就大家带来一篇全面了解Java中的内部类匿名类。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 匿名内部类

    千次阅读 2022-03-16 17:44:12
    提示:这里可以添加系列文章的所有文章的目录,目录需要自己手动添加 例如:第一章 Python 机器学习入门之pandas的使用 提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录系列文章目录...
  • 1) 从程序设计语言的理论上:局部内部类(即:定义在方法中的内部类),由于本身就是在方法内部(可出现在形式参数定义处或者方法体处),因而访问方法中的局部变量(形式参数或局部变量)是天经地义的.是很自然的2) 什么...
  • 匿名内部类,最全讲解

    千次阅读 多人点赞 2021-04-12 20:52:35
    所以我们就定义为匿名内部类,只有在需要使用的时候在初始化。 再理解: 匿名内部类,首先他一定是内部。 再说什么要是匿名内部类; 因为这个我们使用的次数少,定义一个完整的麻烦,而且用的次数少,所以...
  • 匿名内部类为什么是 Final 的呢?

    千次阅读 2017-10-30 14:08:28
    匿名内部类来自外部闭包环境的自由变量必须是final的,除非自由变量来自的成员变量。 什么是自由变量? 一个函数的“自由变量”就是既不是函数参数也不是函数内部局部变量的变量。 什么是外部环境 外部环境...
  • 深入理解Java?内部类

    2021-01-20 03:36:17
    内部主要有以下几:成员内部、局部内部、静态内部匿名内部类  内部的共性  (1)、内部仍然是一个独立的,在编译之后内部会被编译成独立的.class文件,但是前面冠以外部的类名和$符号 。 ...
  • 匿名内部类

    千次阅读 多人点赞 2018-09-22 14:12:02
    一、匿名内部类:我看到很多人有提到“匿名内部类是没有名字的”,个人觉得用陈国君主编的《Java程序设计基础(第五版)》中的 “所谓匿名内部类,是指可以利用内部创建没有名称的对象,它一步完成了声明内部和...
  • 相关android开发中内部 匿名内部类 内部接口 对比说明
  • 使用匿名内部类要注意的原则

    千次阅读 2016-08-19 14:48:25
    在使用匿名内部类时,要记住以下几个原则:  · 匿名内部类不能有构造方法。 (因为匿名内部类是没有类名的)  · 匿名内部类不能定义任何静态成员、方法和。... · 匿名内部类不能是public,protected,private,
  • 一、因为在创建匿名内部类的时候,会立即创建它的实例,可知匿名内部类不能是抽象,所以其必须继承一个抽象或者实现一个接口。 二、匿名内部类没有类名,因此没有构造方法。 三、匿名内部类访问的外部成员变量...
  • 就来说一说这个匿名内部类,用Java做例子,后面插一点c#。这个东西我之前也知道了很久,一直没有认真去看过,这次就来看看吧,今天的代码量相对很多。 匿名内部类 这里就说匿名内部类,关于其他内部老规矩,以后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,567
精华内容 25,826
关键字:

匿名内部类可以声明为private

友情链接: AT89S52ISP.rar