java-内部类/匿名类/Lambda表达式
-
-
我们把一个类放在另一个类的内部定义，称为内部类(inner class)。
/*
内部类访问特点：
内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象
*/
public class Outer {
private int num = 10;
public class Inner {
public void show() {
System.out.println(num);
}
}
public void method() {
Inner i = new Inner();
i.show();
}注意
内部类只是一个编译时概念，一旦我们编译成功，就会成为完全不同的两个类。对于一个名为 Outer 的外部类和其内部定义的名为 Inner 的内部类。编译完成后会出现 Outer.class和 Outer$Inner.class 两个类的字节码文件。所以内部类是相对独立的一种存在，其成员变量 / 方法名 可以和 外部类 的相同。
-
内部类可以直接访问外部类的成员，包括私有
-
内部类的分类
成员内部类（理解）
-
成员内部类的定义位置
-
在类中方法，跟成员变量是一个位置
-
-
外界创建成员内部类格式
-
格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
-
举例：Outer.Inner oi = new Outer().new Inner();
-
-
私有成员内部类
-
将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。
-
非静态内部类
非静态内部类（外部类里使用非静态内部类和平时使用其他类没什么不同）
1. 非静态内部类对象必须寄存在一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
2. 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。
3. 非静态内部类不能有静态方法、静态属性和静态初始化块。
4. 成员变量访问要点：
1. 内部类属性：this.变量名。
2. 外部类属性：外部类名.this.变量名。
内部类的访问：
1. 外部类中定义内部类：new Inner()。
2. 外部类以外的地方使用非静态内部类：
Outer.Inner varname = new Outer().new Inner()。
Outer sw = new Outer();
// 通过method方法调用内部类方法，到达调用内部类
sw.method();
// 访问内部类的格式
Outer.Inner inc = new Outer().new Inner();
inc.show();静态内部类
static class ClassName {
//类体
}
使用要点：
1. 静态内部类可以访问外部类的静态成员，不能访问外部类的普通成员。
2. 静态内部类看做外部类的一个静态成员。
package static_innerclass;
class Outer2 {
private static int b = 20;
private int a = 10;
//相当于外部类的一个静态成员
static class Inner2 {
public void test() {
// System.out.println(a); //静态内部类不能访问外部类的普通属性
System.out.println(b); //静态内部类可以访问外部类的静态属性
}
}
}
public class static_inner {
public static void main(String[] args) {
//通过 new 外部类名.内部类名() 来创建内部类对象
Outer2.Inner2 inner = new Outer2.Inner2();
inner.test();
}
}-
-
存在一个类或者接口，这里的类可以是具体类也可以是抽象类
- 匿名内部类没有访问修饰符。
-
-
- 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。
-
匿名内部类的格式
-
-
-
本质：是一个继承了该类或者实现了该接口的子类匿名对象
-
-
匿名内部类的细节
-
package anonymity_class;
//定义一个接口，里面有个show方法
interface Inter {
void show();
}
interface Inter2 {
void show1();
void show2();
}
//实现类：创建接口的实现类对象使用
class InterImpl implements Inter {
//重写接口里面的方法
@Override
public void show() {
System.out.println("InterImpl 重写的show方法");
}
}
public class anonymity {
/*
1. 创建实现类, 通过implements关键字去实现接口
2. 重写方法
3. 创建实现类对象
4. 调用重写后的方法.
匿名内部类:
前提: 需要存在类\接口
格式:
new 类名 \ 接口名 (){
重写方法
}
*/
public static void main(String[] args) {
InterImpl ii = new InterImpl();
ii.show();
// 匿名内部类的理解: 将继承\实现, 方法重写, 创建对象, 放在了一步进行.
// 解释: 实现了Inter接口的, 一个实现类对象.
new Inter() {
@Override
public void show() {
System.out.println("我是匿名内部类中的show方法");
}
}.show(); // .show() 直接调用内部类的show方法
// 情况: 接口中存在多个方法
// 实例化接口实现类 打个花括号在里面重写方法
Inter2 i = new Inter2() {
@Override
public void show1() {
System.out.println("show1...");
}
@Override
public void show2() {
System.out.println("show2...");
}
};
//调用内部类的方法
i.show1();
i.show2();
}
}当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
-
使用Lambda必须要有接口
-
并且要求接口中有且仅有一个抽象方法
Lambda表达式和匿名内部类的区别
-
所需类型不同
-
匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
-
Lambda表达式：只能是接口
-
-
使用限制不同
-
如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
-
如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
-
-
实现原理不同
-
匿名内部类：编译之后，产生一个单独的.class字节码文件
-
-
组成Lambda表达式的三要素：
形式参数，箭头，代码块
格式： (形式参数) -> {代码块}
形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可 ->：由英文中画线和大于符号组成，固定写法。代表指向动作
代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
匿名内部类的格式是 new 类名/接口名(){ // 重写方法 }
抽象方法带参无返回值的Lambda写法
Lambda表达式的简化写法
省略规则
参数类型可以省略。但是 有多个参数 的情况下，不能只省略一个
如果参数有且仅有一个，那么 小括号 可以省略
如果代码块的语句只有一条，可以省略大括号，分号，return
package LambdaDemo;
/*
游泳接口
*/
interface Swimming {
void swim();
}
public class Swimmingdemo {
public static void main(String[] args) {
// 通过匿名内部类实现
goSwimming(new Swimming() {
@Override
public void swim() {
System.out.println("铁汁, 我们去游泳吧");
}
});
/* 通过Lambda表达式实现
理解: 对于Lambda表达式, 对匿名内部类进行了优化
省略了类型名，没传入参数则小括号没有省略，由于这里代码只有一句，省略了大括号、分号、return
*/
goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
}
/*
* 使用接口的方法
*/
public static void goSwimming(Swimming swimming) {
swimming.swim();
}
}-
-
有一个接口
-
接口中有且仅有一个抽象方法
-
-
练习描述
无参无返回值抽象方法的练习
-
操作步骤
-
定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
-
定义一个测试类(EatableDemo)，在测试类中提供两个方法
-
一个方法是：useEatable(Eatable e)
-
-
-
package LambdaDmeo2;
//接口
interface Eatable {
void eat();
}
//实现类
class EatableImpl implements Eatable {
@Override
public void eat() {
System.out.println("一天一苹果，医生远离我，实现类调用");
}
}
//测试类
public class EatableDemo {
public static void main(String[] args) {
//在主方法中调用useEatable方法
Eatable e = new EatableImpl();
useEatable(e);
//匿名内部类
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("一天一苹果，医生远离我，匿名类调用");
}
});
//Lambda表达式，
useEatable(() -> {
System.out.println("一天一苹果，医生远离我，Lambda表达式调用");
});
}
//定义了一个函数，形式参数为一个接口，接口不能实例化所以就会用到匿名类、Lambda表达式了
private static void useEatable(Eatable e) {
e.eat();
}
}
本文来自博客园，作者：link-零，转载请注明原文链接：https://www.cnblogs.com/e-link/p/16754808.html❤❤❤
