一.创建不可变集合
package com.wjh.d1_unchange_collection;
/*
目标:不可变集合
*/
import java.util.List;
import java.util.Map;
import java.util.Set;
public class CollectionDemo {
public static void main(String[] args) {
List<Double> list = List.of(595.5, 700.5, 523.0, 570.5);
System.out.println(list);
// list.add(566.5); //报错:不可变集合添加失败
// list.remove(1); //报错:不可变集合删除失败
// list.set(2,596.5); //报错:修改失败
System.out.println(list);
//2.不可变的set集合
//Set<String> set = Set.of("迪丽热巴", "迪丽热九", "马尔扎哈", "马尔扎哈", "卡密尔");
//有重复元素:出现 "duplicate element: 马尔扎哈"的报错异常
Set<String> set = Set.of("迪丽热巴", "迪丽热九", "马尔扎哈", "卡密尔");
//set.add("三少爷的剑"); //报错:不可变集合添加失败
System.out.println(set);
//3.不可变的Map集合
Map<Integer, Integer> map = Map.of(1,45,2,12,3, 45);
//map.put(4,5); //报错:不可变集合添加失败
System.out.println(map); //{3=45, 1=45, 2=12}
}
}
[595.5, 700.5, 523.0, 570.5]
[595.5, 700.5, 523.0, 570.5]
[卡密尔, 马尔扎哈, 迪丽热九, 迪丽热巴]
{3=45, 2=12, 1=45}进程已结束，退出代码为 0
二.Stream流
1.Stream流的概述
package com.wjh.d2_stream;
import java.util.ArrayList;
import java.util.List;
/*
初步体验stream流的方便与快捷
*/
public class StreamTest {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
System.out.println(list); //[张无忌, 周芷若, 赵敏, 张强, 张三丰]
//
// //1.从集合中找出姓张的放到新的集合
// List<String> zhangList = new ArrayList<>();
// for (String s : list) {
// if(s.startsWith("张")){ //startsWith -> 以什么开始
// zhangList.add(s);
// }
// }
// System.out.println(zhangList); //[张无忌, 张强, 张三丰]
//
// //2.找名称长度是3且姓名为:张的姓名
// List<String> zhangList3 = new ArrayList<>();
// for (String s3 : list) {
// if (s3.startsWith("张") && s3.length() == 3){
// zhangList3.add(s3);
// }
// }
// System.out.println(zhangList3); //[张无忌, 张三丰]
//3.使用stream实现的
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
//list.stream() -> 调用stream流 //.filter() -> 过滤
//s代表集合里面的每个元素 //"->"开始过滤
}
}
[张无忌, 周芷若, 赵敏, 张强, 张三丰]
张无忌
张三丰进程已结束，退出代码为 0
2.Stream流的获取
package com.wjh.d2_stream;
import java.util.*;
import java.util.stream.Stream;
public class StreamDemo2 {
public static void main(String[] args) {
/*-------------------------Collection集合获取流------------------------*/
Collection<String> collection = new ArrayList<>();
Stream<String> s = collection.stream();
/*-------------------------Map获取流------------------------*/
Map<String, Integer> maps = new HashMap<>();
//键流
Stream<String> keyStream = maps.keySet().stream();
//值流
Stream<Integer> valueStream = maps.values().stream();
//键值对流(拿整体)
Stream<Map.Entry<String, Integer>> stream = maps.entrySet().stream();
/*-------------------------数组获取流------------------------*/
String[] name = {"小明", "小红", "灭绝师太", "尼古拉斯"};
Stream<String> streamName = Arrays.stream(name);
Stream<String> nameStream = Stream.of(name);
}
}
3.Stream流的常用方法
package com.wjh.d2_stream;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class StreamDemo3 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
System.out.println(list); //[张无忌, 周芷若, 赵敏, 张强, 张三丰]
//Stream<T> filter(Predicate<? super T> predicate);
list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
//张无忌
//张强
//张三丰
System.out.println("-------------");
list.stream().filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
//张无忌
//周芷若
//张三丰
System.out.println("-------------");
list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(s -> System.out.println(s));
//张无忌 ^ 以"张"开头的姓名 取前2个
//张强
System.out.println("-------------");
list.stream().filter(s -> s.startsWith("张")).skip(2).forEach(s -> System.out.println(s));
//张三丰 ^ 以"张"开头的姓名 跳过前2个
System.out.println("-------------");
//Map加工方法 : -> 第二个参数是加工后的结果
//给集合元素的前面加一个: "真爱粉"
//<R> Stream<R> map(Function<? super T, ? extends R> mapper);
list.stream().map(s -> "真爱粉" + s).forEach(s -> System.out.println(s));
//需求:把所有的名称都加工成一个学生对象
//Student s = new Student(s);
//list.stream().map(s -> new Student(s)).forEach(s -> System.out.println(s));
list.stream().map(Student::new).forEach(System.out::println);
//简化版: -> 构造器引用 方法引用
//合并流
Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
Stream<String> s2 = Stream.of("Java", "Java2", "张无忌");
Stream<String> s3 = Stream.concat(s1,s2); //s1,s2合并
/* public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
Objects.requireNonNull(a);
Objects.requireNonNull(b);
*/
//s3.forEach(s -> System.out.print(s + "\t")); //张无忌 张强 张三丰 Java Java2 张无忌
System.out.println();
System.out.println("---------------------");
//去重复
//s3.distinct().forEach(s -> System.out.println(s));
s3.distinct().forEach(s -> System.out.print(s + "\t")); //张无忌 张强 张三丰 Java Java2
}
}
[张无忌, 周芷若, 赵敏, 张强, 张三丰]
张无忌
张强
张三丰
-------------
张无忌
周芷若
张三丰
-------------
张无忌
张强
-------------
张三丰
-------------
真爱粉张无忌
真爱粉周芷若
真爱粉赵敏
真爱粉张强
真爱粉张三丰
Student{name='张无忌'}
Student{name='周芷若'}
Student{name='赵敏'}
Student{name='张强'}
Student{name='张三丰'}---------------------
张无忌 张强 张三丰 Java Java2
进程已结束，退出代码为 0
4.Stream流的综合应用
package com.wjh.d3_streamDemo;
/*
需求：某个公司的开发部门，分为开发一部和二部，现在需要进行年中数据结算。
分析：
：员工信息至少包含了(名称、性别、工资、奖金、处罚记录)
：开发一部有4个员工、开发二部有5名员工
：分别筛选出2个部门的最高工资的员工信息，封装成优秀员工对象Topperformer
：分别统计出2个部门的平均月收入，要求去掉最高和最低工资。
：统计2个开发部门整体的平均工资，去掉最低和最高工资的平均值。
*/
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Stream;
public class Test {
public static double count; //共享访问
public static double count2; //共享访问 //两个部门去掉高低的总和
public static void main(String[] args) {
List<Employee> oneList = new ArrayList<>();
oneList.add(new Employee("孙悟空",'男',10000,50000,null));
oneList.add(new Employee("沙僧",'男',5000,2000,null));
oneList.add(new Employee("猪八戒",'男',3000,100,"取经路上偷吃西瓜"));
oneList.add(new Employee("小白龙",'女',4500,3000,null));
List<Employee> twoList = new ArrayList<>();
twoList.add(new Employee("小明",'男',5000,2500,null));
twoList.add(new Employee("小红",'女',4000,3000,null));
twoList.add(new Employee("小玲",'女',3500,6000,null));
twoList.add(new Employee("小谢",'男',200,1000,"迟到旷工"));
twoList.add(new Employee("小王",'男',15000,20000,null));
//1.开发一部的最高工资的员工
// Employee e = oneList.stream().max((e1, e2) -> Double.compare(e1.getPrice()+e1.getMonths(), e2.getPrice()+e2.getMonths()))
// .get();
// System.out.println(e);
niceEmployee n = oneList.stream().max((e1, e2) -> Double.compare(e1.getPrice()+e1.getMonths(), e2.getPrice()+e2.getMonths()))
.map(e -> new niceEmployee(e.getName(),e.getMonths() + e.getPrice())).get();
niceEmployee n2 = twoList.stream().max((e1,e2) -> Double.compare(e1.getPrice() + e1.getMonths(), e2.getPrice() + e2.getMonths()))
.map(e -> new niceEmployee(e.getName(),e.getMonths() + e.getPrice())).get();
System.out.println(n);
System.out.println(n2);
//2.分别统计出2个部门的平均月收入，要求去掉最高和最低工资。
//double count = 0; //在局部变量这里创建爱count在stream访问不了,因为stream相当于一个方法,所以要在外面创建一个共享访问的方法
oneList.stream().sorted((e1, e2) -> Double.compare(e1.getPrice() + e1.getMonths(), e2.getPrice() + e2.getMonths()))
.skip(1).limit(oneList.size() - 2).forEach(e ->{
//求出总和:剩余员工的工资总和
count += (e.getMonths() + e.getPrice());
});
double avg = count / oneList.size() - 2;
System.out.println("开发一部的平均工资是:" + avg);
//3.合并两个集合流,再统计
Stream<Employee> s1 = oneList.stream();
Stream<Employee> s2 = twoList.stream();
Stream<Employee> s3 = Stream.concat(s1, s2);
s3.sorted((e1, e2) -> Double.compare(e1.getPrice() + e1.getMonths(), e2.getPrice() + e2.getMonths()))
.skip(1).limit(oneList.size() + twoList.size() - 2).forEach(e ->{
//求出总和:剩余员工的工资总和
count2 += (e.getMonths() + e.getPrice());
});
double avg2 = count2 / (oneList.size() + twoList.size() - 2); //去掉最高最低
//BigDecimal -> 解决精度问题
// BigDecimal b = BigDecimal.valueOf(count);
// BigDecimal b2 = BigDecimal.valueOf(count2);
System.out.println("公司的平均工资是:" + (int)avg2);
}
}
niceEmployee{name='孙悟空', money=60000.0}
niceEmployee{name='小王', money=35000.0}
开发一部的平均工资是:3623.0
公司的平均工资是:10942进程已结束，退出代码为 0
5.收集Stream流
package com.wjh.d2_stream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/*
目标:收集Stream流的数据到集合或数组中去
*/
public class streamDemo5 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
list.add("张三丰");
Stream<String> stream = list.stream().filter(s -> s.startsWith("张"));
List<String> zhangList = stream.collect(Collectors.toList()); //遍历流中的每个数据
System.out.println(zhangList); //[张无忌, 张强, 张三丰, 张三丰]
//报错:注意注意注意!!! -> 流只能使用一次,已经被流走了
//如果需要重新需要流的功能,可以再new一个Stream对象
Stream<String> stream2 = list.stream().filter(s -> s.startsWith("张"));
Set<String> zhangSet = stream2.collect(Collectors.toSet());
System.out.println(zhangSet);
//收集到数组
Object[] arr = zhangSet.toArray();
System.out.println("Arrays数组内容:");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
//张 强
//张三丰
//张无忌
}
}
}
[张无忌, 张强, 张三丰, 张三丰]
[张强, 张三丰, 张无忌]
Arrays数组内容:
张强
张三丰
张无忌进程已结束，退出代码为 0
三.异常处理
1.异常概述、体系
package com.wjh.d5_exception_javac;
public class ExceptionDemo {
public static void main(String[] args) {
// 1.数组索引越界异常: ArrayIndexOutOfBoundsException
int[] arr = {1, 2, 3};
System.out.println(arr[2]); //3
//System.out.println(arr[3]); //Index 3 out of bounds for length 3
//2. 空指针异常 : NullPointerException，直接输出没有问题，
// 但是调用空指针的变量的功能就会报错。
String name = null;
System.out.println(name); //null
//System.out.println(name.length()); //Cannot invoke "String.length()" because "name" is null
//3. 数学操作异常：ArithmeticException
Object it = 23;
System.out.println(it); //23
//4.类型转换异常：ClassCastException
String s = (String)it;
System.out.println(s);
//转换异常!class java.lang.Integer cannot be cast to
// class java.lang.String (java.lang.Integer and java.lang.
// String are in module java.base of loader 'bootstrap')
//5. 数字转换异常： NumberFormatException
int c = 10 / 0;
//System.out.println(c);
// class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
String number = "23";
//Integer it2 = Integer.valueOf(number); //运行出错,程序终止!
//System.out.println(it2 + 1);
//class java.lang.Integer cannot be cast to class java.lang.String
// (java.lang.Integer and java.lang.
// String are in module java.base of loader 'bootstrap')
System.out.println("程序结束!");
}
}
3
null
23
进程已结束，退出代码为 1
2.常见运行时异常
3.常见编译时异常
4.异常的默认处理流程
package com.wjh.d6_exception_default;
public class ExceptionDemo {
public static void main(String[] args) {
System.out.println("程序开始.....");
chu(10,2);
chu(10,0); // / by zero
System.out.println("程序结束....."); //程序无法到达,程序立即死亡
}
public static void chu(int a, int b){
System.out.println(a);
System.out.println(b);
int c = a / b;
System.out.println(c);
}
}
程序开始.....
10
2
5
10
0
Exception in thread "main" java.lang.ArithmeticException: / by zero
at com.wjh.d6_exception_default.ExceptionDemo.chu(ExceptionDemo.java:15)
at com.wjh.d6_exception_default.ExceptionDemo.main(ExceptionDemo.java:7)进程已结束，退出代码为 1
5.编译时异常的处理机制
package com.wjh.d7_exception_handle;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo1 {
//throws ParseException异常往外抛 Alt + enter:添加异常到方法签名!
public static void main(String[] args) throws ParseException, FileNotFoundException {
System.out.println("程序开始...");
parseTime("2023-05-06 21:38:56");
System.out.println("程序结束...");
}
//throws ParseException异常往外抛 Alt + enter:添加异常到方法签名!
public static void parseTime(String date) throws ParseException, FileNotFoundException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse(date);
System.out.println(d);
/*
程序开始...
Sat May 06 21:38:56 CST 2023
程序结束...
*/
InputStream is = new FileInputStream("E:/meinv.jpg");
//控制台依旧异常:因为被ParseException先抛,JVM虚拟机表面能抛多个,实际上就抛一个
}
}
程序开始...
Sat May 06 21:38:56 CST 2023
Exception in thread "main" java.io.FileNotFoundException: E:\meinv.jpg (系统找不到指定的文件。)
at java.base/java.io.FileInputStream.open0(Native Method)
at java.base/java.io.FileInputStream.open(FileInputStream.java:216)
at java.base/java.io.FileInputStream.<init>(FileInputStream.java:157)
at java.base/java.io.FileInputStream.<init>(FileInputStream.java:111)
at com.wjh.d7_exception_handle.ExceptionDemo1.parseTime(ExceptionDemo1.java:29)
at com.wjh.d7_exception_handle.ExceptionDemo1.main(ExceptionDemo1.java:14)进程已结束，退出代码为 1
// Exception只写一个
public static void parseTime(String date) throws Exception {
} 
package com.wjh.d7_exception_handle;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo2 {
public static void main(String[] args) {
System.out.println("程序开始...");
parseTime("2023-05-06 21:38:56");
System.out.println("程序结束...");
}
//块四:终极写法!
// Exception只写一个
public static void parseTime(String date) {
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
Date d = sdf.parse(date);
System.out.println(d);
InputStream is = new FileInputStream("E:/11.png");
} catch (Exception e) { //2.
//打印异常栈信息,是规范
e.printStackTrace(); //自带打印信息;推荐使用,程序不死机
}
}
// //块三:
// // Exception只写一个
// public static void parseTime(String date) {
// try {
// //1.
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
// //2.
// InputStream is = new FileInputStream("E:/11.png");
//
// } catch (FileNotFoundException|ParseException e) { //2.
// //打印异常栈信息,是规范
// e.printStackTrace(); //自带打印信息;推荐使用,程序不死机
// }
// }
//
// }
// //块二:
// // Exception只写一个
// public static void parseTime(String date) {
// try {
// //1.
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
// //2.
// InputStream is = new FileInputStream("E:/11.png");
//
// } catch (FileNotFoundException e) { //2.
// //打印异常栈信息,是规范
// e.printStackTrace(); //自带打印信息;推荐使用,程序不死机
// } catch (ParseException e) { //1.
// e.printStackTrace(); //自带打印信息;推荐使用,程序不死机
// }
//
// }
//
// //块1
// public static void parseTime2(String date) {
//
// //Ctrl + Alt + T:选择try { }catch ( ) { }
// try {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
// } catch (ParseException e) {
// //解析出现问题
// System.out.println("解析出现问题,时间异常！"); //不推荐使用
// }
//
//
// try {
// InputStream is = new FileInputStream("E:/meinv.jpg");
// } catch (FileNotFoundException e) {
// System.out.println("文件不存在,异常！");
// }
//
//
// }
}程序开始...
java.text.ParseException: Unparseable date: "2023-05-06 21:38:56"
at java.base/java.text.DateFormat.parse(DateFormat.java:399)
at com.wjh.d7_exception_handle.ExceptionDemo2.parseTime(ExceptionDemo2.java:22)
at com.wjh.d7_exception_handle.ExceptionDemo2.main(ExceptionDemo2.java:13)
程序结束...进程已结束，退出代码为 0
package com.wjh.d7_exception_handle;
import java.io.FileInputStream;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo3 {
public static void main(String[] args) {
System.out.println("程序开始...");
try {
parseTime("2023-05-06 21:38:56");
System.out.println("功能操作成功!");
} catch (Exception e) {
e.printStackTrace();
System.out.println("功能操作失败!");
}
System.out.println("程序结束...");
}
public static void parseTime(String date) throws Exception{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
Date d = sdf.parse(date);
System.out.println(d);
InputStream is = new FileInputStream("E:/11.png");
}
}
程序开始...
java.text.ParseException: Unparseable date: "2023-05-06 21:38:56"
at java.base/java.text.DateFormat.parse(DateFormat.java:399)
at com.wjh.d7_exception_handle.ExceptionDemo3.parseTime(ExceptionDemo3.java:25)
at com.wjh.d7_exception_handle.ExceptionDemo3.main(ExceptionDemo3.java:12)
功能操作失败!
程序结束...进程已结束，退出代码为 0
6.运行时异常的处理机制
package com.wjh.d8_exception_handle_runTime;
/*
目标:运行时异常的处理机制!
可以不处理,编译阶段不报错!
按照理论规范,建议还是处理,只需要在最外层捕获处理即可
*/
public class Test {
public static void main(String[] args) {
System.out.println("start...");
try {
chu(10,0);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("end...");
}
public static void chu(int a,int b) { //throws RuntimeException{ 运行时不需要抛
System.out.println(a);
System.out.println(b);
int c = a / b;
System.out.println(c);
}
}
start...
10
0
end...
java.lang.ArithmeticException: / by zero
at com.wjh.d8_exception_handle_runTime.Test.chu(Test.java:25)
at com.wjh.d8_exception_handle_runTime.Test.main(Test.java:13)进程已结束，退出代码为 0
7.异常处理使代码更稳健的案例
package com.wjh.d8_exception_handle_runTime;
/*
需求
键盘录入一个合理的价格为止（必须是数值）。
分析
定义一个死循环，让用户不断的输入价格。
*/
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true){
try {
System.out.println("请输入合法价格:");
String priceStr = sc.nextLine(); //接收一行任意的数据
//转换成Double类型的价格
double price = Double.valueOf(priceStr); //将数据转换成double类型
//判断价格是否大于 0
if(price > 0){
System.out.println("价格合理");
break;
}else {
System.out.println("价格必须是正数");
}
} catch (NumberFormatException e) {
//e.printStackTrace(); //打印异常信息
System.out.println("输入的价格格式有误!请重试!");
}
}
}
}
请输入合法价格:
-89
价格必须是正数
请输入合法价格:
9.9.9
输入的价格格式有误!请重试!
请输入合法价格:
fdg44
输入的价格格式有误!请重试!
请输入合法价格:
a14
输入的价格格式有误!请重试!
请输入合法价格:
3.h
输入的价格格式有误!请重试!
请输入合法价格:
85
价格合理进程已结束，退出代码为 0
8.自定义异常
package com.wjh.d9_exception_custom;
/*
需求:
认为年龄小于0岁,大于200岁就是一个异常
1.自定义编译时异常
定义一个异常类继承Exception.
重写构造器。
在出现异常的地方用throw new 自定义对象抛出，
作用：编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理！！
2、自定义运行时异常
定义一个异常类继承RuntimeException.
重写构造器。
在出现异常的地方用throw new 自定义对象抛出!
作用：提醒不强烈，编译阶段不报错！！运行时才可能出现！！
*/
public class ExceptionDemo {
public static void main(String[] args) {
try {
checkAge(34); //年龄合法,推荐商品!
checkAge(-34);
} catch (com.wjh.d9_exception_custom.itWjhAge itWjhAge) {
itWjhAge.printStackTrace();
}
}
/**
*
* @param age
*/
public static void checkAge(int age) throws itWjhAge {
if(age < 0 || age > 200){
//抛出一个异常对象
//throw : 在方法内部创建一个异常对象,并从此点抛出
//throws : 用在方法申明上面,抛出方法内部的异常
throw new itWjhAge(age + "is illeagal");
}else{
System.out.println("年龄合法,推荐商品!");
}
}
}
年龄合法,推荐商品!
com.wjh.d9_exception_custom.itWjhAge: -34is illeagal
at com.wjh.d9_exception_custom.ExceptionDemo.checkAge(ExceptionDemo.java:42)
at com.wjh.d9_exception_custom.ExceptionDemo.main(ExceptionDemo.java:24)进程已结束，退出代码为 0
package com.wjh.d9_exception_custom;
/*
需求:
认为年龄小于0岁,大于200岁就是一个异常
1.自定义编译时异常
定义一个异常类继承Exception.
重写构造器。
在出现异常的地方用throw new 自定义对象抛出，
作用：编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理！！
2、自定义运行时异常
定义一个异常类继承RuntimeException.
重写构造器。
在出现异常的地方用throw new 自定义对象抛出!
作用：提醒不强烈，编译阶段不报错！！运行时才可能出现！！
*/
public class ExceptionDemo {
public static void main(String[] args) {
try {
checkAge2(34); //年龄合法!
checkAge2(-34); //编译不报错,运行时报错
} catch (Exception e) {
e.printStackTrace();
}
//编译异常方法
try {
checkAge(34); //年龄合法,推荐商品!
checkAge(-34);
} catch (com.wjh.d9_exception_custom.itWjhAge itWjhAge) {
itWjhAge.printStackTrace();
}
}
public static void checkAge2(int age){ //运行时异常不强烈,不抛异常!
if(age < 0 || age > 200){
//抛出一个异常对象
//throw : 在方法内部创建一个异常对象,并从此点抛出
//throws : 用在方法申明上面,抛出方法内部的异常
throw new RunTimeItWjhAge(age + "is have question!");
}else{
System.out.println("年龄合法!");
}
}
/**
*编译时异常
* @param age
*/
public static void checkAge(int age) throws itWjhAge {
if(age < 0 || age > 200){
//抛出一个异常对象
//throw : 在方法内部创建一个异常对象,并从此点抛出
//throws : 用在方法申明上面,抛出方法内部的异常
throw new itWjhAge(age + "is illeagal");
}else{
System.out.println("年龄合法,推荐商品!");
}
}
}
年龄合法!
com.wjh.d9_exception_custom.RunTimeItWjhAge: -34is have question!
at com.wjh.d9_exception_custom.ExceptionDemo.checkAge2(ExceptionDemo.java:44)
at com.wjh.d9_exception_custom.ExceptionDemo.main(ExceptionDemo.java:24)
com.wjh.d9_exception_custom.itWjhAge: -34is illeagal
at com.wjh.d9_exception_custom.ExceptionDemo.checkAge(ExceptionDemo.java:62)
at com.wjh.d9_exception_custom.ExceptionDemo.main(ExceptionDemo.java:33)
年龄合法,推荐商品!进程已结束，退出代码为 0
扫一扫
280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
