精华内容
下载资源
问答
  • 3.1 匿名内部类特性1. 匿名内部类总是默认实现某个接口或继承某个抽象类。2.不能有构造方法,只能有一个实例。3. 不能定义在任何静态成员、静态方法。4. 不能是public.protected.privatestatic.5. 匿名内部类为局部...

    3. 匿名内部类

    没有名字的内部类就是匿名内部类。

    3.1 匿名内部类特性

    1. 匿名内部类总是默认实现某个接口或继承某个抽象类。

    2.不能有构造方法,只能有一个实例。

    3. 不能定义在任何静态成员、静态方法。

    4. 不能是public.protected.private static.

    5. 匿名内部类为局部的,所以局部内部类的所有限制都对其有效。

    3.2  匿名内部类的使用方式

    一、继承式的匿名内部类: 就是new 抽象类。

    示例:

    package 匿名内部类抽象类练习;

    public abstract class Tv {

    //打开电视

    public abstract void open();

    //关闭电视

    public abstract void close();

    //换台

    public abstract void turn();

    }

    package 匿名内部类抽象类练习;

    public class Summer {

    public static Tv extendsTv() {

    Tv tv = new Tv() {

    @Override

    public void open() {

    System.out.println("打开三星电视...");

    }

    @Override

    public void close() {

    System.out.println("关闭三星电视...");

    }

    @Override

    public void turn() {

    System.out.println("对三星电视进行换台...");

    }

    };

    //tv.open();

    //tv.close();

    //tv.turn();

    return tv;

    }

    }

    package 匿名内部类抽象类练习;

    public class XiaoMi {

    public static Tv extendsTv() {

    //匿名内部类... 抽象类的实现 ...

    Tv tv = new Tv() {

    @Override

    public void open() {

    System.out.println("打开小米电视...");

    }

    @Override

    public void close() {

    System.out.println("关闭小米电视...");

    }

    @Override

    public void turn() {

    System.out.println("对小米电视进行换台...");

    }

    };

    //tv.open();

    //tv.close();

    //tv.turn();

    return tv;

    }

    }

    package 匿名内部类抽象类练习;

    public class Test {

    public static void main(String[] args) {

    Tv xiaomi = XiaoMi.extendsTv();

    xiaomi.open();

    xiaomi.turn();

    xiaomi.close();

    System.out.println("------------------------------");

    Tv summer = Summer.extendsTv();

    summer.open();

    summer.turn();

    summer.close();

    }

    }

    展开全文
  • 一、匿名内部类特点:  1.匿名内部类是没有名称的内部类,没办法引用它们。必须在创建时,作为new语句的一部分来声明并创建它们的实例。  2.匿名内部类必须继承一个类(抽象的、非抽象的都可以)或者实现一个...

    一、匿名内部类特点:

        1.匿名内部类是没有名称的内部类,没办法引用它们。必须在创建时,作为new语句的一部分来声明并创建它们的实例。

        2.匿名内部类必须继承一个类(抽象的、非抽象的都可以)或者实现一个接口。如果父类(或者接口)是抽象类,则匿名内部类必须实现其所有抽象方法。

        3.匿名内部类中可以定义代码块,用于实例的初始化({},对对象的属性做初始化,也可用构造方法来做,但代码块优先于构造方法先执行),但是不能定义静态代码块(会报错)。

        4.匿名内部类的语法:

             new interface/super class() {// 类体}  这种形式的new语句声明一个新的匿名类,它对一个给定的类进行扩展,或者实现一个给定的接口,并同时创建该匿名类的一个新实例。(这里new出来的是接口的实现类也就是说new出来了一个类它继承了这个接口或者是父类的子类,所以new接口/父类new出来的不是对接口实例化而是new出来的是接口的实现类对象或者是父类的子类对象) 

    public class AnonymousInnerClass {
        public static void main(String[] args) {
            Person person = new Person();
            // 这是传统的实现方法
            Animal dog = new Dog();
            person.feed(dog);
        }
    }

    abstract class Animal {
        public abstract void eat();
    }

    class Dog extends Animal {

        @Override
        public void eat() {
            System.out.println("啃骨头");
        }
        
    }

    class Person {
        public void feed(Animal animal) {
            // 同一个方法接收不同的实例对象(接收不同的动物),实现不同的功能。
            animal.eat();
        }
    }


    (1)通过匿名类来实现这个功能     

    public class AnonymousInnerClass {
        public static void main(String[] args) {
            Person person = new Person();
            //+++++======这里喂的是不同的狗=======+++++//
            person.feed(new Animal() {
                
                @Override
                public void eat() {
                    System.out.println("啃骨头");
                }
            });
            
            person.feed(new Animal() {
                
                @Override
                public void eat() {
                    System.out.println("啃骨头");
                }
            });
            //-------------------喂同一条狗可以这么做-----------------//
            Animal dog =new Animal() {
                
                @Override
                public void eat() {
                    System.out.println("啃骨头");
                }
            };
            // 将匿名内部类构造出来的对象也可以赋值给一个引用变量,所以这个dog是同一个对象。
            person.feed(dog);
            person.feed(dog);
            //-------------匿名内部类中可以有自己的属性和方法--------------//
            Animal cat = new Animal() {
                private String name = "aa";

                @Override
                public void eat() {
                    System.out.println("吃鱼肉");
                }
                
                public void show() {
                    System.out.println(name);
                }
            };
            cat.eat();
            //cat.show();
            ------>怎么调用自己的方法呢?
                 这里不能通过这种方式来调用,因为这里new出来的是子类的对象,子类赋值给父类,父类的引用变量引用其子类的对象,它只能调用父类中有的方法,而这个show方法是子类特有的,所以父类的引用变量是不能调用的。也不能将父类的引用变量强制类型转换为猫,因为这里没有猫这个类型,因此不能强制类型转换。所以可以这么做,因为这个类是匿名的,所以就不要赋值,即:
            new Animal() {
                private String name = "加菲猫";

                @Override
                public void eat() {
                    System.out.println("吃鱼肉");
                }
                
                public void show() {
                    System.out.println(name);
                }
            }.show();
                因为new出来的是它的一个子类的对象,那么对象名.方法名就可以调用自己内部的方法。所以要想调用匿名内部类中特有的方法,只能通过这种方式,不能赋值给父类的引用变量,因为它只能调用父类中有的方法,不能调用子类中特有的方法。
            //----------匿名内部类中可以定义代码块----------------//
            new Animal() {
                private String name;
                // 代码块,比构造方法先执行,一般用来对属性进行初始化,但是这里不能使用静态代码块。
                {
                    name = "TEST";
                }
                @Override
                public void eat() {
                    System.out.println(name);
                }
            };
        }
    }

    abstract class Animal {
        public abstract void eat();
    }

    class Person {
        public void feed(Animal animal) {
            // 同一个方法接收不同的实例对象(接收不同的动物),实现不同的功能。
            animal.eat();
        }
    }


    public class AnonymousInnerClass {
        public static void main(String[] args) {
            Person person = new Person();
            //-------------new一个接口的实现类对象--------------------//
            new IAnimal() {
                private String name = "aa";
                @Override
                public void eat() {
                    System.out.println("啃骨头");
                }
                
                public void show() {
                    System.out.println(name);
                }
            }.show();
            
            person.feed(new IAnimal() {
                
                @Override
                public void eat() {
                    System.out.println("吃鱼肉");
                }
            });
        }
    }

    interface IAnimal {
        // 接口里只能放方法的声明,不能放有方法体的方法;
        public abstract void eat();
    }

    class Person {
        public void feed(IAnimal animal) {
            animal.eat();
        }
    }

    展开全文
  • 3.1 匿名内部类特性   1. 匿名内部类总是默认实现某个接口或继承某个抽象类。 2.不能有构造方法,只能有一个实例。 3. 不能定义在任何静态成员、静态方法。 4. 不能是public.protected.private static. 5. ...

    3. 匿名内部类

     

     没有名字的内部类就是匿名内部类。

     

    3.1 匿名内部类特性

     

    1. 匿名内部类总是默认实现某个接口或继承某个抽象类。

    2.不能有构造方法,只能有一个实例。

    3. 不能定义在任何静态成员、静态方法。

    4. 不能是public.protected.private static.

    5. 匿名内部类为局部的,所以局部内部类的所有限制都对其有效。

    3.2  匿名内部类的使用方式

    一、继承式的匿名内部类: 就是new 抽象类。

    示例:

    package 匿名内部类抽象类练习;
    
    public abstract class Tv {
    	//打开电视
    	public abstract void open();
    	
    	//关闭电视
    	public abstract void close();
    	
    	//换台
    	public abstract void turn();
    }
    
    package 匿名内部类抽象类练习;
    
    public class Summer {
    	public static Tv extendsTv() {
    		Tv tv = new Tv() {
    
    			@Override
    			public void open() {
    				System.out.println("打开三星电视...");
    				
    			}
    
    			@Override
    			public void close() {
    				System.out.println("关闭三星电视...");
    				
    			}
    
    			@Override
    			public void turn() {
    				System.out.println("对三星电视进行换台...");
    				
    			}
    			
    		};
    		
    		//tv.open();
    		//tv.close();
    		//tv.turn();
    		return tv;
    	}
    }
    package 匿名内部类抽象类练习;
    
    public class XiaoMi {
    	public static Tv extendsTv() {
    		//匿名内部类... 抽象类的实现 ...
    		Tv tv = new Tv() {
    
    			@Override
    			public void open() {
    				System.out.println("打开小米电视...");
    				
    			}
    
    			@Override
    			public void close() {
    				System.out.println("关闭小米电视...");
    				
    			}
    
    			@Override
    			public void turn() {
    				System.out.println("对小米电视进行换台...");
    				
    			}
    			
    		};
    		
    		//tv.open();
    		//tv.close();
    		//tv.turn();
    		
    		return tv;
    	}
    }
    package 匿名内部类抽象类练习;
    
    public class Test {
    	public static void main(String[] args) {
    		Tv xiaomi = XiaoMi.extendsTv();
    		xiaomi.open();
    		xiaomi.turn();
    		xiaomi.close();
    		
    		System.out.println("------------------------------");
    		
    		Tv summer = Summer.extendsTv();
    		summer.open();
    		summer.turn();
    		summer.close();
    	}
    }

     

    展开全文
  • 匿名内部类

    2019-06-03 11:59:00
    一、 内部类特性 内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号 。 内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地...

    一、 内部类特性

    1.  内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号 。
    2.  内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的 。
    3.  内部类声明成静态的,就不能随便的访问外部类的成员变量了,此时内部类只能访问外部类的静态成员变量 。

    二、 匿名内部类

    1. 

     

     1 public class Parcel7
     2 {
     3     public Contents contents()
     4     {
     5         return new Contents()
     6         {
     7             private int i = 11;
     8             public int value() { return i; }
     9         };
    10     }
    11     public static void main(String[] args)
    12     {
    13         Parcel7 p = new Parcel7();
    14         Contents c = p.contents();
    15     }
    16 }

     

    在上述代码中, contents() 方法将返回值的生成与表达这个返回值的类定义结合在一起。另外,这个类是匿名的,它没有名字。

    语法:创建一个继承自Contents的匿名类的对象。通过new表达式返回的引用被自动向上转型为对Contents的引用。(向上转型内容参照:https://www.cnblogs.com/Leo-Xia/p/10917614.html

    关于分号的说明:在匿名内部类末尾的分号,并不是用来标记此内部类结束的。实际上,它标记的是表达式的结束,只不过这个表达式正巧包含了匿名内部类,因此,这与别的地方使用的分号是一致的。

    上述匿名内部类的代码,是下面代码的简化版本:

     1 public class Parcel7
     2 {
     3     public MyContents implements contents
     4     {
     5         private int i = 11;
     6         public int value() { return i; }
     7     }
     8     public Contents contents() { return new MyContents(); }
     9     public static void main(String[] args)
    10     {
    11         Parcel7 p = new Parcel7();
    12         Contents c = p.contents();
    13     }
    14 }

    在这个匿名类中,使用了默认的构造器来生成Contents。

     

    2. 下面代码展示了基类需要一个有参数的构造器

     1 public class Wrapping
     2 {
     3     private int i;
     4     public Wrapping(int x) { i = x; }
     5     public int value() { return i; }
     6 }
     7 //
     8 public class Parcel8
     9 {
    10     public Wrapping wrapping(int x)
    11     {
    12         return new Wrapping(x)
    13         {
    14             public int value()
    15             { 
    16                 return super.value() * 47; 
    17             }
    18         };
    19     }
    20     public static void main(String[] args)
    21     {
    22         Parcel8 p = new Parcel8();
    23         Contents w = p.wrapping();
    24     }
    25 }

    在该例子中,可以看到Wrapping拥有一个要求传递参数的构造器。

    这里是将x传进new Warpping(x)。

    在匿名内部类中,只需要简单地传递合适的参数给基类的构造器即可。

     

    3. 在匿名内部类定义中,对其进行初始化操作

     1 public class Parcel9
     2 {
     3     public Destination destination(final String dest)
     4     {
     5         return new Destination()
     6         {
     7             private String lable = dest;
     8             public String readLable() { return lable; }
     9         };
    10     }
    11     public static void main(String[] args)
    12     {
    13         Parcel9 p = new Parcel9();
    14         Destination d = p.destination("Tasmaina");
    15     }
    16 }

    在new Destination()中,使用到了在其外部定义的变量dest,编译器要求我们引用的参数是final的

    即: 如果定义一个匿名内部类,并且希望他使用一个在其外部定义的对象,那么编译器会要求其参数引用final的。

     

    4. 

    如果只是简单的给一个字段赋值,那么3例中的方法是很好的。但是,如果想做一个类似构造器的行为,但是匿名类中不可能有命名构造器(其原因是因为它根本就没有名字)。通过实例初始化,就能够达到为匿名内部类创建一个构造器的效果。具体实例如下:

     1 abstract class Base
     2 {
     3     public Base(int i)
     4     {
     5         System.out.println("Base coustructor. i = " + i);
     6     }
     7     public abstract void f();
     8 }
     9 public class AnonymousConstructor
    10 {
    11     public static Base getBase(int i)
    12     {
    13         return new Base(i)
    14         {
    15             { System.out.println("Inside instance initializer "); }
    16             public void f()
    17             {
    18                 System.out.println("In anonymous f()");
    19             }
    20         };
    21     }
    22         public static void main(String[] args)
    23         {
    24             Base base = getBase(47);
    25             base.f();
    26         }
    27 }

    注意: 在此例中,并没有要求变量 i 一定是final的,因为 i 被传递给匿名类的基类的构造器,并没有在匿名类内部被直接使用。

     

    5. 下面代码为带实例初始化的形式

     1 public class Parcel10
     2 {
     3     public Destination destination(final String dest, final float price) 
     4     {
     5         return new Destination()
     6         {
     7             private int cost;
     8             {
     9                 cost = Math.round(price);
    10                 if(cost > 100)
    11                     System.out.println("Over budget");
    12             }
    13             private String lable = dest;
    14             public String readLable() { return lable; }
    15         };
    16     }
    17     public static void main(String[] args)
    18     {
    19         Parcel10 p = new Parcel10();
    20         Destination d = p.destination("Tasmaina", 101.395F);
    21     }
    22 }

    其中 destination 的参数必须是 final 的,因为他们在匿名类中被使用到了。

    在实例初始化的内部,有 if 语句,它们不能作为实例初始化动作的一部分。所以对于匿名类而言,实例初始化的实际效果就是构造器。(但是,你不能重载实例初始化方法,所以仅有一个这样的构造器)

     

    匿名内部类与正规继承相比是受到限制的,因为匿名内部类既可以扩展类,也可以实现接口,但是不能二者兼备。并且,如果是实现接口,也只能实现一个接口。

     

    转载于:https://www.cnblogs.com/Leo-Xia/p/10966723.html

    展开全文
  • 匿名内部类 ** 成员内部类: 内部类处于外部类的成员位置 是外部的成员,就可以使用成员修饰符 是个类,有类的特性,继承,实现接口… 注意: 内部类中可以使用外部类中所有的内容,包括私有的 除了静态内部类以外的内部类...
  • 内部类可以是静态(static)的,可以使用 public、protected 和 private 访问控制符,而外部类只能使用 public,或者默认。 成员式内部类 在外部类内部直接定义(不在方法内部或代码块内部)的类就是成员式内部类,...
  • 广泛意义上的内部类一般来说包括这四种:成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来了解一下这四种内部类的用法。 1.成员内部类 内部类定义在外部类的成员位置 特点: 具有类的特性: 继承父类,...
  • 作用:对匿名内部类的简化。 写法:3种。 (参数) -> 单行语句 (参数) -> { 多行语句 } (参数) -> 表达式 测试代码: public class Test05 { public static void main(String[] args) { // 使用匿名内部...
  • Java匿名内部类

    2017-03-05 18:11:35
    根据声明的位置,判断匿名内部类是成员内部类还是方法内部类。一般是方法内部类,这是就具备内部类的特性
  • 的高级特性Java包类名冲突Java包语法 Java包 类名冲突 Java允许创建相同名称的,但是使用相同名称的容易造成类名的冲突。 创建一个: public class Demo { public static void main(String[] args) {...
  • 匿名内部类总结

    2020-07-23 01:38:10
    Thread本身并不是抽象类,因为覆盖了run方法,run的表现形式和父类不同,只有子类可以实现这个特性,所以new出的并不是Thread类,而是Thread类的匿名子类,即匿名内部类。如果不重写run方法,那么new出的就是Thread...
  • Lambda 表达式与匿名内部类的相同点如下:Lambda 表达式与匿名内部类一样,都可以直接访问 effectively final 的局部变量(如果不了解 Effectively final,可先阅读《Java8新特性之Effectively final》一节),以及...
  • 一.静态内部类1)内部类之前修饰...◆实例方法中,无法访问外部实例成员实例:静态内部类特性测试public class StaticInnerClass{ public static void main(String []args){ //Outer2.Inner2 inner=new Outer2.In
  • Java匿名内部类这篇文章来深入的了解一下匿名内部类的使用Java匿名类中的thisjava的匿名类特性,在于可以在项目里“内联”地实现一个类型,它可以继承一个现有的具体或抽象类,或是实现接口,并提供完整的成员实现...
  • /*** 匿名内部类的概念和特性:* 1、匿名内部类只能也必须(有且仅有)继承一个父类或者实现一个接口,也可以重写父类普通方法;* 2、匿名内部类不能是抽象类,因为定义匿名内部类时立即生成对象,而抽象类不允许生成...
  • JAVA中的匿名内部类

    2020-01-01 13:07:46
    在java的内部类当中,匿名内部类是用的最多的,匿名内部类是java8的新特性lambda表达式的重要前提。 我们传统方式的实现接口: 1.定义一个接口 2.定义他的实现类 3.父类引用指向子类对象(多态) 如果接口的实现...
  • 内部类和JDK8新特性 1.内部类 类中嵌套的类,当我们需要使用一个类描述信息,并且此类没有必要被外部其他类使用,我们可以定义为内部类。 1.1普通内部类 1.在类的内部定义,与实例变量、实例方法同级别的类。...
  • /*** 匿名内部类的概念和特性:* 1、匿名内部类只能也必须(有且仅有)继承一个父类或者实现一个接口,也可以重写父类普通方法;* 2、匿名内部类不能是抽象类,因为定义匿名内部类时立即生成对象,而抽象类不允许生成...
  • 负一、知道啥是匿名内部类不? 要使用lambda,我觉得你至少得明白匿名内部类是个啥。“o -> o.getName”是lambda表达式,"Book::getName"也是一个lambda表达式,表达式表达式,表达的是什么呢?当你在看到这个式...
  • 原来的匿名内部类 @Test public void test1(){ Comparator <String> com = new Comparator (){ @Override public int compare(String o1, String o2) { return Integer.compare(o1.length(), o2...
  • Java匿名内部类 顾名思义,就是没有名字的内部类。表面上看起来它们似乎有名字,实际上不是它们的名字。 ——百度百科 特性说明 没有名字的类 既然这个类没有名字,那么就只能使用一次,进而简化代码编写 前提条件...
  • lambda和匿名内部类

    2018-08-17 14:49:06
    在jdk8里面新加了一个lambda,其优点很多,主要是节约了代码,增加了可读性,它在很多方面和匿名内部类很相似,是高级语言的编写特征之一,结合匿名内部类讲解一下lambda的用法和特性;  注意点:  1.如果形参列表...
  • java中的多态使我们可以为接口类型的变量创建一个实例,即创建接口实现的对象。比如定义一个加法接口和一个该接口的实现 加法接口: public interface IAdd { int add(int a,int b); } 加法实现: ...
  • 静态内部类 我们知道非静态内部类是外部类的一个对象,我们可以通过将内部类定义成静态的,来将它当作外部类本身 值得一提的是,外部类不能用static来修饰 特性 1.静态内部类可以包含静态成员,也可以包含非静态成员...
  • 匿名内部类 匿名内部类也就是没有名字的内部类。这种类的定义之所有没有名称,因为其仅用在使用之处,其他地方也无需要使用。通常和new运算符同时定义类和创建对象。匿名类必须显示地指明其要继承和父类或接口。由...

空空如也

空空如也

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

匿名内部类特性