内部类 订阅
内部类(Inner Class),是 Java 中对类的一种定义方式,是嵌套类的一个分类,即非静态嵌套类(Non-Static Nested Class)。内部类(非静态嵌套类)分为成员内部类、局部内部类和匿名内部类三种。 展开全文
内部类(Inner Class),是 Java 中对类的一种定义方式,是嵌套类的一个分类,即非静态嵌套类(Non-Static Nested Class)。内部类(非静态嵌套类)分为成员内部类、局部内部类和匿名内部类三种。
信息
外文名
Inner Class
中文名
内部类
内部类定义
以下内容来自 Java 官方教程中的《嵌套类》章节。 [1]  Java 编程语言允许一个类被定义在另一个类中,这样的类就称为嵌套类。嵌套类分为两种:静态的和非静态的。没有用 static 关键字来声明的嵌套类,就称为非静态嵌套类。非静态嵌套类,又称为内部类。内部类还有两个特殊的类型:局部类(Local Class)和匿名类(Anonymous Class)。包含嵌套类的类,可称为外围类(Enclosing Class)或外部类(Outer Class)。非静态嵌套类(内部类)可访问其外围类的其他成员,即使这些成员被声明为私有的。若内部类作为其外部类的成员,则它可声明为 private、public、protected 或包私有的。
收起全文
精华内容
参与话题
问答
  • java匿名内部类什么是匿名内部类?匿名内部类的使用场景?匿名内部类如何创建?匿名内部类的实现和使用例1(实现接口)例2(继承类) 什么是匿名内部类? 匿名内部类,顾名思义,就是不知道这个类到底是什么名字,也...

    什么是匿名内部类?

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

    匿名内部类的使用场景?

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

    匿名内部类如何创建?

    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
    

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

    展开全文
  • 内部类

    万次阅读 2020-05-15 18:12:51
    内部类定义 内部类: 所谓内部类就是在一个类内部进行其他类结构的嵌套操作。 内部类的优缺点 优点 内部类与外部类可以方便的访问彼此的私有域(包括私有方法、私有属性)。 内部类是另外一种封装,对外部的其他类...

    内部类定义

    内部类: 所谓内部类就是在一个类内部进行其他类结构的嵌套操作。

    内部类的优缺点

    优点

    1. 内部类与外部类可以方便的访问彼此的私有域(包括私有方法、私有属性)。
    2. 内部类是另外一种封装,对外部的其他类隐藏。
    3. 内部类可以实现java的单继承局限。

    缺点
    结构复杂

    内部类是否有用、 必要和安全

    当在Java1.1的Java语言中增加内部类时,很多程序员都认为这是–项很主要的新特性,
    但这却违背了Java要比C++更加简单的设计理念。内部类的语法很复杂(可以看到,稍后介
    绍的匿名内部类更加复杂)。它与访问控制和安全性等其他的语言特性的没有明显的关联。
    由于增加了一些看似优美有趣,实属没必要的特性,似乎Java也开始走上了许多语言饱
    受折磨的毁灭性道路上。

    我们并不打算就这个问题给予-一个完整的答案。内部类是一-种编译器现象,与虚拟机无
    关。编译器将会把内部类翻译成用$ (美元符号)分隔外部类名与内部类名的常规类文件,而
    虚拟机则对此一无所知。

    内部类的分类

    局部内部类

    在方法体中定义的类被称为局部内部类
    局部类不能用publicprivate访问说明符进行声明。它的作用域被限定在声明这个局部
    类的块中

    局部类有一一个优势,即对外部世界可以完全地隐藏起来
    与其他内部类相比较,局部类还有一个优点。它们不仅能够访问包含它们的外部类,还
    可以访问局部变量。不过,那些局部变量必须事实上为final。这说明,它们一旦赋值就绝不.
    会改变
    在这里插入图片描述

    匿名内部类

    将局部内部类的使用再深入一步。假如只创建这个类的一个对象,就不必命名了。这种类被称为匿名内部类

    在这里插入图片描述
    在这里插入图片描述

    静态内部类

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • java内部类

    千次阅读 多人点赞 2013-03-19 16:25:42
    Java内部类 目录 1 JAVA内部类 1 1.1 简介 1 2 JAVA内部类的分类 1 2.1 成员内部类 1 2.2 方法内部类 1 2.3 匿名内部类 1 2.4 静态内部类 1 1 Java内部类 1.1 简介 内部类内部类顾名思义...
    Java内部类


    目录
    1 JAVA内部类 1
    1.1 简介 1
    2 JAVA内部类的分类 1
    2.1 成员内部类 1
    2.2 方法内部类 1
    2.3 匿名内部类 1
    2.4 静态内部类 1



    1 Java内部类
    1.1 简介
    内部类:内部类顾名思义就是类中类,即在一个类中定义了另一个类,内部类依赖于外部类而存在。
    (1)、内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是内部类的名称为外部类名$内部类名。
    (2)、Java在创建内部类对象时,会隐式的把其外部类对象的引用传给内部类并保存,这样就使得内部类对象始终都可以访问其外部类对象,同时这也是为什么在外部类作用范围之外要创建内部类对象必须创建其外部类对象。
    (3)、如果内部类声明为静态类,那么内部类就不能随便访问外部类的成员变量,仍然只能访问外部类的静态成员变量。
    (4)、外部类只能使用public和缺省的包访问权限修饰类,而内部类可以使用public,protected,private访问权限来修饰类。

    2 JAVA内部类的分类
    内部类分为:成员内部类,方法内部类,匿名内部类,静态内部类。
    2.1 成员内部类
    作为外部类的一个成员存在,与外部类的属性、方法并列。
    package com.nbl;

    /**
    * 外部类
    * @author Administrator
    *
    */
    public class OuterA {

    private String oa ="oa";
    static String ob ="ob";

    /**
    * 内部类
    */
    class InnerA{

    private String ia = "ia";
    //static String ib = "ib";//内部类中不允许定义静态变量
    private String ob = "ib";

    /**
    * 内部类方法
    */
    public void doMethod(){
    //内部类访问外部类的成员变量,即使是访问权限是private
    System.out.println(oa);
    //当内外部类中成员变量同名后,访问的是内部类的成员变量
    System.out.println(ob);
    //当内外部类中成员变量同名后,可以通过外部类名.this来访问外部类成员变量
    System.out.println(OuterA.this.ob);
    }

    }

    /**
    * 外部类的非静态方法访问成员内部类
    */
    public void doMethod(){
    InnerA ia = new InnerA();
    //OuterA.InnerA ia = new OuterA.InnerA();
    ia.doMethod();
    }

    /**
    * 外部类的静态方法访问成员变量内部类
    */
    static void doStatic(){
    //step1创建外部类对象
    OuterA oa = new OuterA();
    //step2根据外部类对象创建内部类对象
    InnerA ia = oa.new InnerA();
    //step3访问内部类
    ia.doMethod();
    }


    public static void main(String[] args) {
    //直接调用静态方法,输出结果和下面语句执行结果一样
    //doStatic();
    /**
    * 如果要创建一个内部类的对象,就必须先创建一个外部类对象,
    * 由外部内对象来创建一个内部类对象,不能想当然在new操作上加上外部类的名称就可以了。
    * 当然如果内部类为静态内部类,那就不需要创建外部类对象了。
    */
    OuterA oa = new OuterA();
    OuterA.InnerA ia = oa.new InnerA();
    //InnerA ia = oa.new InnerA();
    ia.doMethod();
    }


    }


    执行结果为:
    oa
    ib
    ob


    注:内部类是一个编译时的概念,一旦编译成功,就会有两个完全不同的类OuterA.class和OuterA$InnerA.class
    ..

    2.2 方法内部类
    方法内部类又叫局部内部类,即在外部类的方法中定义内部类。
    package com.nbl;

    /**
    * 外部类
    * @author Administrator
    *
    */
    public class OuterB {

    private String oa = "oa";
    private String ob = "ob";

    //外部类方法
    public void doMethod(){

    final String ma = "ma";
    final String ob = "mb";

    /**
    * 方法中定义内部类
    */
    class InnerB{

    private String ob = "ib";

    //内部类方法
    void doMethod(){
    //可以直接访问外部类的成员变量
    System.out.println(oa);
    //可以直接访问其方法的局部变量,局部变量必须为final类型
    System.out.println(ma);
    //如果内部类的成员变量和方法的局部变量同名,内部类的成员变量和覆盖其方法的局部变量
    System.out.println(ob);
    System.out.println(this.ob);
    //如果内部类的成员变量和外部类的成员变量同名,可以通过外部类名.this+访问外部类变量
    System.out.println(OuterB.this.ob);

    }

    }
    //方法内部类只能在定义其内部类的方法中实例化
    new InnerB().doMethod();

    }


    public static void main(String[] args) {
    //创建外部类
    OuterB ob = new OuterB();
    ob.doMethod();
    }


    }


    执行结果:
    oa
    ma
    ib
    ib
    ob


    注:方法内部类在定义该类的方法中实例化,不能再此方法外对其实例化。方法内部类对象不能使用该内部类所在方法的非final局部变量。

    2.3 匿名内部类
    匿名内部类:顾名思义就是没有名字的内部类。
    使用匿名内部类注意一下几点:
    1) 匿名内部类不能有构造方法。
    2) 匿名内部类不能定义任何静态成员、方法和类。
    3) 匿名内部类不能是public,protected,private,static。
    4) 只能创建匿名内部类的一个实例。
    5) 一个匿名内部类一定是在new的后面,用其隐含实现一个接口或实现一个类。
    6) 因匿名内部类为局部内部类,所以局部内部类的所有限制都对其生效。

    package com.nbl;

    /**
    * 内部类接口
    * @author Administrator
    *
    */
    interface InterfaceC {

    public void doMethod();

    }


    内部类实现接口

    package com.nbl;

    /**
    * 外部类
    * @author Administrator
    *
    */
    public class OuterC {

    String oa = "oa";

    private void doMethod(){

    final String ma = "ma";

    /**
    * 方法中的匿名内部类同等于方法内部类
    */
    InterfaceC ic = new InterfaceC(){

    public void doMethod(){
    //直接访问外部内成员变量
    System.out.println(oa);
    //只能访问方法中final变量
    System.out.println(ma);
    }

    };
    ic.doMethod();
    }

    public static void main(String[] args) {
    OuterC oc = new OuterC();
    oc.doMethod();
    }

    }


    执行结果:
    oa
    ma


    2.4 静态内部类
    静态内部类又叫嵌套类,静态内部类不像普通内部类对象隐式地保存了外部类的一个引用,他们只是一种共享关系。
    使用Static修饰的内部类注意以下几点:
    (1) 要创建内部类对象,并不需要外部类对象。
    (2) 不能从内部类对象中访问外部类的非静态成员(包括非静态成员变量,非静态方法)。

    package com.nbl;

    /**
    * 外部类
    * @author Administrator
    *
    */
    public class OuterD {

    public String oa = "oa";
    public static String ob = "ob";
    public static String oc = "oc";

    /**
    * 静态内部类
    */
    static class InnerD{

    private String ia = "ia";
    private String oc = "ic";
    private static String id = "id";

    public void doMethod(){
    //静态内部类不能访问外部类非静态成员
    //System.out.println(oa);
    //静态内部类直接访问外部类的静态成员
    System.out.println(ob);
    //静态内部类直接访问内部类变量
    System.out.println(ia);
    //静态内部类和外部类的静态成员同名,可以通过外部类名加成员名访问
    System.out.println(OuterD.oc);
    }

    }

    /**
    * 外部类方法访问内部类
    */
    public void doAction(){
    //外部类访问内部类静态成员可以直接通过类名来访问
    System.out.println(InnerD.id);
    //外部类访问内部类非静态成员需要实例化内部类
    System.out.println(new InnerD().ia);
    }

    public static void main(String[] args) {
    //外部类执行方法
    OuterD od = new OuterD();
    od.doAction();
    /**
    * 静态内部类的对象可以直接生成
    * Outer.Inner in = new Outer.Inner();
    * 而不需要通过生成外部类对象来生成。
    */
    OuterD.InnerD id = new OuterD.InnerD();
    //InnerD id = new InnerD();
    id.doMethod();
    }

    }


    执行结果:
    id
    ia
    ob
    ia
    oc


    注:静态内部类可以看成是一个高级类来使用,他并不依赖外部类对象。
    展开全文
  • Java内部类和匿名内部类的用法

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

    Java内部类和匿名内部类的用法

        【尊重原创,转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51981163
    一、内部类: 
          (1)内部类的同名方法
            内部类可以调用外部类的方法,如果内部类有同名方法必须使用"OuterClass.this.MethodName()"格式调用(其中OuterClass与MethodName换成实际外部类名及其方法;this为关键字,表示对外部类的引用);若内部类无同名方法可以直接调用外部类的方法。
            但外围类无法直接调用内部类的private方法,外部类同样无法直接调用其它类的private方法。注意:内部类直接使用外部类的方法与该方法的权限与是否static无关,它取决于内部类是否有同名方法。
    package innerclass;
    public class OuterClass {
    	private void outerMethod() {
    		System.out.println("It's Method of OuterClass");
    	}
    	public static void main(String[] args) {
    		OuterClass t = new OuterClass();
    		OuterClass.Innerclass in = t.new Innerclass();
    		in.innerMethod();
    	}
    
    	class Innerclass {
    		public void innerMethod() {
    		   OuterClass.this.outerMethod();// 内部类成员方法与外部类成员方法同名时,使用this调用外部类的方法
    		   outerMethod();// 内部类没有同名方法时执行外部类的方法
    		}
    		private void outerMethod() {
    			System.out.println("It's Method of Innerclass");
    		}
    	}
    }
         输出结果为:
    It's Method of OuterClass
    It's Method of Innerclass
        (2)内部类访问外部类的变量必须声明为final
          方法中的局部变量,方法结束后这个变量就要释放掉,final保证这个变量始终指向一个对象。
       首先,内部类和外部类其实是处于同一个级别,内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了,如果外部类的方法中的变量不定义final,那么当外部类方法执行完毕的时候,这个局部变量肯定也就被GC了,然而内部类的某个方法还没有执行完,这个时候他所引用的外部变量已经找不到了。如果定义为final,java会将这个变量复制一份作为成员变量内置于内部类中,这样的话,由于final所修饰的值始终无法改变,所以这个变量所指向的内存区域就不会变。
         注意,若使用JDK1.8,方法中内部类的方法是可以直接访问外部类的方法的局部变量,并且不需要声明为final类型。
    public class OuterClass {
    	int num1 = 0;// 成员变量
    
    	private void outerMethod() {
    		int num2 = 0;// 方法内的局部变量
    		class Innerclass_1 {
    			public void innerMethod() {
    				System.out.println(num1);// 方法中内部类的方法,可以正常访问外部类的成员变量
    				System.out.println(num2);// JDK1.8以前,方法中内部类的方法,不能直接访问外部类的方法的局部变量,必须声明为final
    			}
    		}
    	}
    }
          如果使用JDK1.8以前的版本,Eclipse会出现如下错误提示:

        (3)内部类的实例化
         内部类实例化不同于普通类,普通类可以在任意需要的时候实例化,而内部类必须在外层类实例化以后方可实例化,并与外部类建立关系
         因此在外部类中的非static方法中,是可以实例化内部类对象
    	private void outerMethod() {
    		System.out.println("It's Method of OuterClass");
    		Innerclass in = new Innerclass();//在外部类的outerMethod方法中实例化内部类是可以啊
    	}
         但在static方法中,就要注意啦!!!!不能在static方法中直接new内部类,否则出现错误:
         No enclosing instance of type OuterClass is accessible. Must qualify the allocation with an enclosing instance of type OuterClass (e.g. x.new A() where x is an instance of OuterClass).
         这是因为静态方法是在类实例化之前就可以使用的,通过类名调用,这时动态内部类都还没实例化呢,怎么用,总不能调用一个不存在的东西吧。
         如果想在Static方法中new内部类,可以把内部类声明为Static
    public class OuterClass {
    	private void outerMethod() {
    		System.out.println("It's Method of OuterClass");
    	}
    
    	public static void main(String[] args) {
    		Innerclass in = new Innerclass();
    		in.innerMethod();
    	}
    
    	static class Innerclass {//把内部类声明为static
    		public void innerMethod() {
    			System.out.println("It's Method of innerMethod");
    
    		}
    	}
    
    }
         当然,一般不使用static的方式,而是推荐这种方法:x.new A() ,其中 x是外部类OuterClass的实例,A是内部类Innerclass
    package innerclass;
    public class OuterClass {
    	private void outerMethod() {
    		System.out.println("It's Method of OuterClass");
    	}
    	public static void main(String[] args) {
    		OuterClass.Innerclass in = new OuterClass().new Innerclass();//使用x.new A()的方式
    		in.innerMethod();
    	}
    	class Innerclass {
    		public void innerMethod() {
    			System.out.println("It's Method of innerMethod");
    		}
    	}
    }
         x.new A() ,其中 x是外部类OuterClass的实例,A是类部类Innerclass,当然可以拆分如下,这样就显然很明白啦:
    	public static void main(String[] args) {
    		OuterClass out = new OuterClass();//外部实例
    		OuterClass.Innerclass in = out.new Innerclass();//外部实例.new 外部类
    		in.innerMethod();
    	}

        (4)什么情况下使用内部类
         典型的情况是,内部类继承自某个类或实现某个接口,内部类的代码操作创建其的外层类的对象。所以你可以认为内部类提供了某种进
    入其外层类的窗口。
        使用内部类最吸引人的原因是:每个内部类都能独立地继承自一个(接口的)实现,所以无论外层类是否已经继承了某个(接口的)实
    现,对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力,一些设计与编程问题就很难解决。从这个角
    度看,内部类使得多重继承的解决方案变得完整。接口解决了部分问题,而内部类有效地实现了“多重继承”。
       (5)在静态方法中实例化内部类例子:(内部类放在静态方法中)
    package javatest2;
    public class JavaTest2 {
    	public static void main(String[] args) {
    		class Boy implements Person {
    			public void say() {// 匿名内部类自定义的方法say
    				System.out.println("say方法调用");
    			}
    			@Override
    			public void speak() {// 实现接口的的方法speak
    				System.out.println("speak方法调用");
    			}
    		}
    		Person per = new Boy();
    		per.speak();// 可调用
    		per.say();// 不能调用
    	}
    }
    interface Person {
    	public void speak();
    }
           per.speak()可调用,而per.say()不能调用,这时因为per是Person对象,要想调用子类的方法,可以强制向下转型为:((Boy) per).say();或者直接改为Boy per = new Boy();。从中可发现,要想调用内部类的自定义的方法,必须通过内部类的对象来调用。那么,匿名内部类连名字都没有,怎么调用内部类自定义的方法?
    (二)匿名内部类
          匿名内部类也就是没有名字的内部类正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写,但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口,但最多只能继承一个父类,或实现一个接口。
    关于匿名内部类还有如下两条规则:
        1)匿名内部类不能是抽象类,因为系统在创建匿名内部类的时候,会立即创建内部类的对象。因此不允许将匿名内部类定义成抽象类。
        2)匿名内部类不等定义构造器(构造方法),因为匿名内部类没有类名,所以无法定义构造器,但匿名内部类可以定义实例初始化块,
        怎样判断一个匿名类的存在啊?看不见名字,感觉只是父类new出一个对象而已,没有匿名类的名字。
    先看段伪代码
    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() ;
    }
    
         先看一个例子,体会一下匿名内部类的用法:

        运行结果:eat something
        可以看到,我们直接将抽象类Person中的方法在大括号中实现了,这样便可以省略一个类的书写。并且,匿名内部类还能用于接口上
    public class JavaTest2 {
    	public static void main(String[] args) {
    		Person per = new Person() {
    			public void say() {// 匿名内部类自定义的方法say
    				System.out.println("say方法调用");
    			}
    			@Override
    			public void speak() {// 实现接口的的方法speak
    				System.out.println("speak方法调用");
    			}
    		};
    		per.speak();// 可调用
    		per.say();// 出错,不能调用
    	}
    }
    
    interface Person {
    	public void speak();
    }
            这里per.speak()是可以正常调用的,但per.say()不能调用,为什么呢?注意Person per = new Person()创建的是Person的对象,而非匿名内部类的对象。其实匿名内部类连名字都没有,你咋实例对象去调用它的方法呢?但继承父类的方法和实现的方法是可以正常调用的,本例子中,匿名内部类实现了接口Person的speak方法,因此可以借助Person的对象去调用。
            若你确实想调用匿名内部类的自定义的方法say(),当然也有方法:
          (1)类似于speak方法的使用,先在Person接口中声明say()方法,再在匿名内部类中覆写此方法。
          (2)其实匿名内部类中隐含一个匿名对象,通过该方法可以直接调用say()和speak()方法;代码修改如下:
    public class JavaTest2 {
    	public static void main(String[] args) {
    		new Person() {
    			public void say() {// 匿名内部类自定义的方法say
    				System.out.println("say方法调用");
    			}
    
    			@Override
    			public void speak() {// 实现接口的的方法speak
    				System.out.println("speak方法调用");
    			}
    		}.say();// 直接调用匿名内部类的方法
    	}
    }
    interface Person {
    	public void speak();
    }











    展开全文
  • 文章目录1 内部类的基本概念1.1 内部类的定义1.2 内部类的优缺点2 创建内部类2.1 在外部类外部创建非静态内部类2.2 在外部类外部创建静态内部类2.3 在外部类内部创建内部类语法3 内部类的分类3.1 成员内部类3.2 静态...
  • 详解 Java 内部类

    万次阅读 多人点赞 2018-09-04 00:17:56
    从种类上说,内部类可以分为四类:普通内部类、静态内部类、匿名内部类、局部内部类。我们来一个个看: 普通内部类 这个是最常见的内部类之一了,其定义也很简单,在一个类里面作为类的一个字段直接定义就可以...
  • 我最近在使用一个安卓图表插件androidplot,看到别人很多代码都使用了匿名内部类,像这样: ``` _ratePlot.setRangeValueFormat(new Format() { @Override public StringBuffer format(Object obj, @NonNull ...
  • 内部类(成员内部类、静态内部类、方法内部类)

    万次阅读 多人点赞 2018-06-05 15:33:35
    一:成员内部类:最常见的内部类就是成员内部类,也称作普通内部类;1、Inner类定义在Outer类的内部,相当于Outer类的成员变量的位置,Inner类可以使用任意访问修饰符,如:public、private、protected等。2、Inner...
  • 1、如果想访问没有static修饰的内部类,先要访问其外部类(内部类在外部类里),再由外部类通过方法(或者别的办法)去访问内部类。 2、而如果内部类在外部类的方法里,要先访问外部类,再通过访问方法来访问内部类...
  • java内部类之成员内部类、局部内部类和匿名内部类

    千次阅读 多人点赞 2018-07-15 16:13:30
    内部类概念 一个类中包含另外一个类。 分类 1、成员内部类。 2、局部内部类(包含匿名内部类)。 成员内部类 定义格式: 修饰符 class 类名称 { 修饰符 class 类名称 { //... } //... } 注意: 内部类...
  • 内部类的实现方式有很多种,其中内明内部类和局部内部类比较常见,下面的一个例子主要是针对这两种实现方式做一个简单的... * 这个类主要说明通过匿名内部类和局部内部类的方式来实现内部类,以及说明了内部类可以不受
  • 匿名内部类看了半天真心看不懂,不知如何理解,如何更好的应用,还要它是否属于内部类的一种,和成员内部类以及局部内部类有什么区别。
  • 成员内部类class Demo1_InnerClass { public static void main(String[] args) { //Inner i = new Inner(); //i.method(); //外部类名.内部类名 = 外部类对象.内部类对象 Outer.Inner oi = new Outer().new...
  • 一、私有内部类: class Out { private int age = 12; private class In { public void print() { System.out.println(age); } } public void outPrint() { new

空空如也

1 2 3 4 5 ... 20
收藏数 135,863
精华内容 54,345
关键字:

内部类