精华内容
下载资源
问答
  • 匿名类特点

    2012-08-23 16:53:07
    简单的讲述匿名类特点,帮助大家区分和使用
  • java 匿名类

    2018-07-03 13:13:21
    匿名类和子类有关的匿名类 假如没有显式地声明一个类的子类,而又想用子类创建一个对象,那么该如何实现这一目的呢?Java允许我们直接使用一个类的子类的类体创建一个子类对象,也就是说,创建子类对象时,除了使用...

    匿名类

    和子类有关的匿名类

        假如没有显式地声明一个类的子类,而又想用子类创建一个对象,那么该如何实现这一目的呢?Java允许我们直接使用一个类的子类的类体创建一个子类对象,也就是说,创建子类对象时,除了使用父类的构造方法体外还有类体,此类体被认为是一个子类去掉类声明后的类名,称作匿名类。匿名类就是一个子类,由于无名可用,所以不可能用匿名类声明对象,却可以直接用匿名类创建个对象。

    假设Bank是类,那么下列代码就是用Bank的一个子类(匿名类) 创建对象。

    new Bank(){
          匿名类的类体
    };

     匿名类有如下特点。

        (1)匿名类可以继承父类的方法也可以重写父类的方法。

        (2)使用匿名类时,必然是在某个类中直接用匿名类创建对象,因此匿名类定是内部类。

      (3)匿名类可以访问外嵌类中的成员变量和方法,匿名类的类体中不可以声明static成员变量和static方法。

      (4)由于匿名类是一个子类,但没有类名,所以在用匿名类创建对象时,要直接使用父类的构造方法。

         尽管匿名类创建的对象没有经过类声明步骤,但匿名对象的引用可以传递给个匹配的参数。

      比如,用户程序中有如下方法:

    void f(A a){
    }

    该方法的参数类型是A类,用户希望向方法传递A的子类对象,但系统没有提供符合要求的子类,那么用户在编写代码时就可以考虑使用匿名类。

      下面的例子中,抽象类OuputAlphabet有output()方法,而且该类有一个OutputEnglish子类,这个子类重写的output()方法可以输出英文字母表。

    例子中的ShowBoard类的showMess(OutputAlphabet show)方法的参数是OutputAlphabet类型的对象,用户在编写程序时,希望使用ShowBoard类的对象调用showMess(OutputAlphabet show)输出英文字母表和希腊字母表,但系统没有提供输出希腊字母表的子类(只提供了输出英文字母表的子类),因此用户在主类的main方法中,向showMess方法的参数传递了一个匿名类的对象,该匿名类的对象负责输出希腊字母表。运行效果如图所示。

    abstract class OutputAlphabet {
    	public abstract void output();
    }
    class OutputEnglish extends OutputAlphabet{    //输出英文字母的子类
    	public void output() {
    		for(char c='a';c<='z';c++) {
    			System.out.printf("%3c",c);
    		}
    	}
    }
    class ShowBoard{
    	void showMess(OutputAlphabet show) {        //参数show是OutputAlphabet类型的对象
    		show.output();
    	}
    }
     public class Example5.2{
    	 public static void main(String args[]) {
    		 ShowBoard board=new ShowBoard();
    		 board.showMess(new OutputEnglish());  //向参数传递OutputAlphabet的子类OutputEnglish的对象
    		 System.out.println();
    		 board.showMess(new OutputAlphabet() {  //向参数传递OutputAlphabet的匿名子类的对象
    				 public void output() {
    					 for(char c='α';c<='ω';c++)   //输出希腊字母
    						 System.out.printf("%3c",c);
    				 }
    		 }
    		 );	    //请注意分号在这里
    	 }
     }

    展开全文
  • 匿名内部类特点及注意

    千次阅读 2017-10-09 12:17:52
    匿名内部特点及注意: 匿名内部也就是没有名字的内部,无class关键字,直接使用new来生成一个对象的引用正因为没有名字,所以匿名内部只能使用一次 匿名内部还有个前提条件:必须继承一个父类(抽象,...

    匿名内部类的特点及注意:

    1. 匿名内部类也就是没有名字的内部类,无class关键字,直接使用new来生成一个对象的引用正因为没有名字,所以匿名内部类只能使用一次
    2. 匿名内部类还有个前提条件:必须继承一个父类(抽象类,普通类)或实现一个接口(两者不可兼得,并且只能是一个),它相当于一个具体类(只是没有名字),所以可以使用new
    3. 不能存在任何的静态成员变量和静态方法。
    4. 不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法。 无构造函数,使用构造(空白)代码块进行初始化
    5. 当所在的方法的形参需要被内部类里面使用时,该形参必须为final,为了拷贝引用避免引用值发生改变

    稍微说下new时的情况:

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

    所以我个人觉得new不是对抽象类(普通类)或接口直接new的,而是对继承他的子类new的。它的名字是外部类名字$1,如Test$1

    为什么我们使用匿名内部类:

    1. 实现伪多重继承
    2. 方便定义回调
    3. 对于其他类来说能够隐藏起来

    PS.

    内部类的介绍
    加深理解匿名内部类
    形参为什么是final详解

    展开全文
  • 匿名类

    2016-05-27 20:25:35
    package pers.songhongkang.chaper3.day6; //匿名类对象:创建类的对象是匿名的。...//2)特点:创建的匿名类的对象只能调用一次 public class CircleAreaTest { public static void main(String[] args){ Pa
    package pers.songhongkang.chaper3.day6;
    //匿名类对象:创建类的对象是匿名的。
    //1)当我们需要一次调用类的对象时,我们就可以考虑使用匿名的方式创建类的对象。
    //2)特点:创建的匿名类的对象只能调用一次
    
    public class CircleAreaTest {
    	public static void main(String[] args){
    		PassObject cu=new PassObject();
    //		Circle c=new Circle();//c即是创建类的名字,不是匿名类
    		cu.printAreas(new Circle(),5);//匿名类new Circle()
    		System.out.println();
    		
    	}
    }
    
    class Circle{
    	double radius;
    	double findArea(double radius){
    		return(3.14*radius*radius);
    		
    	}
    
    }
    class PassObject{
    	double area=0;
    	public void printAreas(Circle c,int time){
    		System.out.println("radius"+"\t"+"area"+"\n");
    		/*for(int i=1;i<=time;i++){
    			area=c.findArea(i);
    			System.out.println(i+"\t"+area+"\n");
    		}*/
    		int i=1;
    		while(i<=time){
    			area=c.findArea(i);
    			System.out.println(i+"\t"+area+"\n");
    			i++;	
    		}
    	System.out.print("now radius is:"+i);
    }
    	
    }

    展开全文
  • 前端时间在写.net项目中,一直错将.cs里的两个class当作内部类,原来是一个文件里的两个类而已,这让我想起了Java中的内部类,比较内部类,那么还有两个类,那就是匿名类和匿名内部类。今天我想就Java中的这三种类...

    前端时间在写.net项目中,一直错将.cs里的两个class当作内部类,原来是一个文件里的两个类而已,这让我想起了Java中的内部类,比较内部类,那么还有两个类,那就是匿名类和匿名内部类。今天我想就Java中的这三种类进行个比较。

    我们知道在Java语言规范中可以做很多事,例如一个类或一个接口中可以声明一个类或接口,在一个方法中可以声明一个类,类与接口声明可以嵌套任意深度等。

     

    匿名类:

          1、new <类或接口><类的主体>,匿名类的声明是在编译时进行的,实例化是在运行时进行的,所以在for循环中一个new语句会创建相同匿名类的几个实例,而不是创建几个不同匿名类的一个实例。

          2、如果要执行的对象需要一个对象,但却不值得创建全新的对象(可能是因为该对象只在一个方法内部使用),在这个时候使用匿名类就会非常合适,所以说,匿名类一般会在swing程序中快速创建事件处理程序。

    Java代码  收藏代码
    1. firstButton.addActionListener(new ActionListener() {  
    2.         @Override  
    3.         public void actionPerformed(ActionEvent e) {  
    4.             getTxtValue().setText("第一个按钮触发的事件!");  
    5.         }  
    6.     });   

           3、从技术上说,匿名类可以被看作非静态的内部类,所以他们具有方法内部声明的非静态内部类相同的权限和限制。

     

     

    内部类:

    内部类顾名思义就是在一个类的内部还有一个类

    Java代码  收藏代码
    1. package com.iflytek.innerclass;  
    2.   
    3. /** 
    4.  * @author xudongwang 2012-1-11 
    5.  *  
    6.  *         Email:xdwangiflytek@gmail.com 
    7.  */  
    8. public class InnerClassDemo {  
    9.     public static void main(String[] args) {  
    10.         new Outer().fun();  
    11.     }  
    12. }  
    13.   
    14. class Outer {  
    15.   
    16.     private String name = "Hello 内部类";  
    17.   
    18.     class Inner {  
    19.         public void print() {  
    20.             System.out.println("name = " + name);  
    21.   
    22.         }  
    23.     };  
    24.   
    25.     public void fun() {  
    26.         new Inner().print();  
    27.     }  
    28. }  

     

     内部类生成的.class文件名为:Outer$Inner.class,从上面的结构发现内部类的的缺点是“结构非常的混乱”。

    Java代码  收藏代码
    1. package com.iflytek.innerclass;  
    2.   
    3. /** 
    4.  * @author xudongwang 2012-1-11 
    5.  *  
    6.  *         Email:xdwangiflytek@gmail.com 
    7.  */  
    8. public class InnerClassDemo02 {  
    9.     public static void main(String[] args) {  
    10.         new Outer02().fun();  
    11.     }  
    12. }  
    13.   
    14. class Outer02 {  
    15.   
    16.     private String name = "Hello 内部类";  
    17.   
    18.     public void fun() {  
    19.         new Inner02(this).print();  
    20.     }  
    21.   
    22.     public String getName() {  
    23.   
    24.         return this.name;  
    25.     }  
    26. };  
    27.   
    28. class Inner02 {  
    29.     private Outer02 out;  
    30.   
    31.     public Inner02(Outer02 out) {  
    32.         this.out = out;  
    33.     }  
    34.   
    35.     public void print() {  
    36.         System.out.println("name = " + this.out.getName());  
    37.   
    38.     }  
    39. };  

     从上可以看出内部类的优点是“可以方便的访问外部类中的私有成员”;

    如果要在外部直接使用内部类的实例化对象:

          外部类.内部类 内部类对象 = 外部类实例.new 内部类实例();

    Java代码  收藏代码
    1. package com.iflytek.innerclass;  
    2.   
    3. /** 
    4.  * @author xudongwang  2012-1-11 
    5.  * 
    6.  *  Email:xdwangiflytek@gmail.com 
    7.  */  
    8. public class InnerClassDemo03 {  
    9.     public static void main(String[] args) {  
    10.         Outer03 out = new Outer03();//外部类实例  
    11.         Outer03.Inner inner = out.new Inner();//实例化内部类对象  
    12.         inner.print();  
    13.     }  
    14. }  
    15. class Outer03{  
    16.     private String name = "Hello 内部类";  
    17.     class Inner {  
    18.         public void print() {  
    19.             System.out.println("name = " + name);  
    20.         }  
    21.     }  
    22. }  

     

     一个内部类如果使用static关键字声明的话,则此内部类就将成为外部类,可以直接通过外部类.内部类的形式访问

    Java代码  收藏代码
    1. package com.iflytek.innerclass;  
    2.   
    3. /** 
    4.  * @author xudongwang 2012-1-11 
    5.  *  
    6.  *         Email:xdwangiflytek@gmail.com 
    7.  */  
    8. public class InnerClassDemo04 {  
    9.     public static void main(String[] args) {  
    10.         Outer04.Inner inner = new Outer04.Inner();// 实例化内部类对象  
    11.         inner.print();  
    12.     }  
    13. }  
    14.   
    15. class Outer04 {  
    16.     private static String name = "Hello 内部类";  
    17.   
    18.     static class Inner {  
    19.         public void print() {  
    20.             System.out.println("name = " + name);  
    21.         }  
    22.     }  
    23. }  

     

     内部类可以在任意的地方使用,例如方法中声明

    Java代码  收藏代码
    1. package com.iflytek.innerclass;  
    2.   
    3. /** 
    4.  * @author xudongwang 2012-1-11 
    5.  *  
    6.  *         Email:xdwangiflytek@gmail.com 
    7.  */  
    8. public class InnerClassDemo05 {  
    9.     public static void main(String[] args) {  
    10.         new Outer05().fun();  
    11.     }  
    12. }  
    13.   
    14. class Outer05 {  
    15.     private static String name = "Hello 内部类";  
    16.   
    17.     public void fun() {  
    18.         class Inner {  
    19.             public void print() {  
    20.                 System.out.println("name = " + name);  
    21.             }  
    22.         }  
    23.         new Inner().print();  
    24.     }  
    25. }  

     

     在方法中定义的内部类,可以直接访问外部类中的各个成员,但是如果要访问方法中的参数,则需要在参数上加上final关键字声明;

    Java代码  收藏代码
    1. package com.iflytek.innerclass;  
    2.   
    3. /** 
    4.  * @author xudongwang 2012-1-11 
    5.  *  
    6.  *         Email:xdwangiflytek@gmail.com 
    7.  */  
    8. public class InnerClassDemo06 {  
    9.     public static void main(String[] args) {  
    10.         new Outer06().fun(20);  
    11.     }  
    12. }  
    13.   
    14. class Outer06 {  
    15.     private static String name = "Hello 内部类";  
    16.   
    17.     public void fun(final int temp) {  
    18.         class Inner {  
    19.             public void print() {  
    20.                 System.out.println("temp = " + temp);  
    21.                 System.out.println("name = " + name);  
    22.             }  
    23.         }  
    24.         new Inner().print();  
    25.     }  
    26. }  

     匿名类与内部的联系与区别:

    按所在位置可以分为两大类:

          1、在类的方法中

                         特点:

                                  a、可以访问宿主类的所有元素 ;

                                  b、保存宿主类对象的引用,创建对象时必须有宿主类对象;

                                  c、 不能有静态数据;

    继续划分:

                                 A、本地内部类;

                                 B、匿名内部类

     两者的区别在于本地内部类有构造方法,而匿名内部类只能实例初始化;

          2、在类或接口作用域中;

                         继续划分:

                                A、普通内部类

                                B、静态内部类

     

     

    匿名内部类:

    匿名内部类是在抽象类和接口的基础之上发展起来的。

    Java代码  收藏代码
    1. package com.iflytek.innerclass;  
    2.   
    3. /** 
    4.  * @author xudongwang 2012-1-11 
    5.  *  
    6.  *         Email:xdwangiflytek@gmail.com 
    7.  */  
    8. public class NoNameClass01 {  
    9.     public static void main(String[] args) {  
    10.         new X().fun2();  
    11.     }  
    12. }  
    13.   
    14. interface A {  
    15.     public void fun();  
    16. }  
    17.   
    18. class B implements A {  
    19.     public void fun() {  
    20.   
    21.         System.out.println("Hello 准备匿名内部类");  
    22.     }  
    23. }  
    24.   
    25. class X {  
    26.     public void fun1(A a) {  
    27.         a.fun();  
    28.     }  
    29.   
    30.     public void fun2() {  
    31.         this.fun1(new B());  
    32.     }  
    33. }  

     通过上面的Demo,如果现在假设B类只使用一次,那么还有必要将其定义成一个单独的类么?

     呵呵,此时就可以使用匿名内部类:

    Java代码  收藏代码
    1. package com.iflytek.innerclass;  
    2.   
    3. /** 
    4.  * @author xudongwang 2012-1-11 
    5.  *  
    6.  *         Email:xdwangiflytek@gmail.com 
    7.  */  
    8. public class NoNameClass02 {  
    9.   
    10.     public static void main(String[] args) {  
    11.         new XX().fun2();  
    12.     }  
    13. }  
    14.   
    15. interface AA {  
    16.     public void fun();  
    17. }  
    18.   
    19. class XX {  
    20.     public void fun1(AA a) {  
    21.         a.fun();  
    22.     }  
    23.     public void fun2() {  
    24.         this.fun1(new AA() {  
    25.             public void fun() {  
    26.                 System.out.println("Hello 准备匿名内部类");  
    27.             }  
    28.         });  
    29.     }  
    30. }  

     其实在真正的项目开发中匿名内部类使用的非常之少,一般在Java的图形界面和现在的Android中使用的比较多点。

     

     最后给一个内部类实现的简单链表:

    Java代码  收藏代码
    1. package com.iflytek.innerclass;  
    2.   
    3. /** 
    4.  * @author xudongwang 2012-1-11 
    5.  *  
    6.  *         Email:xdwangiflytek@gmail.com 
    7.  */  
    8. public class LinkDemo {  
    9.     public static void main(String args[]) {  
    10.         Link link = new Link();  
    11.         link.add("A");  
    12.         link.add("B");  
    13.         link.add("C");  
    14.         link.add("D");  
    15.         link.add("E");  
    16.         link.print();  
    17.     }  
    18. };  
    19.   
    20. class Link {  
    21.     class Node {  
    22.         private String name;  
    23.         private Node next; // 单向链表,每个节点指向下一个节点  
    24.   
    25.         public Node(String name) {  
    26.             this.name = name; // 通过构造方法为name属性赋值  
    27.         }  
    28.   
    29.         public void addNode(Node newNode) { // 增加节点  
    30.             if (this.next == null) {  
    31.                 this.next = newNode; // 保存节点  
    32.             } else {  
    33.                 this.next.addNode(newNode); // 继续向下查找  
    34.             }  
    35.         }  
    36.   
    37.         public void printNode() { // 输出节点  
    38.             System.out.println(this.name);  
    39.             if (this.next != null) { // 此节点之后还存在其他的节点  
    40.                 this.next.printNode();  
    41.             }  
    42.         }  
    43.     };  
    44.   
    45.     private Node root; // 链表的头  
    46.   
    47.     public void add(String name) { // 增加节点  
    48.         Node newNode = new Node(name); // 定义一个新的节点  
    49.         /* 
    50.          * 如果是第一个节点,则肯定是根节点, 如果是第二个节点,则肯定放在根节点next中 如果是第三个节点,则肯定放在第二个节点的next中 
    51.          */  
    52.         if (this.root == null) {  
    53.             this.root = newNode; // 将第一个节点设置成根节点  
    54.         } else {  
    55.             // 肯定要放在最后一个节点之后  
    56.             // 通过节点.next来不断的判断  
    57.             this.root.addNode(newNode);  
    58.         }  
    59.     }  
    60.   
    61.     public void print() {  
    62.         if (this.root != null) { // 如果根节点为空了,则没有任何内容  
    63.             this.root.printNode();  
    64.         }  
    65.     }  
    66. };  





    展开全文
  • 7.2 匿名类

    2017-11-30 17:33:23
    匿名类特点: (1)可以继承父类方法,也可以重写父类方法 (2)使用匿名类的时候,必然是在某个类中直接使用匿名类创建对象,因此匿名类一定是内部类 (3)匿名类可以访问外嵌类中的成员变量和方法,匿名类类体不...
  • 匿名类是一个木类名的快捷内部类,适合创建仅需要使用一次的类 匿名类不可以重复使用 创建匿名类前提:需要继承父类和重写方法或者实现接口和重写方法 创建的匿名类没有构造方法和静态成员 ...
  • 1.18 Java匿名类,匿名内部类

    千次阅读 2020-09-30 13:12:36
    匿名类是指没有类名的内部类,必须在创建时使用 new 语句来...匿名类有两种实现方式: 继承一个类,重写其方法。 实现一个接口(可以是多个),实现其方法。 下面通过代码来说明。 public class Out { void show() {
  • 匿名类是指没有类名的内部类,必须在创建时使用 new 语句来声明类。其语法形式如下: new<类或接口>...匿名类有两种实现方式: 继承一个类,重写其方法。 实现一个接口(可以是多个),实现其...
  • 匿名类对象

    2019-09-03 15:48:12
    匿名类对象:创建类的对象是匿名的。 1)当我们只需要一次调用类的对象的时候,我们可以考虑使用匿名的方式创建类的对象。 2)特点:创建的匿名类的对象只能够调用一次。 ...
  • 匿名内部特点

    2021-02-20 16:49:23
    匿名内部就是没有名字的内部 特点: 必须继承一个抽象或者实现一个接口 匿名内部不能定义任何静态成员和静态方法 当所在的方法的形参需要被匿名内部使用时,必须声明为final (jdk8之前要手动加上final,...
  • Java 匿名类

    2019-04-10 11:22:00
    匿名类是指没有类名的内部类,必须在创建时使用 new 语句来声明类 其语法形式如下: new<类/抽象类/接口>() ...这种形式的 new 语句...匿名类有两种实现方式: 继承一个类,重写其方法。 实现一个接口...
  • 匿名内部

    千次阅读 2016-07-21 16:01:42
    匿名内部
  • JAVA 匿名类

    2018-06-01 17:55:18
    匿名类和子类有关的匿名类 假如没有显式地声明一个类的子类,而又想用子类创建一个对象,那么该如何实现这一目的呢?Java允许我们直接使用一个类的子类的类体创建一个子类对象,也就是说,创建子类对象时,除了使用...
  • Javascript匿名类

    2014-12-17 14:21:42
    1.关于匿名类  var class1={p1:value1,p2:value2};  这个也可以写成  var class1={};  class1.p1=value1;  class1.p2=value2; 首先所有的匿名类都是继承与Object核心对象的,var class1={}...
  • 内部-成员内部、局部内部匿名内部匿名内部实际应用
  • 内部类和匿名类

    2016-11-27 17:24:02
    内部特点是它可以访问外部的成员变量和方法的局部变量,不可以被外部的其他访问。 匿名内部,是特殊的内部,它是继承了其他,实现了接口或者实现抽象的内部。可以访问外部成员变量,和final...
  • C#中的匿名类

    2017-05-11 00:19:55
    匿名类, 就是无需声明类型, 即可实例化的类, 实例化中不写类名。 举例: var anAnonymousObject = new { Name = "Tom", Age = 65 }; 特点: 1. 只能包含公共变量 2.声明匿名类时必须初始化变量 3.无法使用...
  • java匿名类与匿名对象

    2018-06-13 15:58:48
    一、匿名对象 匿名对象是没有名字的实体,也就是该实体没有对应的变量名引用 匿名对象的特征: 创建的匿名类的对象只能够调用一次 匿名对象只在堆内存中开辟空间,而不存在栈内存的引用 每次创建匿名对象都是...
  • Java——匿名类

    2021-07-22 18:13:22
    匿名类有两种实现方式: 继承一个类,重写其方法。 实现一个接口(可以是多个),实现其方法。 public class Out { void show() { System.out.println("调用 Out 类的 show() 方法"); } } public class ...
  • 匿名类最大的特点就是匿名了。。(感觉是废话) 既然是匿名类,所以你无法在别的地方使用这个类(实例化,调用它的静态方法之类的)特点的话,除了只能使用一次,其实还有其他用处(在看spring-boot源码时发现的)当...
  • java嵌套类和内部类、匿名类

    千次阅读 2016-03-10 16:08:13
    java嵌套类和内部类、匿名类 1、嵌套类和内部类定义 可以在一个类的内部定义另一个类,这种类称为嵌套类(nested classes),它两种类型:静态嵌套类和非静态嵌套类。静态嵌套类使用很少,最重要的是非静态嵌套类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,147
精华内容 33,658
关键字:

匿名类的特点有哪些