java笔记：lambda和异常

最新推荐文章于 2023-09-13 17:25:07 发布
最新推荐文章于 2023-09-13 17:25:07 发布
阅读量523 收藏
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46144237/article/details/108358977
版权

lambda和异常

(一) Lambda

引入Lambda

1.用匿名内部类实现
我们都知道，每个java文件必须有一个与这个java文件同名的外部类，这个外部类可以是public或default的。而除了这个同名外部类，还可以有与这个同名外部类平级的其他外部类，但它们必须是default的。
而内部类是指在外部类的内部再定义一个类。
在这里插入图片描述

package work1;
//定义动物类接口
interface Animal {
	void shout();
}
public class Example21 {
	public static void main(String[] args) {
		String name = "小花";
		// 定义匿名内部类作为参数传递给animalShout()方法
		animalShout(new Animal() {
			// 实现shout()方法
			public void shout() {
				// JDK 8开始，局部内部类、匿名内部类可以访问非final的局部变量
				System.out.println(name + "喵喵...");
			}
		});
	}
	// 定义静态方法animalShout()，接收接口类型参数
	public static void animalShout(Animal an) {
		an.shout(); // 调用传入对象an的shout()方法
	}
}

Lambda表达式实现

package work2;
//定义动物类接口
interface Animal {
	void shout(); // 定义方法shout()
}
public class Example22 {
	public static void main(String[] args) {
		String name = "小花";
		// 1、匿名内部类作为参数传递给animalShout()方法
		animalShout(new Animal() {
			public void shout() {
				System.out.println("匿名内部类输出：" + name + "喵喵...");
			}
		});
		// 2、使用Lambda表达式作为参数传递给animalShout()方法
		animalShout(() -> System.out.println("Lambda表达式输出：" + name + "喵喵..."));
	}
	// 创建一个animalShout()静态方法，接收接口类型的参数
	public static void animalShout(Animal an) {
		an.shout();
	}
}

2、用Lambda表达式实现接口中两个函数的调用测试。

package week15;
//定义无参、无返回值的函数式接口
@FunctionalInterface
interface Animal {
	void shout();
}
//定义有参、有返回值的函数式接口
interface Calculate {
	int sum(int a, int b);
}
public class Example23 {
	public static void main(String[] args) {
	   // 分别两个函数式接口进行测试
	   animalShout(() -> System.out.println("无参、无返回值的函数式接口调用"));
	   showSum(10, 20, (x, y) -> x + y);
	}
	// 创建一个动物叫的方法，并传入接口对象Animal作为参数
	private static void animalShout(Animal animal) {
		animal.shout();
	}
	// 创建一个求和的方法，并传入两个int类型以及接口Calculate类型的参数
	private static void showSum(int x, int y, Calculate calculate) {
		System.out.println(x + "+" + y + "的和为：" + calculate.sum(x, y));
	}
}

3、验证下列程序，掌握其方法。

package week15;
//定义一个函数式接口
@FunctionalInterface
interface Calcable {
	int calc(int num);
}
//定义一个类，并在类中定义一个静态方法
class Math {
	// 定义一个求绝对值方法
	public static int abs(int num) {
		if (num < 0) {
			return -num;
		} else {
			return num;
		}
	}
}
//定义测试类
public class Example24 {
	private static void printAbs(int num, Calcable 

calcable) {
		System.out.println(calcable.calc(num));
	}
	public static void main(String[] args) {
		// 使用Lambda表达式方式
		printAbs(-10, n -> Math.abs(n));
		// 使用方法引用的方式
		printAbs(-10, Math::abs);
	}
}

4、验证下列程序，掌握其方法。

package week15;
//定义一个函数式接口
@FunctionalInterface
interface Printable{
	void print(String str);
}
class StringUtils {
	public void printUpperCase(String str) {
		System.out.println(str.toUpperCase());
	}
}
//定义测试类
public class Example25 {
	private static void printUpper(String text, Printable pt) {
		pt.print(text); 
	}
	public static void main(String[] args) {
		StringUtils stu = new StringUtils();
		// 使用Lambda表达式方式
		printUpper("Hello", t -> stu.printUpperCase(t));
		// 使用方法引用的方式
		printUpper("Hello", stu::printUpperCase);
	}
}

5、验证下列程序，掌握其方法。

package week15;
//定义一个函数式接口
@FunctionalInterface
interface PersonBuilder {
	Person buildPerson(String name);
}
//定义一个Person类，并添加有参构造方法
class Person {
	private String name;
	public Person(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}
//定义测试类
public class Example26 {
	public static void printName(String name, PersonBuilder builder) {
		System.out.println(builder.buildPerson(name).getName());
	}
	public static void main(String[] args) {
		// 使用Lambda表达式方式
		printName("夏侯惇", name -> new Person(name));
		// 使用构造器引用的方式
		printName("夏侯惇", Person::new);
	}
}

6、验证下列程序，掌握其方法。

package week15;
//定义一个函数式接口
@FunctionalInterface
interface Printable{
	void print(StringUtils su, String str);
}
class StringUtils {
	public void printUpperCase(String str) {
		System.out.println(str.toUpperCase());
	}
}
//定义测试类
public class Example27 {
	private static void printUpper(StringUtils su, String text, 
								Printable pt) {
		pt.print(su, text); 
	}
	public static void main(String[] args) {
		// 使用Lambda表达式方式
		printUpper(new StringUtils(), "Hello",
                                  (object, t) -> object.printUpperCase(t));
		// 使用方法引用的方式
	  printUpper(new StringUtils(), "Hello",
                                  StringUtils::printUpperCase);
	}
}

（二）异常

7、异常的基础练习1，回答能否将几个catch语句交换位置，并回答为什么。
基本结构一 基本机构二

class Exce{
	public int div(int a,int b) throws Exception{
//		try{
			return a/b;
//		}catch(Exception e){
//			e.printStackTrace();
//			System.out.println(e.getMessage());
//			return 0;
//		}
//		return a/b;
	}
}
class MyException03 {
	
	 /**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		Exce exce01=new Exce();
		try{
			exce01.div(100,0);
		}
		catch(ArithmeticException e){
			System.out.println("出现异常");
			e.printStackTrace();
			System.out.println(e.getMessage());
			System.out.println(e.toString());
		}catch(Exception e){
			System.out.println("出现异常");
		}
		
//		exce01.div(100,0);
		System.out.println("出现异常");

	}

}
	public class ExDemo2 {
	static void calculate() throws IllegalAccessException{
		int c[]={1,2};
		c[1]=60;
		int a=100;
		System.out.println("a="+a);
		int b=50/a;    
		throw new IllegalAccessException();
	}
	public static void main(String args[]){
		try	{
			calculate();
		}
		catch(IllegalAccessException e){
			System.out.println("非法存取:"+e);
		}
		catch(ArrayIndexOutOfBoundsException e){
			System.out.println("数组越界:"+e);
		} 
		catch(ArithmeticException e){
			System.out.println("被0整除:"+e);
		}
		finally{
			System.out.println("最后执行的语句!");
		}
	}
}

8、异常基础练习2，回答为什么“t没有机会赋值”，并回答为什么。

public class Exception01 {

	/**
	 * @param args
	 */
	public static void main(String args[ ]) {
	      int n=0,m=0,t=6666;
	      try{  m=Integer.parseInt("8888");
	            n=Integer.parseInt("ab85"); //发生异常,转向catch
	            t=9999;  //t没有机会赋值
	      }
	      catch(NumberFormatException e) {
	            System.out.println("发生异常:"+e.getMessage());
	            n=123;
	      }
	      System.out.println("n="+n+",m="+m+",t="+t);
	    }

}

9、finally语句结构；

public class Exception2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		try {
			int x = args.length, y = 222, z;
			z = y / x;
			System.out.println("x除以y的值是：" + z);
		} catch (ArithmeticException e) {
			System.out.println("捕获到了算术异常！" + e);
		} finally {
			System.out.println("现在执行到finally子句了。");
			try {
				String strName = null;
				if (strName.equals("锄禾日当午"))
					System.out.println(strName + "汗滴禾下土");
			} catch (Throwable e) {
				System.out.print("又捕获到一个异常！" + e);
			} finally {
				System.out.print("，又执行到一个finally子句了。");
			}
		}

	}

}

10、Throws语句

public class Exception3 {

	/**
	 * @param args
	 * throws的使用
	 */
	static void ArrayTest(int x) throws ArithmeticException,
			ArrayIndexOutOfBoundsException {
		System.out.print("i=" + x);
		if (x == 111) {
			System.out.println(" ， 此时尚无异常发生！");
			return;
		}
		if (x == 3) {
			int array[] = new int[6];
			array[20] = 200;
		}
	}

	public static void main(String args[]) {
		try {
			ArrayTest(111);
			ArrayTest(3);
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.print("  ， 数组越界异常被捕获:");
			System.out.println(e);
		} catch (ArithmeticException e) {
			System.out.println("算术异常被捕获 " + e);
		} finally {
			System.out.print("执行到了finally子句！");
		}
	}

}

问：ArrayTest(111);ArrayTest(3);两句不用try_catch语句包裹会如何？

11、自定义异常+抛出异常练习。（自定义异常类+throw语句）

class MyException extends Exception {//继承异常类，完成自定义异常类的定义
	private int x;

	MyException(int a) {
		x = a;
	}

	public String toString() {
		return "MyException";
	}
}

public class Exception5 {

	/**
	 * @param args
	 *            本例为自定义异常示例
	 */
	static void method(int a) throws MyException {
		System.out.print("此处引用mathod(" + a + ")");
		if (a > 10)
			throw new MyException(a);
		System.out.println(" ， 正常返回！");
	}

	public static void main(String args[]) {
		try {
			System.out.print("进入监控区，执行此段程序可能发生异常！");
			method(8);
			method(20);
			method(6);
		} catch (MyException e) {
			System.out.print(" ，程序发生异常就在此处处理；");
			System.out.println("所发生的异常是：" + e.toString() + "。");
			System.out.print("在此可以执行其它代码！");
		}
	}

}

12、自定义异常+抛出异常练习。（自定义异常类+throw语句）

import java.util.Scanner;

public class ExceptionExe {
	int score;
	/**
	 * @param args
	 */
	public void setScore(){
		System.out.println("请输入学生的成绩");
		Scanner readScore=new Scanner(System.in);
		score=readScore.nextInt();
	}
	public int getScore(){
		return score;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		ExceptionExe e01=new ExceptionExe();
		
		try{
			e01.setScore();
			if(e01.getScore()<0||e01.getScore()>100){
				System.out.println("输入成绩不合理。");
				throw new ScoreException(e01.getScore());
			}else 
				System.out.printf("学生成绩= %d",e01.getScore());
		}catch(ScoreException e){
			System.out.println("自己定义的\"输入成绩不合理\"的提示。");
		}
	}

}

class ScoreException extends Exception {
	   String message;
	   public ScoreException(int s) {
	       message="成绩"+s+"不合理";
	   }
	   public String toString() {
	       return message;
	   }
	}
Mr顺
关注
专栏目录
java8 lamda throw_Java8中lambda表达式无法抛出受检异常的问题
weixin_36204061的博客
02-26 1136
问题提出昨天写代码的时候遇到了一个需要在Java8流中抛出异常的问题，结果一直编译报错，先看下代码：//编译通过Stream.of("a", "b", "c").forEach(str -> {throw new RuntimeException();});//编译失败Stream.of("a", "b", "c").forEach(str -> {throw new IOExcept...
《Java8实战》笔记（03）：Lambda表达式
KISS
08-14 594
本文源码 Lambda 管中窥豹 可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式：它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。 Lambda表达式可以让你十分简明地传递代码。 Lambda组成结构 参数列表——这里它采用了Comparator中compare方法的参数，两个Apple。 箭头——箭头->把参数列表与Lambda主体分隔开。 Lambda主体——比较两个Apple的重量。表达式就是Lambda的返回值了。 Lambda的基本
JAVA 自定义异常 全局捕获
12-04
自己编写异常类型 ，自定义错误异常进行全局捕捉。实现项目全局的拦截定义输出。。。
lambda 异常 java8_Java8（1）：当 Lambda 遇上受检异常
weixin_28745525的博客
02-16 158
我今天高高兴兴，想写个简单的统计一个项目下有多少行代码的小程序，于是咔咔的写下：long count = Files.walk(Paths.get("D:/Test")) // 获得项目目录下的所有目录及文件.filter(file -> !Files.isDirectory(file)) // 筛选出文件.filter(file ...
Java8新特性 - lambda
Javaer`s blog
11-19 218
1. java8 中的三种编程思想 流处理 行为参数化 并行与共享的可变数据 2. 行为参数化 - 通过参数化传递代码 2.1 行为参数化 一个方法接受多个不同的行为作为参数，并在内部使用它们，完成不同行为的能力 是可以帮助你处理频繁变更的需求的一种软件开发模式 传递代码，就是将新行为作为参数传递给方法，但在Java 8之前这实现起来很啰嗦，现在使用lambda表达式 编写一个prettyPrintApple方法，它接受一个Apple的List，并可以对它参数化，以 多种方式根据苹果生成一个Stri
java受检异常_Java 受检异常与lambda表达式
weixin_42515295的博客
02-21 170
Java 受检异常与lambda表达式，存在一个抛出受检异常的 lambda 表达式，且所实现的函数式接口中的抽象方法并未声明该异常。为 lambda 表达式添加一个 try/catch 代码块，或委托给某个提取的方法进行处理。lambda 表达式实际上属于函数式接口中单一抽象方法的实现，因此只能抛出在抽象方法签名中声明的受检异常。Java 受检异常与lambda表达式 问题描述存在一个抛出受检异...
java8源码-java8:java8笔记和代码示例
06-04
有参数列表，函数主体，返回类型，可抛出异常 传递 可作为参数传递给方法或存储在变量中 简洁 组成 () -> {} 参数列表 可以没有参数 箭头 主体 如果函数主体只有一行，可不用{} 在哪里使用 在函数式接口中使用。函数...
Public-JavaNotes:笔记
03-19
6. **异常处理**：Java提供了异常处理机制，通过`try-catch-finally`语句块来捕获和处理运行时错误，确保程序的健壮性。 7. **集合框架**：Java集合框架是一组接口和类，如List、Set、Map等，它们提供了一种组织和...
Java8新特性详解：Lambda、Optional与日期时间API
"Java8学习笔记包含了Java语言、编译器、库、工具和JVM的新特性，重点讲解了Lambda表达式、函数式接口、接口的默认方法和静态方法、Optional、Streams、Date/Time API、JavaScript引擎Nashorn、Base64、并行数组、...
notebook-java：笔记本java示例
02-15
【标题】"notebook-java：笔记本java示例" 指的是一种将Java编程与交互式计算环境结合的实践方式，通常在数据科学、机器学习和教育领域中广泛应用。"Notebook"在这里可能指的是Jupyter Notebook，这是一个开源的Web...
lambda处理异常四种方式
最新发布
gb4215287的博客
09-13 957
lambda处理异常四种方式
java 8 lambda表达式中的异常处理
V539413949的博客
04-30 4347
简介 java 8中引入了lambda表达式，lambda表达式可以让我们的代码更加简介，业务逻辑更加清晰，但是在lambda表达式中使用的Functional Interface并没有很好的处理异常，因为JDK提供的这些Functional Interface通常都是没有抛出异常的，这意味着需要我们自己手动来处理异常。 因为异常分为Unchecked Exception和checked Exception,我们分别来讨论。 处理Unchecked Exception Unchecked exception
java lambda函数_抛出异常的Java 8 Lambda函数？
weixin_39852647的博客
02-12 402
实际上你可以扩展Consumer(和Function(等等)有一个处理异常的新接口-使用Java 8的默认方法!考虑这个接口(扩展Consumer):@FunctionalInterfacepublicinterfaceThrowingConsumerextendsConsumer{@Overridedefaultvoidaccept(finalTelem){try{acce...
【一看就懂的java学习】高级篇 之 方法引用
qq_38785034的博客
04-26 566
方法引用体验方法引用方法引用符Lambda表达式支持的方法引用引用类方法引用对象的实例方法 体验方法引用 在使用Lambda表达式时，实际传递进去的代码就是一种解决方案：拿参数做操作 如果在Lambda中所指定的操作方案，已经有地方存在相同文案，则没有必要再写重复逻辑 public interface Printable { void printString(String s); } public class PrintableDemo { public static void main
JVM角度看方法调用-MethodHandle篇
yangxiaofei_java的博客
06-05 1159
JVM角度看方法调用系列文章：1.JVM角度看方法调用-开篇2.JVM角度看方法调用-反射篇3.JVM角度看方法调用-MethodHandle篇4.JVM角度看方法调用-性能压测篇（码字…）5.JVM角度看方法调用-Lambda篇（码字…）​ 在我们平时开发中常用的方法调用有三种：直接调用、反射调用、MethodHandle调用，这一系列文章就围绕着三种调用方式进行原理剖析和性能分析，本文JDK的版本是1.8。在上篇文章中我们最后总结由于反射调用的种种缺陷严重影响性能，所以当我们热点代码需要用到反射调用时不
关于lambda表达式中的异常
qq_39632912的博客
01-25 2869
lambda表达式中，如果有异常产生，lambda表达式是不用显示标出的。。。函数式接口要和相应的lambda表达式兼容，函数式接口中如果有产生异常的可能，要显示标出。。。所以，有产生异常可能的lambda表达式，对应的函数式接口，一定要显示标出throws Exception。。。这样函数式接口才能和要赋值的lambda表达式想匹配。。。。。
【黑马程序员】第四章：面向对象（下）
u010975449的专栏
11-25 1209
一、类的继承 1、继承的概念    在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种书屋之间形成一种关系体系。例如猫和狗都属于动物，程序中便描述为猫和狗继承自动物，同理波斯猫和巴厘猫继承自猫
欺骗异常 – Java 8 Lambdas
上善若水 厚德载物
05-21 3257
抛开检查异常和运行时异常的宗教争论，有很多次那些处理检查异常的例子的可怜构造类库就能让你发疯。 考虑下面你可能想要写的一小段代码： ``` public void createTempFileForKey(String key) { Map<String, File> tempFiles = new ConcurrentHashMap<>(); //不编译，因为抛出了IOException
一个参数无返回值的Lambda表达式
心猿问道的博客
10-09 719
package com.company.demo16; interface MyInterface3{ public void method(int num1); } public class Test6 { public static void main(String[] args) { MyInterface3 m3 = (int x)-> System.out.println(x); m3.method(10); //类型省略.
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mr顺

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值