精华内容
下载资源
问答
  • 匿名内部类的格式和理解

    千次阅读 2018-09-02 18:54:47
    匿名内部类的格式和理解 A:匿名内部类 就是内部类的简化写法。 B:前提:存在一个类或者接口 这里的类可以是具体类也可以是抽象类。 匿名内部类,意思就是没有名字。没有名字就需要想办法表示它。 怎么表示它...

    匿名内部类的格式和理解

    • A:匿名内部类
      • 就是内部类的简化写法。
    • B:前提:存在一个类或者接口
      • 这里的类可以是具体类也可以是抽象类。
        匿名内部类,意思就是没有名字。没有名字就需要想办法表示它。
        怎么表示它呢?就是要实现一个接口或者继承一个类。
        必须要和外面的某个接口或者某个类产生关系,这才是匿名内部类。
    • C:格式
      new 类名或者接口名(){
      重写方法;
      }
    • D:本质是什么呢?
      • 是一个继承了该类或者实现了该接口的子类匿名对象。
    • E:案例演示

      • 按照要求来一个匿名内部类

        class Demo04_NoNameInnerClass{
            public static void main(String[] args){
                Outer o = new Outer();
                o.method();
            }
        }
        
        interface Inter{
            public void print();
        }
        
        /*
        //有名字的内部类
        class Outer{
            class Inner implements Inter{
                public void print() {
                    System.out.println("print");
                }
            }
        
            public void method(){
                //Inner i = new Inner();
                //i.print();
                new Inner().print();
            }
        }*/
        
        //匿名内部类
        //匿名内部类是局部内部类的一种,所以必须写在方法里。
        class Outer{
            public void method(){
                //整个代表Inter的子类对象,然后调用print方法
                new Inter(){                    //实现Inter接口
                    public void print(){        //重写抽象方法
                        System.out.println("print");
                    }
                }.print();
            }
        }
        
    展开全文
  • 匿名内部类:  1.匿名内部类其实就是内部类的简写格式。  2.定义匿名内部类的前提:内部类必须是继承一个抽象类或者实现接口。只要一个类是抽象的或是一个接口,那么其子类中的方 法都可以使用匿名内部类来实现 ...
    一.匿名内部类:
      1.匿名内部类其实就是内部类的简写格式。
      2.定义匿名内部类的前提:内部类必须是继承一个抽象类或者实现接口。只要一个类是抽象的或是一个接口,那么其子类中的方    法都可以使用匿名内部类来实现
      3.匿名内部类的格式:  new 父类或者接口(){定义子类的内容}
      4.其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
      5.匿名内部类中定义的方法最好不要超过3个。
    二.通过继承一个抽象类来定义匿名内部类。
    package com.saiermeng;
    abstract class AbsDemo
    {
    abstract void show();


    }
    class Outer4
    {
    int x = 3;
        public void function()
    {
                 AbsDemo d = new AbsDemo()
    {
    int num = 9;
    void show()
    {
    System.out.println("num==="+num);
    }
    void abc()
    {
    System.out.println("haha");
    }
    };


    d.show();
         }
    }
    class InnerClassDemo4 
    {
    public static void main(String[] args) 
    {
    new Outer4().function();
    }
    }
    运行结果是:
    num===9
    三.通过实现一个接口来定义匿名内部类。
    package com.saiermeng;
    interface Inter0{
    void method();

    }
    class Test0{
    static Inter0 function(){    


    return new Inter0(){      //new 就是新建了一个实现接口抽象方法的对象



    public void method() {
    System.out.println("method run");

    }

    };
    }
    }


    public class InnerClassTest0 {
    public static void main(String[]args){
    Test0.function().method();
    // 通过一个方法得到实现接口的子类对象,通过对象调用方法,就得到了Test0.function().method();
    show(new Inter0(){



    public void method() {
    System.out.println("method show run");

    }

    });

    }
    public static void show(Inter0 in){
    in.method();
    }
    }
    运行的结果是:
    method run
    method show run



    展开全文
  • 匿名内部类

    2020-07-17 10:03:36
    除此之外还有局部内部类,就是定义在方法内的,这个一般不怎么用,不需要掌握,知道就好,本文主要说匿名内部类,其他内部类以后会说。 如果接口的实现类(或者是父类的子类)只需要使用唯一的一次, 那么这种情况下...

    什么是匿名内部类

    如果在一个类里面定义一个类,那么这个类就是内部类,外面的那个类就是外部类,这个很好理解。内部类就相当于外部类的一个成员,你可以把内部类看成一个整体。内部类分为:静态内部类,非静态内部类。匿名内部类是非静态内部类的一种特殊情况,匿名内部类没有类名,因此就不可能有构造函数,不能创建对象。除此之外还有局部内部类,就是定义在方法内的,这个一般不怎么用,不需要掌握,知道就好,本文主要说匿名内部类,其他内部类以后会说。

    如果接口的实现类只需要使用唯一的一次,那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】。

    如果接口的实现类需要使用多次,那么需要直接实现该接口,而不是用匿名内部类实现

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

    new代表创建对象的动作
    接口名称就是匿名内部类需要实现哪个接口
    {…}这才是匿名内部类的内容

    注意:

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

    匿名内部类中的方法不能是抽象的;

    匿名内部类必须实现接口或抽象父类的所有抽象方法。

    匿名内部类访问的外部类成员变量或成员方法必须用static修饰;

    代码:

    接口

    public interface Inner {
        public String say();
    }
    

    抽象类

    public abstract class Inner1 implements Inner {
    }
    实现了接口的部分功能
    

    普通类

    public class Inner2 implements Inner {
        public String say() {
            return "this is Inner2";
        }
    }
    
    //实现了接口的全部功能
    

    外部类

    public class Outer {
    
        public static String s1 = "this is s1 in Outer";
        public static String s2 = "this is s2 in Outer";
        private static String s3 = "this is s3 in Outer";
    
        public void method1(Inner inner) {
            System.out.println(inner.say());
        }
    
        private static String method2() {
            return "this is method2 in Outer";
        }
    
        public static void main(String[] args) {
            Outer outer = new Outer();
            // 测试1,Inner为接口
            outer.method1(new Inner() {
                String s1 = "this is s1 in Inner";
    
                public String say() {
                    // 外部类和匿名函数类中有同名变量s1
                    return s1;
                }
            });
            // 测试2,Inner1为抽象类
            outer.method1(new Inner1() {
                String s2 = "this is s2 in Inner1";
    
                public String say() {
                    // 外部类和匿名函数类中有同名变量s2
                    return Outer.s2;
                }
            });
            // 测试3,Inner2为普通类
            outer.method1(new Inner2() {
                public String say() {
                    // 访问外部类私有变量s3
                    return s3;
                }
            });
            // 测试4,Inner2为普通类
            outer.method1(new Inner2() {
                public String say() {
                    // 访问外部类私有方法method1()
                    return method2();
                }
            });
        }
    }
    

    打印:

    this is s1 in Inner
    this is s2 in Outer
    this is s3 in Outer
    this is method2 in Outer

    展开全文
  • java匿名内部类实例

    2019-09-20 11:53:28
    正因为没有名字,所以这个匿名内部类只能使用一次,这怎么理解?很好理解,因为是匿名的,所以其他方法不能直接调用匿名内部类的方法,因为没有名字找不到这个方法,所以只能通过匿名内部类的使用方法来使用。 而且...

    匿名内部类,也就是没有名字的内部类
    正因为没有名字,所以这个匿名内部类只能使用一次,这怎么理解?很好理解,因为是匿名的,所以其他方法不能直接调用匿名内部类的方法,因为没有名字找不到这个方法,所以只能通过匿名内部类的使用方法来使用。
    而且匿名内部类还有一个前提条件:必须继承一个父类或者实现一个接口。这个也很好理解,匿名嘛,必须要有依托的主体才能存在。

    实例1:不实用匿名内部类来实现抽象方法

    abstract class Person {
    		public abstract void eat();
    		public void drink(){
    			System.out.println("haha");
    		}
    	}
    
    class Child extends Person {
    
    		@Override
    		public void eat() {
    			System.out.println("eat something");
    		}
    	}
    public class Demo{
    	public static void main(String[] args) {
    		Person p = new Child();
    		p.eat();
    		p.drink();
    	}
    }
    

    这个很好理解,继承然后实例化然后调用,但是此处的child类只使用了一次,没有其他实例再使用这个Child类了,那么将其编写成一个独立的类岂不是很麻烦?
    这个时候就引入了匿名内部类,类似调用的时候去创建一个就好了

    实例2:匿名内部类的基本实现

    abstract class Person {
    		public abstract void eat();
    		public void drink(){
    			System.out.println("haha");
    		}
    	}
    
    public class DemoTest2 {
    	public static void main(String[] args) {
    		Person p = new Person() {
    			
    			@Override
    			public void eat() {
    				// TODO Auto-generated method stub
    				System.out.println("eat something");
    			}
    		};
    		p.eat();
    		p.drink();
    	}
    }
    

    可以看到,我们直接将抽象类Person中的方法在大括号中实现了,这样可以省略一个类的书写,而且,匿名内部类还能用于接口上其实接口跟抽象类是差不多的

    interface Person{
    	public void eat();
    }
    
    public class DemoTest3 {
    	public static void main(String[] args) {
    		Person p = new Person() {
    			
    			@Override
    			public void eat() {
    				// TODO Auto-generated method stub
    				System.out.println("eat something");
    			}
    		};
    		p.eat();
    	}
    }
    

    由上面的例子可以看出,只要一个类是抽象的或者是一个接口,那么其子类中的方法(Child类)都可以使用匿名内部类来实现,最常用的情况就是在多线程的实现上,因为要实现多线程必须继承Thread类或者继承Runnable接口
    实例4:Thread类的匿名内部类实现

    public class DemoTest4 {
    	public static void main(String[] args) {
    		Thread t = new Thread(){
    			public void run(){
    				for (int i = 0; i < 5; i++) {
    					System.out.println(i + " ");
    				}
    			}
    		};
    		t.start();
    	}
    }
    

    实例5:Runnable接口的匿名内部类实现

    public class DemoTest5 {
    	public static void main(String[] args) {
    		Runnable r = new Runnable() {
    			
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				for (int i = 0; i < 5; i++) {
    					System.out.println(i + " ");
    				}
    			}
    		};
    		Thread t = new Thread(r);
    		t.start();
    	}
    }
    
    展开全文
  • 对于匿名内部类究竟是怎么回事,谈谈我自己的理解。 只有带有抽象方法,才提到匿名内部类。比如接口之中必须有抽象方法,只不过省略了abstract关键字,还有抽象类中也有抽象方法. 对于它到底是什么,我是这么理解...
  • 内部类是一个非常有用的特性但又比较难理解使用的特性(鄙人到现在都没有怎么使用过内部类,对内部类也只是略知一二)。  内部类我们从外面看是非常容易理解的,无非就是在一个类的内部在定义一个类。 ...
  • 匿名类理解

    2015-07-28 00:43:17
    匿名内部类 1、new 一个已有的类(Hander类) eg: Handler endSplashHandler2 = new Handler(){....} 2、得到一个子例 3、对其onCreate() 方法进行重写覆盖 4、再运用子例 非匿名内部类 1、写一个cla
  • 一。内部类基础二。...广泛意义上的内部类一般来说包括这四种:成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来了解一下这四种内部类的用法。1.成员内部类成员内部类是最普通的内部类,它的定义...
  • 我只是试着用大白话做个简单的整理,希望能更容易理解一点。关于对象与闭包的关系的一个有趣小故事(这篇的精华在后面的回复,小故事可以跳过)1.闭包(Closure)什么是闭包,大白话不怎么严谨的说就是:一个...
  • 网上看了,不怎么理解 ,有没有大神来通俗讲解下内部类下面匿名类问题。 ``` package foe; import java.lang.reflect.*; import demo2.user; public class test { public static void main(String[] args) ...
  • 十、内部类的认识

    2017-11-14 14:55:33
    口诀:局部、成员、匿名、静态 ... 内部类是一个非常有用的特性但又比较难理解使用的特性(鄙人到现在都没有怎么使用过内部类,对内部类也只是略知一二)。 第一次见面 内部类我们从外面看是非常容易...
  • 这些跟题目的匿名类有什么关系? 我们知道,匿名类是“随手”起的。它重复率不高,但是又具有“相似”动作。所以每次使用的时候,需要重新定义动作内容。这除了少量的定义可以重复外,它怎么就能“为所欲为”了呢?...
  • 匿名内部类了解吗? BIO和NIO区别,4核cpu,100个http连接,用BIO和NIO分别需要多少个线程 HashMap的负载因子。 jvm: jvm 内存结构 jvm 调优参数 什么是类加载? 何时类加载? java的类加载流程? 知道哪些类加载器。...
  • 程序员你真的理解final关键字吗? 前言 提到final关键字,想必大家都不陌生,可是程序员你真的理解final吗?就比如网上流传的”方法中不需要改变...在使用匿名内部类的时候会经常用到final关键字。而且在Java中St...
  • 匿名内部类进行简化可以写出lambda表达式,使我们的代码更简洁,但是可读性会变差,编译器会给出提示,这样的话有时候不用我们去想怎么写 引用可以在lambda的基础上再次进行简化,具体简化方式我不阐述了,举一个...
  •   用户线程的启动就是线程调用start方法,就是我们平时使用new Thread()对象,或者实现Runable()接口创建的线程,当然也可以直接通过匿名内部类启动。   启动守护线程也有两种方法,先来看看怎么启动守护...
  • 当使用内部类(包括匿名类)来创建Handler的时候,Handler对象会隐式地持有一个外部类对象(通常是一个Activity)的引用,不然你怎么可能通过Handler来操作Activity中的View。而Handler通常会伴随着一个耗时的后台...
  • 匿名内部类了解吗? BIO和NIO区别,4核cpu,100个http连接,用BIO和NIO分别需要多少个线程 HashMap的负载因子。 jvm: jvm 内存结构 jvm 调优参数 什么是类加载? 何时类加载? java的类加载流程? 知道哪些...
  • 匿名内部类了解吗? BIO和NIO区别,4核cpu,100个http连接,用BIO和NIO分别需要多少个线程 HashMap的负载因子。 jvm: jvm 内存结构 jvm 调优参数 什么是类加载? 何时类加载? java的类加载流程? 知道...
  • 匿名内部类了解吗? BIO和NIO区别,4核cpu,100个http连接,用BIO和NIO分别需要多少个线程 HashMap的负载因子。 jvm: jvm 内存结构 jvm 调优参数 什么是类加载? 何时类加载? java的类.
  • 匿名内部类了解吗? BIO和NIO区别,4核cpu,100个http连接,用BIO和NIO分别需要多少个线程 HashMap的负载因子。 jvm: jvm 内存结构 jvm 调优参数 什么是类加载? 何时类加载? java的..
  • Java ...匿名内部类了解吗? BIO和NIO区别,4核cpu,100个http连接,用BIO和NIO分别需要多少个线程 HashMap的负载因子。 jvm: jvm 内存结构 jvm 调优参数 什么是类加载? 何时类加载? jav.
  • Java常见面试题

    2020-03-05 21:44:06
    Java常见面试题 基础: ...匿名内部类了解吗? 4.BIO和NIO区别,4核cpu,100个http连接,用BIO和NIO分别需要多少个线程 5.假如我们需要存500个数需要多大的HashMap? 6.HashMap的负载因子。 JVM: 1.jvm...
  • Java面试题.docx

    2020-02-19 08:44:27
    9、成员内部类、静态内部类、局部内部类和匿名内部类理解,以及项目中的应用 10、string 转换成 integer的方式及原理 11-20题: 11、哪些情况下的对象会被垃圾回收机制处理掉? 12、静态代理和动态代理的区别...
  • 使用匿名类实现筛选,使用匿名类主要是便于理解使用功能lambda表达时,容易想想其内容是怎么实现的。 public class Lambda09 { public static void main(String[] args) { List<Student> students = Arrays....
  • 关键字(二):final

    2020-03-15 16:58:14
    前言 提到final关键字,想必大家都不陌生,可是程序员你真的理解final吗?就比如网上流传的”方法中不需要改变作为...在使用匿名内部类的时候会经常用到final关键字。而且在Java中String类就是一个final类,从本篇...
  • Handler彻底理解 本篇文章主要为了解决以下问题: Handler是什么,有什么作用,怎么使用 Handler的原理 能不能手写一个Handler 其他常见的Handler问题 ...下图其实有警告:说匿名内部类Handle可能会产...

空空如也

空空如也

1 2 3 4
收藏数 69
精华内容 27
关键字:

匿名内部类怎么理解