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);
 	}
}

原文链接：https://blog.csdn.net/qq_41615150/article/details/111411111