千锋逆战班day26

2023-11-01 12:55:04

day26
在千锋逆战学习第26天
越努力越幸运
15、Map集合的遍历
KeySet(); 获得Map集合中所有的键。返回的是Set集合
Values(); 获得Map集合中的所有值。返回的是Collection集合
entrySet(); 返回的是Map.Entry(Node) 包含了getValue（）和getValue（）。直接输出调用的是toString打印键值对

package com.qf.day26.maps;

import java.util.*;

public class HashMapApply {

	public static void main(String[] args) {
		Map<String,String> maps=new HashMap<String,String>();
		maps.put("CN", "中国");
		maps.put("US", "美国");
		maps.put("JP", "日本");
		maps.put("IT", "意大利");
		
		//entrySet();  键值对   getKey()  getValue()
		//Set集合里存放的都是node对象
		Set<Map.Entry<String,String>> entry=maps.entrySet();
		for (Map.Entry<String, String> e : entry) {
			System.out.println(e.getKey()+":"+e.getValue());
			System.out.println(e);
		}
		
		
		//遍历方式1  KeySet();  键-无序、无下标、不可重复
		//遍历的是所以的键
		Set<String> keys=maps.keySet();
		for (String k : keys) {
			System.out.println(maps.get(k));	
		}
		
		//遍历方式2  values 值 可以重复 
		Collection<String> cs=maps.values();
		for (String value : cs) {
			System.out.println(value);
		}
		
	}

}

16、Iterator 迭代器
专注于迭代Collectioin体系的集合

package com.qf.day26.maps;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

public class TestIterator {

	public static void main(String[] args) {
		// 对于Collection体系集合进行遍历
		List<String> list=new ArrayList<String>();
		list.add("A");
		list.add("B");
		list.add("C");
		list.add("D");
		
		//1、获得一个迭代器
		//hasNext();  是否有下一个元素可以遍历  有true  没有false
		//next();   返回下一个元素
		Iterator<String> iter=list.iterator();
		while(iter.hasNext()){
			System.out.println(iter.next());
		}
		
		Set<String> sets=new HashSet<String>();
		sets.add("E");
		sets.add("F");
		sets.add("G");
		sets.add("H");
		
		Iterator<String> si=sets.iterator();
		while(si.hasNext()){
			System.out.println(si.next());
		}
	}

}

第十三章异常
1、什么是异常
程序在运行过程中出现的特殊情况
异常处理的必要性：任何程序都可能存在大量的未知问题。错误：如果不对这些问题进行正确处理，则可能导致程序的中断，造成不必要的损失
2、异常的分类
Throwable：可抛出、一切错误或异类的父类。位于java.long包中
Error：JVM、硬件、执行逻辑错误，不能手动处理
Exception：程序在运行和配置过程中产生的问题，可处理
RuntimeException：运行时异常，可处理，可不处理
CheckedException：受查异常，必须处理

package com.qf.day26.errors;

import java.util.Scanner;

public class TestException {

	public static void main(String[] args) {
		m6();//不处理---->java虚拟机处理，打印堆栈跟踪信息
		//程序运行过程当中产生的

	}
	//java.lang.ClassCastException 类型转换异常
	public static void m1(){
		Object o=new Integer(2);
		Scanner sc=(Scanner) o;
	}
	
	//java.lang.ArithmeticException 算数异常
	public static void m2(){
		System.out.println(10/0);
	}
	
	//java.lang.ArrayIndexOutOfBoundsException数组下标越界
	public static void m3(){
		int[] nums=new int[1];
		System.out.println(nums[1]);
	}
	
	//java.lang.StringIndexOutOfBoundsException字符串下标越界
	public static void m4(){
		String str="anc";
		System.out.println(str.charAt(5));
	}
	
	//java.util.InputMismatchException 输入匹配异常
	public static void m5(){
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入一个数：");
		int num=sc.nextInt();
	}
	
	//java.lang.NullPointerException 空指针异常
	public static void m6(){
		Object o=null;
		o.hashCode();
	}

}

3、异常的产生：
自动抛出异常：当程序在运行时遇到不符合规范的代码或结果时，会产生异常
手动抛出异常：throw new 异常类型（“实际参数”）
一旦产生异常结果：相当于执行return语句，导致程序因异常而终止

public class TestThrowException {

	public static void main(String[] args) {
		Student stu=new Student();
		
		stu.setAge(20);//在调用者角度看，不清楚违规问题
		System.out.println(stu.getAge());
	}

}
class Student{
	private int age;
	public int getAge(){
		return this.age;
	}
	public void setAge(int age){
		if(age>0&&age<125){
			this.age=age;
		}else{
			RuntimeException re=new RuntimeException();//1、创建异常对象，单独存在就意味着仅仅是个对象
			throw re;//2、结合throw关键字，抛出异常
			
			//throw new RuntimeException();
		}
	}
}

4、异常的传递：
按照方法的调用链反向传递，如果最终都没有处理异常，最终交由我们的JVM进行默认异常处理（打印堆栈跟踪信息）
受查异常：throws声明异常，声明位置：修饰在方法参数列表的后端
运行时异常：因其可处理，可不处理，无需声明

package com.qf.day26.transfer;

import javax.management.RuntimeErrorException;

public class TestTeabsferException {

	public static void main(String[] args)throws Exception {
		System.out.println("main--start");
		m1(10);
		System.out.println("main--end");
	}
	public static void m1(int n)throws Exception{
		System.out.println("m1--start");
		m2(n);
		System.out.println("m1--end");
	}
	
	public static void m2(int n)throws Exception{
		System.out.println("m2--start");
		m3(n);
		System.out.println("m2--end");
	}
	
	//throws 消极的处理方式
	public static void m3(int n)throws Exception{//向上声明--声明该方法存在受查异常
		System.out.println("m3--start");
		if(n%2==0){
			throw new Exception();
//			throw new RuntimeException();
		}	
		System.out.println("m3--end");
	}
	
	public static void method(){
		
	}

}

5、异常的处理

package com.qf.day26.dispose;

import java.util.Scanner;

public class TestTryCatch {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		
		System.out.println("请输入一个被除数：");
		int num1=sc.nextInt();
		
		System.out.println("请输入一个除数：");
		int num2=sc.nextInt();
		
		try{
			int result=num1/num2;
			System.out.println(result);
		}catch(Exception e){
			System.out.println("除数不可为0");//处理方案1：自定义处理
			e.printStackTrace();//处理方案2：打印堆栈跟踪信息
			System.out.println(e.getMessage());//处理方案3：获取异常的原因message
			
		}
		System.out.println("程序结束");

	}

}

package com.qf.day26.dispose;
import java.util.InputMismatchException;
import java.util.Scanner;

public class TestMoreTryCatch {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		 int num1=0;
		 int num2=0;
		try{
			System.out.println("请输入一个被除数：");
			num1=sc.nextInt();
			
			System.out.println("请输入一个除数：");
			num2=sc.nextInt();
			
			int result=num1/num2;
			System.out.println(result);
		

		}catch(ArithmeticException e){
			System.out.println("除数不可为0");
		}catch(InputMismatchException e){
			System.out.println("请输入正确的整数！");
		}catch(Exception e){
			System.out.println("出现未知问题");
		}
	}
}

package com.qf.day26.dispose;

public class TestFinally {

	public static void main(String[] args) {
		System.out.println(method(2));

	}
	public static int method(int n){
		try{
			if(n%2==0){
				throw new RuntimeException();
			}
			return 20;
		}catch (Exception e) {
			System.out.println("解决异常。。。");
			return 30;
		}finally{
			System.out.println("程序结束！");
		}
	}

}

Chapter 10 异常
Key Point：
●异常的概念和分类
●异常的产生和传递
●异常的处理
●自定义异常
习题：
1、填空
java中所有的错误都继承自 Throwable 类；在该类的子类中， Error 类表示严重的底层错误，对于这类错误一般的处理方式是不应该试图捕捉他； Exception 类表示例外、异常

2、查询API，填空
异常类java.rmi.AlreadyBoundException类；从分类上说，该类属于已检察异常，从处理方式上说，对这种异常必须处理
异常类java.util.regex.PattemSynataxException,从分类上说，该类属于未检查异常，从处理方式上说，对这种异常可处理可不处理处理

3、（异常的产生）把下面代码补全
public class TestThrow {
public static void main(String[] args) {
throwException(10);
}
public static void throwException(int n){
if(n==0){
//抛出一个NullPointerException
throw new NullPointerException();
}else{
//抛出一个ClassCastException
throw new ClassCastException();
//并设定详细信息为“类型转换出错”
//char a=(char) n;
}
}
}

4、（try-catch-finally）有以下代码：
package t4;

import java.io.;
import java.sql.;
public class TestException {
public static void main(String[] args) {
System.out.println(“main 1”);
int n;
//读入n
ma(n);
System.out.println(“main 2”);
}
public static void ma(int n){
try{
System.out.println(“ma1”);
mb(n);
System.out.println(“ma2”);
}catch(EOFException e){
System.out.println(“Catch EOFException”);
}catch(IOException e){
System.out.println(“Catch IOException”);
}catch(SQLException e){
System.out.println(“Catch SQLException”);
}catch (Exception e) {
System.out.println(“Catch Exception”);
}finally{
System.out.println(“In finally”);
}
}
public static void mb(int n)throws Exception{
System.out.println(“mb1”);
if(n1)throw new EOFException();
if(n2)throw new FileNotFoundException();
if(n3)throw new SQLException();
if(n4)throw new NullPointerException();
System.out.println(“mb2”);
}
}
问：当读入的n分别为1，2，3，4，5时，输出的结果分别是什么？
答：n=1时：
main 1
ma1
mb1
Catch EOFException
In finally
main 2

n=2时：
main 1
ma1
mb1
Catch IOException
In finally
main 2

n=3时：
main 1
ma1
mb1
Catch SQLException
In finally
main 2

n=4时：
main 1
ma1
mb1
Catch Exception
In finally
main 2

n=5时：
main 1
ma1
mb1
mb2
ma2
In finally
main 2
7、(try-catch)代码改错：
class MyException{}
class TestException {
public static void main(String[] args) {
ma();
}
public static int ma(){
try{
m();
return 100;
}catch (Exception e) {
System.out.println(“Exception”);
}catch(ArithmeticException e){
System.out.println(“ArithmeticException”);
}
}
public static void m(){
throw new MyException();
}
}
改完为：
class MyException{}
class TestException {
public static void main(String[] args) {
ma();
}
public static int ma(){
try{
m();
return 100;

	}catch(ArithmeticException e){
		System.out.println("ArithmeticException");
	}catch (Exception e) {
		System.out.println("Exception");
	}
	return 200;
}
public static void m() throws Exception{
	throw new Exception();
}

}
9、（try-catch 局部变量）有以下代码：
public class TestTryCatch {
public static void main(String[] args) {
System.out.println(ma());
}
public static int ma(){
int n;
try{
n=10/0;
}catch (Exception e) {

	}
	return n;
}

}
选择正确答案： A
A.编译不通过
B.编译通过，输出-1
C.编译通过，输出0
11、（try-finally）写出下面代码的运行结果
public class TestTryFinally {
public static void main(String[] args) {
try {
ma();
} catch (Exception e) {
}
}
public static void ma() throws Exception{
int n=10;
int b;
//读入一个整数b
try{
System.out.println(“ma1”);
int result=n/b;
System.out.println(“ma2”+result);
}finally{
System.out.println(“In Finally”);
}
}
}
在ma中，读入整数b。如果读入的值为10，则输出：
ma1
ma21
In Finally
如果读入的值为0，则输出：
ma1
In Finally
13、（异常的捕捉和抛出）有以下代码：
public class TestException {
public static void main(String[] args) {
try{
System.out.println(“main1”);
ma();
System.out.println(“main2”);
}catch (Exception e) {
System.out.println(“In Catch”);
}
}
public static void ma(){
System.out.println(“ma1”);
throw new NullPointerException();
System.out.println(“ma2”);
}
}
选择正确答案： A
A.编译出错
B.编译正常，输出main1 ma1 In Catch
C.编译正常，运行时出错
14、（异常的捕捉和抛出）有以下代码：
import java.io.;
import java.sql.;
class TestException {
public static void main(String[] args) {
try{
ma();
}
//1
catch (Exception e) {
}
}
public static void ma() throws IOException{}
}
下列哪些代码放在//1处可以编译通过 AB
A.catch(NullPointerException npe){}
B.catch(IOException ioe){}
C.catch(SQLException sqle){}

码农公寓

相关文章