Java学习笔记day13-内部类-Lambda表达式
Day13
内部类
概述：
-
内部类：就是在一个类中定义一个类。例如：在一个A类的内部定义一个B类，B类就被称为内部类；
-
创建格式：外部类名.内部类名 对象名 = new 外部类对象().new 内部类对象();
内部类的访问特点
- 内部类可以直接访问外部类的成员，包括私有；
- 外部类要访问内部类的成员，必须创建对象；
按照内部类在类中的定义位置不同，可分为如下两种：
- 在类的成员位置：成员内部类；
- 在类的局部位置：局部内部类；
成员内部类
成员内部类也属于成员，既然是成员就可以被一些修饰符所修饰
- private
- 私有成员内部类访问：在自己所在的外部类中创建对象访问。
- static
- 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
- 静态成员内部类中的静态方法：外部类名.内部类名.方法名();
局部内部类
局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用，该类可以直接访问外部类的成员，也可以访问方法内部的局部变量。
package neibulei;
public class InClassTest {
public static void main(String[] args) {
Out o = new Out();
o.method();
}
}
class Out{
int a = 10;
public void method(){
int b = 20;
class Inner{
public void show(){
System.out.println(a);
System.out.println(b);
System.out.println("show...");
}
}
//通过对象调用show方法
Inner i = new Inner();
i.show();
}
}
运行结果：
注意(在内部类的方法中调用外部类、内部类及内部类方法中的变量)
请问下面横线处分别填写什么代码，才能实现打印出注释的结果
class Outside{
private int a = 100;
class Inside{
private int a = 200;
public void show(){
int a = 300;
System.out.println(_Outside.this.a_);//100
System.out.println(_Inside.this.a_);//200
Ssytem.out.println(_a_);//300
}
}
}
匿名内部类
- 概述：匿名内部类本质上是一个特殊的局部内部类（定义在方法内部）
- 前提：需要存在一个接口或类
格式：
new 类名或接口名(){
重写方法;
}
范例：
new Inter(){
public void show(){
}
}
- 理解：匿名内部类是将(继承\实现)(方法重写)(创建对象)三个步骤，放在了一步进行；
匿名内部类的使用场景
当方法的形式参数是接口或者抽象类时，可以将匿名内部类作为实际参数进行传递。
package neibulei;
public class NiMing {
public static void main(String[] args) {
//将匿名内部类作为实际参数进行传递
useGanNailuo(new GanNailuo() {
@Override
public void xineilalaku() {
System.out.println("xineilalaku!");
}
});
}
//定义一个方法，以接口为形式参数，方法内调用了接口的抽象方法
public static void useGanNailuo(GanNailuo ganNailuo){
ganNailuo.xineilalaku();
}
}
//定义一个接口
interface GanNailuo{
public abstract void xineilalaku();
}
Lambda表达式
函数式编程思想概述
- 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”
- 面向对象思想强调“必须通过对象的形式来做事情”
- 函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”
Lambda表达式的标准格式
- 格式：(形式参数)->{代码块}
- 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数留空即可
- ->：由英文中画线和大于符号组成，固定写法。代表指向动作
- 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
Lambda表达式的使用前提
- 有一个接口
- 接口中有且仅有一个抽象方法
案例1(无参数无返回值)：
- 编写一个接口(ShowHandler)
- 在该接口中存在一个抽象方法(show)，该方法是无参数无返回值
- 在测试类(ShowHandlerDemo)中存在一个方法(useShowHandler)，方法的参数是ShowHandler类型的，在方法内部调用了ShowHandler的show方法
package Lambda;
public class TestLambda {
public static void main(String[] args) {
useShowHandler(new ShowHandler() {
@Override
public void show() {
System.out.println("我是匿名内部类中的show方法");
}
});
//Lambda实现
useShowHandler(()->{
System.out.println("我是Lambda中的show方法");
});
}
public static void useShowHandler(ShowHandler showHandler){
showHandler.show();
}
}
interface ShowHandler{
void show();
}
运行结果：
案例2(带参数无返回值)
- 首先存在一个接口(StringHandler)
- 在该接口中存在一个抽象方法(printMessage)，该方法是有参数无返回值
- 在测试类(StringHandlerDemo)中存在一个方法(useStringHandler)，方法的参数是StringHAndler类型的，在方法内部调用了StringHandler的printMessage方法
package Lambda;
public class StringHandlerDemo {
public static void main(String[] args) {
useStringHandler(new StringHandler() {
@Override
public void printMessage(String msg) {
System.out.println("我是匿名内部类"+msg);
}
});
//lambda实现
useStringHandler((String msg) -> {
System.out.println("我是Lambda表达式"+msg);
});
}
public static void useStringHandler(StringHandler stringHandler){
stringHandler.printMessage("lambda练习");
}
}
interface StringHandler{
void printMessage(String msg);
}
运行结果：
案例3(无参数有返回值)
- 首先存在一个接口(RandomNumHandler)
- 在该接口中存在一个抽象方法(getNumber)，该方法是无参数但是有返回值
- 在测试类(RandomNumHandlerDemo)中存在一个方法(useRandomNumHandler),方法的参数是RandomNumHandler类型的，在方法内部调用了RandomNumHandler的getNumber方法
package Lambda;
import java.util.Random;
public class RandomNumHandlerDemo {
public static void main(String[] args) {
useRandomNumHandler(new RandomNumHandler() {
@Override
public int getNumber() {
Random r = new Random();
int a = r.nextInt(100)+1;
return a;
}
});
//Lambda实现
useRandomNumHandler(()->{
Random r = new Random();
int a = r.nextInt(10)+1;
return a;
});
}
public static void useRandomNumHandler(RandomNumHandler randomNumHandler){
int result = randomNumHandler.getNumber();
System.out.println(result);
}
}
interface RandomNumHandler{
int getNumber();
}
运行结果：两个随机数
案例4(有参数有返回值)
-
首先存在一个接口(Calculator)
-
在该接口中存在一个抽象方法(calc)，该方法是有参数也有返回值
-
在测试类(CalculatorDemo)中存在一个方法(useCalculator)，方法的参数是Calculator类型的，在方法内部调用了Calculator的calc方法
package Lambda;
public class CalculatorDemo {
public static void main(String[] args) {
useCalculator(new Calculator() {
@Override
public int calc(int a, int b) {
return a+b;
}
});
//Lambda实现
useCalculator((int a,int b)->{
return a+b;
});
}
public static void useCalculator(Calculator calculator){
int result = calculator.calc(27,68);
System.out.println(result);
}
}
interface Calculator{
int calc(int a,int b);
}
运行结果：
95
95
Lambda的省略模式
省略规则：
- 参数类型可以省略，但是有多个参数的情况下，不能只省略一个
- 如果参数有且仅有一个，那么小括号可以省略
- 如果代码块的语句只有一条，可以省略大括号和分号，甚至是return
Lambda表达式和匿名内部类的区别
所需类型不同
- 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
- Lambda表达式：只能是接口
使用限制不同
- 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
- 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
实现原理不同
- 匿名内部类：编译之后，产生一个单独的.class字节码文件
- Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成
练习1
给定一个计算器Calculator接口，内含抽象方法calc (减法)，其功能是可以将两个数字进行相减，并返回差值;
请分别使用Lambda的标准格式及省略格式调用 invokeCalc 方法，完成130和120的相减计算并输出计算结果;
public interface Calculator {
int calc(int a, int b);
}
public class Test10InvokeCalc {
public static void main(String[] args) {
//请分别使用Lambda【标准格式】及【省略格式】调用invokeCalc方法来计算130-120的结果
invokeCalc(130,120,(int a,int b)->{
return a-b;
});
invokeCalc(130,120,(a,b)->a-b);
}
private static void invokeCalc(int a, int b, Calculator calculator) {
int result = calculator.calc(a, b);
System.out.println("结果是：" + result);
}
}