精华内容
下载资源
问答
  • 匿名累不累(匿名内部类) 正常情况下要调用一个接口中的方法需要这样: public class TestClass { public static void main(String[] args) { TestInterfaceImpl testInterface = new TestInterfaceImpl(); ...

    匿名累不累(匿名内部类)

    正常情况下要调用一个接口中的方法需要这样:

    
    public class TestClass {
        public static void main(String[] args) {
            TestInterfaceImpl testInterface = new TestInterfaceImpl();
            testInterface.show();
        }
    }
    
    interface TestInterface{
        void show();
    }
    
    class TestInterfaceImpl implements TestInterface{
        @Override
        public void show() {
            System.out.println("测试,重写的show方法");
        }
    }
    

    1.创建实现类对象去实现接口

    2.重写方法

    3.创建实现类对象

    4.调用重写的方法

    使用内部类的方式

    public class TestClass1 {
        public static void main(String[] args) {
            new TestInterface1() {
                @Override
                public void show() {
                    System.out.println("重写的show方法");
                }
            }.show();
        }
    }
    
    interface TestInterface1{
        void show();
    }
    

    匿名内部类的理解:

    • 将继承,重写,创建对象,放在一步执行

    • 匿名内部类的前提 : 需要存在一个接口或者类

    接口中有多个方法

    
    public class TestClass1 {
        public static void main(String[] args) {
            TestInterface1 testInterface1 =new TestInterface1() {
                @Override
                public void show() {
                    System.out.println("重写的show方法");
                }
    
                @Override
                public void show1() {
                    System.out.println("重写的show1方法");
                }
            };
            testInterface1.show();
            testInterface1.show1();
        }
    }
    
    interface TestInterface1{
        void show();
        void show1();
    }
    
    

    以多态的方式进行接收,然后在调用不同的方法.

    匿名内部类在开发中的使用场景

    public interface Swimming {
        void swim();
    }
    
    
    public class TestSwimming {
        public static void main(String[] args) {
    
            goSwimming(new Swimming() {
                @Override
                public void swim() {
                    System.out.println("游泳");
                }
            });
        }
    
        public static void goSwimming(Swimming swimming){
            swimming.swim();
        }
    }
    
    • 当方法的形式参数是接口或者抽象类是可以将匿名内部类作为实际参数进行传递
    展开全文
  • TreeSet 的构造函数可以传一个比较器进去,为什么把这个比较器写成匿名累不累,eclipse 表示认不到。。不知道为什么。。。 TreeSet ts = new TreeSet(new Comparator(){ public int compare(Object o1, Object ...
  • 4.8主要讲了static关键字,并且具体介绍了静态字段,静态属性,静态方法,静态类,静态构造方法,单例模式,具体是采用什么方式... 4.10匿名类:使用匿名类的方式创建实例,可以将一组只读属性封装到单个对象中。 ...

          4.8主要讲了static关键字,并且具体介绍了静态字段,静态属性,静态方法,静态类,静态构造方法,单例模式,具体是采用什么方式访问的。

           4.9介绍了一个概念叫嵌套类,类定义在另一个类的内部,由于嵌套类被声明的位置比较特殊,致使其访问权限与引用方式与普通类有所区别。

            4.10匿名类:使用匿名类的方式创建实例,可以将一组只读属性封装到单个对象中。

              4.11对象初始化器:对象初始化器可以有效解决一个类中属性过多的问题。

    转载于:https://www.cnblogs.com/ma214zq/p/10591166.html

    展开全文
  • 内部类你学着累不

    2020-08-14 16:32:18
    匿名内部类 成员内部类 如何直接访问内部类的成员。 外部类名.内部类名 对象名 = 外部类对象.内部类对象; class Outer { private int num = 10; class Inner { public void show() { System.out.println...

    内部类概述

    在 Java 中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类。

    • 成员内部类
    • 局部内部类
    • 匿名内部类

    成员内部类

    如何直接访问内部类的成员。
    外部类名.内部类名 对象名 = 外部类对象.内部类对象;

    class Outer {
    	private int num = 10;	
    	class Inner {
    		public void show() {
    			System.out.println(num);
    		}
    	}
    }
    
    class InnerClassDemo {
    	public static void main(String[] args) {
    		// 访问Inner类的show()方法
    
            //格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象;
    		Outer.Inner oi = new Outer().new Inner();
    		oi.show();
    	}
    }
    

    而成员内部类的使用,一般来说,在实际开发中是不会这样直接使用的,因为一般内部类就是为了不让外界直接访问的

    因此,对Innershow()方法进行保护,使用private为了保证数据的安全性

    class Outer {
    	private int num = 10;	
    	class Inner {
    		private void show() {
    			System.out.println(num);
    		}
    	}
        public void GetShow() {
            Inner i = new Inner();
            i.show();
        }
    }
    
    class InnerClassDemo {
    	public static void main(String[] args) {
    		// 访问Inner类的show()方法
            Outer o = new Outer();
            o.GetShow();
    	}
    }
    

    使用static修饰让数据访问更加方便

    • 被静态修饰的成员内部类只能访问外部类的静态成员
    • 内部类被静态修饰后方法
      • 静态方法
      • 非静态方法
    class Outer {
    	private int num = 10;
    	private static int num2 = 100;
    	
    	//内部类用静态修饰是因为内部类可以看出是外部类的成员
    	public static class Inner {
    		public void show() {
    			System.out.println(num2);
    		}
    
    		public static void show2() {
    			System.out.println(num2);
    		}		
    	}
    }
    
    class InnerClassDemo {
    	public static void main(String[] args) {
    		Outer.Inner oi = new Outer.Inner();
    		oi.show();
    		oi.show2();
    		System.out.println("----------");
    		//show2()的另一种调用方式
    		Outer.Inner.show2();	
    	}
    }
    

    思考

    填空,要求分别输出30,20,10

    		class Outer {
    			public int num = 10;
    			class Inner {
    				public int num = 20;
    				public viod show() {
    					int num  = 30;
    					System.out.println(?);
    					System.out.println(?);
    					System.out.println(?);
    				}
    			}
    		}
    

    		class Outer {
    			public int num = 10;
    			class Inner {
    				public int num = 20;
    				public viod show() {
    					int num  = 30;
    					System.out.println(num);
    					System.out.println(this.num);
    					System.out.println(Outer.this.num);
    				}
    			}
    		}
            class InnerClassDemo4 {
                public static void main(String[] args) {
                    Outer.Inner oi = new Outer().new Inner();
                    oi.show();
                }
            }
    

    注意:

    • 内部类和外部类没有继承关系
    • 通过外部类名限定this对象,(Outer.this

    局部内部类

    • 可以直接访问外部类的成员

    • 在局部位置,可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能

    class Outer {
    	private int num  = 10;
    	
    	public void method() {
    		class Inner {
    			public void show() {
    				System.out.println(num);
    			}
    		}
            // 创建内部类对象
    		Inner i = new Inner();
    		i.show();
    	}
    }
    
    class InnerClassDemo4 {
    	public static void main(String[] args) {
            // 创建外部类对象,调用method()方法
    		Outer o = new Outer();
    		o.method();
    	}
    }
    

    思考

    局部内部类如何访问局部变量?

    class Outer {
    	private int num  = 10;
    	
    	public void method() {
    		final int num = 20;
    		class Inner {
    			public void show() {
                    // 从内部类中访问本地变量num; 需要被声明为最终类型
    				System.out.println(num);
    			}
    		}
    		Inner i = new Inner();
    		i.show();
    	}
    }
    
    class InnerClassDemo5 {
    	public static void main(String[] args) {
    		Outer o = new Outer();
    		o.method();
    	}
    }
    

    局部内部类访问局部变量必须用final修饰

    • 局部变量是随着方法的调用而调用,随着调用完毕而消失。
    • 而堆内存的内容并不会立即消失。所以,我们加final修饰。
    • 加入final修饰后,这个变量就成了常量。既然是常量。你消失了。
    • 在内存中存储的是数据20,所以,我还是有数据在使用。

    匿名内部类

    匿名内部类可以使你的代码更加简洁,你可以在定义一个类的同时对其进行实例化。它与局部类很相似,不同的是它没有类名,如果某个局部类你只需要用一次,那么你就可以使用匿名内部类

    前提

    存在一个类或者接口
    这里的类可以是具体类也可以是抽象类。

    格式

        new 类名或者接口名(){
            重写方法;
        }
    

    本质

    是一个继承了该类或者实现了该接口的子类匿名对象。

    interface Inter {
    	public abstract void show();
    }
    
    class Outer {
    	public void method() {
            // new 类名或者接口名(){}
    		new Inter() {
                // 重写方法
    			public void show() {
    				System.out.println("show");
    			}
    		};
    	}
    }
    

    调用

    因此既然new Inter(){};这一坨是一个对象,那么对象调用show()方法还不简单?

    // 接口
    interface Inter {
    	public abstract void show();
    }
    
    class Outer {
    	public void method() {
            // new 类名或者接口名(){}
    		new Inter() {
                // 重写方法
    			public void show() {
    				System.out.println("show");
    			}
    		}.show();
    	}
    }
    
    class InnerClassDemo {
    	public static void main(String[] args) {
    		Outer o = new Outer();
    		o.method();
    	}
    }
    

    如果Inter接口有两个方法,那如何调用?

    interface Inter {
    	public abstract void show();
    	public abstract void show2();
    }
    
    class Outer {
    	public void method() {
    
    		
    		//二个方法的时候
            // 编译看左边,运行看右边
    		Inter i = new Inter() { //多态
    			public void show() {
    				System.out.println("show");
    			}
    			
    			public void show2() {
    				System.out.println("show2");
    			}
    		};
    		
    		i.show();
    		i.show2();
    	}
    }
    
    class InnerClassDemo {
    	public static void main(String[] args) {
    		Outer o = new Outer();
    		o.method();
    	}
    }
    

    思考

    如何使用PersonDemo调用study()方法?

    interface Person {
    	public abstract void study();
    }
    
    class PersonDemo {
    	//接口名作为形式参数
    	//其实这里需要的不是接口,而是该接口的实现类的对象
    	public void method(Person p) {
    		p.study();
    	}
    }
    

    看到此,一般会想到使用具体类来实现接口,在实现类中重写study()方法即可

    //实现类
    class Student implements Person {
    	public void study() {
    		System.out.println("好好学习,天天向上");
    	}
    }
    
    class InnerClassTest {
    	public static void main(String[] args) {
    		//测试
    		PersonDemo pd = new PersonDemo();
    		Person p = new Student();
    		pd.method(p);
    	}
    }
    

    这种方然固然可行,那么采用匿名内部类的方式来实现:

    class InnerClassTest {
    	public static void main(String[] args) {
    		// 测试
    		PersonDemo pd = new PersonDemo();
            // 匿名内部类的本质是继承类或者实现了接口的子类匿名对象
    		pd.method(new Person(){
    			public void study() {
    				System.out.println("好好学习,天天向上");
    			}
    		});
    	}
    }
    

    这种方式占内存较少,占用内存即可及时回收,一般在Android中使用的比较多,因为只使用一次,匿名回收,使用结束即回收

    思考

    按照要求,补齐代码
        interface Inter { 
        	void show(); 
    	}
        class Outer { 
            //补齐代码 
        }
        class OuterDemo {
            public static void main(String[] args) {
                  Outer.method().show();
              }
        }
        要求在控制台输出”HelloWorld”
    

    1. 首先从Outer.method()直接通过类名访问方法,可以判断出是一个静态方法
    2. Outer.method().show()后面还跟着调用show()方法,即可知道Outer.method()返回值是一个对象,对象为Inter
        interface Inter { 
        	void show(); 
    	}
        class Outer { 
            // 返回对象为Inter的静态方法
            public static Inter method(){
                // 返回接口对象
                return new Inter(){
                    public void show(){
                        System.out.println("HelloWorld");
                    }
                }
            }
        }
        class OuterDemo {
            public static void main(String[] args) {
                  Outer.method().show();
              }
        }
    

    你学废了吗?

    展开全文
  • 16.学内部类累不累?

    2021-05-07 00:49:32
    抽象类 抽象类无法直接创建对象,只能被子类继承后,可以...父类中抽象方法定义时可以有方法体,子类必须重写父类的抽象方法 父类 // 抽象方法 public abstract void info(); 子类 @Override public void inf

    内部类

    内部类具有更好的封装手段,可以将其隐藏在外部类之内,更好的实现了信息隐藏,不允许其他类随意的访问

    分类

    • 成员内部类
    • 静态内部类
    • 方法内部类
    • 匿名内部类

    成员内部类

    成员内部类是最常见的,也称为普通内部类

    • 内部类,在外部使用时,无法直接实例化,需要借由外部类信息才能完成实例化
    • 内部类的访问修饰符可以任意,但是访问范围会受到影响
    • 内部类可以直接访问外部类的成员;如果出现同名属性,优先访问内部类中定义的
    • 可以使用外部类.this.成员的方式,访问外部类中同名的信息
    • 外部类访问内部类信息,需要通过内部类实例,无法直接访问
    • 内部类编译后,class文件命名:外部类$内部类.class
    public class Person {
    	public int age = 18;
    	public Heart getHeart() {
    		return new Heart();
    	}
    	public void eat() {
    		System.out.println("吃");
    	}
    	class Heart{
    		int age = 12;
    		public String beat() {
    			eat();
    			// 此处age,会有优先访问内部类中定义的
    			return age + "岁的心扑通扑通的跳," + getPersonAge() + "的心在燃烧";
    		}
    		public int getPersonAge() {
    			// 通过外部类.this.成员的方式访问的Person内的成员变量
    			return Person.this.age; 
    		}
    	}
    }
    
    
    		Person p = new Person();
    		p.age  = 20;
    		
    		// 方式一
    		Person.Heart heart  = new Person().new Heart();
    		System.out.println(heart.beat());
    		
    		// 方式二
    		heart = p.new Heart();
    		System.out.println(heart.beat());
    		// 方式三
    		System.out.println(p.getHeart().beat());
    
    

    打印输出

    吃
    12岁的心扑通扑通的跳,18的心在燃烧
    吃
    12岁的心扑通扑通的跳,20的心在燃烧
    吃
    12岁的心扑通扑通的跳,20的心在燃烧
    
    

    静态内部类

    静态内部类是内部类中一个比较特殊的情况,Java文档中是这样描述static内部类的:一旦内部类使用static修饰,那么此时这个内部类就升级为顶级类。

    • 静态内部类中,只能直接访问外部类的静态成员,如果需要调用非静态成员,可以通过对象实例调用
    • 静态内部类对象实例时,可以不依赖外部类对象
    • 可以通过外部类.内部类.静态成员的方式,访问内部类的静态成员
    • 内部类可以直接访问外部类的成员;如果出现同名属性,优先访问内部类中定义的
    • 如果需要访问外部类中的静态成员,可以使用外部类.成员的方式,访问外部类中同名的信息
    • 如果是访问非静态成员,则可以使用new 外部类().成员的方式
    public class Person {
    	public int age = 18;
    	static String sex = "男";
    	public Heart getHeart() {
    		return new Heart();
    	}
    	public void eat() {
    		System.out.println("吃");
    	}
    	static class Heart{
    		int age = 12;
    		public String beat() {
    			new Person().eat();
    			return age + "岁的"+ getPersonSex() +"生心扑通扑通的跳," + getPersonAge() + "的心在燃烧";
    		}
    		public static void say() {
    			System.out.println("hello");
    		}
    		public int getPersonAge() {
    			// 访问非静态属性使用new 外部类().属性
    			return new Person().age; 
    		}
    		public String getPersonSex() {
    	 		// 访问静态属性用外部类.属性
    			return Person.sex; 
    		}
    
    
    	}
    }
    
    
    		// 静态内部类对象实例时,可以不依赖外部类对象
    		Person.Heart heart  = new Person. Heart();
    		System.out.println(heart.beat());
    		// 可以通过外部类.内部类.静态成员的方式,访问内部类的静态成员
    		Person.Heart.say();
    

    方法内部类

    定义在外部类方法中的内部类,也成局部内部类

    • 方法内定义的局部变量只能在方法内使用
    • 方法内不能定义静态成员
    • class前面不可添加publicprivateprotectedstatic
    • 类中可以包含finalabstract修饰成员
    
    public class Person {
    	public int age = 18;
    	// 方法内部类
    	public Object getHeart() {
    		class Heart{
    			int age = 12;
    			public String beat() {
    				return age + "岁的生心扑通扑通的跳," + getPersonAge() + "的心在燃烧";
    			}
    			public  void say() {
    				System.out.println("hello");
    			}
    			public int getPersonAge() {
    				return new Person().age; 
    			}
    		}
    		return new Heart().beat();
    	}
    	public void eat() {
    		System.out.println("吃");
    	}
    
    }
    
    

    匿名内部类

    将类的定义与类的创建一起完成,可用于简化对于抽象类和接口实现的操作,既然是匿名类,所以无法在别的地方使用这个类(实例化,调用它的静态方法之类的)而且使用频率只能使用一次

    特点

    • 因此对内存的损耗下相对较小
    • 匿名内部类没有类型名称、实例对象名称
    • 编译后的文件命名:外部类$数字序号.class
    • 无法使用访问修饰符privatepublicprotectedabstractstatic修饰
    • 无法编写构造方法,可以使用构造代码块
    • 不能创建静态成员
    • 匿名内部类可以实现接口也可以继承父类,但不可兼得

    Person

    
    public abstract class Person {
    	private String name;
    	public Person() {}
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    	public abstract void read();
    }
    

    匿名内部类

    		// 匿名内部类
    		new Person() {
    			
    			{
    				// 构造代码块
    			}
    			@Override
    			public void read() {
    				// TODO Auto-generated method stub
    				System.out.println("看武侠");
    			}
    		}.read();
    

    适用场景

    • 只用到类的一个实例
    • 类在定义后马上用到
    • 给类命名并不会导致代码更容易被解释
    展开全文
  • 匿名内部类,没有类的名称,必须借助接口或者父类 like = new ILike(){ @Override public void lambda() { System.out.println("5.匿名内部类"); } }; like.lambda(); //6.用lambda简化 like = ()->{ System.out....
  • 内部类分为:成员内部类、静态内部类、局部内部类、匿名内部类(也是局部内部类一种) 一.成员内部类 成员内部类和成员属性和成员方法是同级别的。例如: public class Outer { private String name; public void ...
  • 匿名函数

    2019-08-26 21:23:35
    1.匿名函数 ​ lambda 关键字 ​ x: 形参 (可以写,可以写多个 位置参数,默认参数,动态) ​ :x 返回值(必须写,只能返回一种数据类型,想要返回多个就用容器返回) 三种调用方式: (lambda x:x)(5) [lambda x:x][0]...
  • 匿名对象与非匿名对象的区别

    千次阅读 2013-11-06 07:42:16
    类封装完以后就可以通过使用new关键字和类的构造方法来创建对象,这种对象分为两种:匿名对象与非匿名对象。何为匿名对象,何为非匿名对象呢?举个例子:假如有如下类:  package com.heima.vo;  public class ...
  • 匿名内部类

    2015-11-22 17:57:42
    1、什么是匿名内部类?  定义:匿名内部类就是没有名字的内部类,更准确一点,是匿名的局部内部类。  匿名内部类出现的前提:必须存在一个类,抽象类,或者接口,来让匿名内部类继承或实现。  匿名内部类的...
  • 匿名管道

    2012-09-28 09:59:04
    不知你是否用过这样的程序,他们本身并没有解压缩的功能,而是调用DOS程序PKZIP完成ZIP包的解压缩。...现在就来讨论一下,如何用匿名管道技术实现这个功能。  管道技术由来已久,相信不少人对DOS命令里的
  • 匿名对象类

    2018-10-23 17:31:53
    PS本片博客写自2018.10.23,今天天气不错是个写博客的好时间 ...当我们需要调用一些接口方法或抽象类而这些东西没有子类对象,我们可以通过创建匿名内部类的方法去创建一个子类对象并可以在内部类中重写接口或抽...
  • JavaScript 匿名函数和闭包   匿名函数就是没有名字的函数,闭包是可访问一个函数作用域里变量的函数。声明:本节内容需要有面向对象和少量设计模式基础,否则无法听懂 .(所需基础 15 章的时候已经声明过了)。 ...
  • Java中的匿名内部类

    2020-04-14 22:54:37
    一、匿名内部类 匿名内部类:没有名字的内部的类。 前提:接口或继承父类。...A a = new A(){//从此处开始,就是匿名的呢不累 public void test(); };//到此处结束 a.test(); 一般匿名内部类适合:使用一次,创...
  • 匿名

    2009-01-04 15:47:00
    //父类 class Parent {  public Parent(){  String name="parent";  System.out.println("super");...parent的子类,由于它没有类名所以称匿名类,它无构造方法(连类名都没有所以也无法写构造方法)
  • 匿名函数最早是LISP语言引入,后面发展为不仅是函数式语言所特有,在解释型语言和编译型语言中也越来越多匿名函数的身影,...其实在 Js 中匿名函数、闭包、自执行函数、回调函数、箭头函数,这些概念似乎相同,却又
  • 2014-03-31 17:26:43
    兴师动众,很,太了,而且晚上似乎有些睡着觉的感觉.我想假如将来我有了小孩子,他的婚事我就让他自己做主,不用这么麻烦,喜欢旅行结婚也可以,不用受累,也不用得罪人.得罪人的事情就如陈经理说,无论你怎么做,总会...
  • 了解项目,但既支持,也反对 支持型。了解项目及其潜在影响,并且会支持项目工作以及成功 领导型。了解项目及其潜在影响,而且积极参与以确保项目取得成功。 习题 一名新项目经理被任命管理一个正在执行的...
  • 6.1 匿名内部类实现方法 不是很懂,看书去了。。。。。。。。。。。。。。。。         -------------------------总结--------------------------  ImageView,src,background; Button,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,175
精华内容 2,870
关键字:

匿名累不累