# Day10-Java基础

Posted zsr6135

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了# Day10-Java基础相关的知识，希望对你有一定的参考价值。

Day10-Java

文章目录

1、异常的捕获与处理

异常时导致程序中断执行的一种指令流。程序出现异常没用合理处理，就会导致程序终止执行。

观察没有异常产生的程序

public class TestDemo1{
	public static void main(String args[]){
		System.out.println("1、除法程序开始");
		int result =10/2;
		System.out.println("2、除法程序结果："+result);
		System.out.println("3、除法程序结束");
	}
}
/*
1、除法程序开始
2、除法程序结果：5
3、除法程序结束
*/

产生异常的程序

public class YiChang{
	public static void main(String args[]){
		System.out.println("1,除法程序开始");
		int result =10/0;//会出现错误
		System.out.println("2,除法程序结果："+result);
		System.out.println("3,除法程序结束");
	}
}
/*
Exception in thread "main" java.lang.ArithmeticException: / by zero
        at YiChang.main(YiChang.java:5)
*/

这个时候程序出现了错误，那么出现错误之后程序不执行了，而是直接进行了错误信息的输出，并且直接结束了程序，但是，出现了错误，应该去处理才对，但是现在没有处理。

1.1 处理异常

现在，如果希望程序出现了异常之后，程序依然可以正常的完成的话，那么就可以使用如下的格式进行异常的处理；

		try{
可能出现异常的语句
		}[catch(异常类型 异常对象){
			处理异常；
		}catch(异常类型 异常对象){
            处理异常；
}…][finally{
    异常统一出口
    不管是否出现异常，都执行此代码；
}]

使用该操作进行异常的处理

public class TestDemo1{
	public static void main(String args[]){
		System.out.println("1、除法程序开始");
		try{
			int result =10/0;
			System.out.println("2、除法程序结果："+result);
		}catch(ArithmeticException e){
		System.out.println("异常被正确的处理了");
		}
		System.out.println("3、除法程序结束");
	}
}
/*
1、除法程序开始
异常被正确的处理了
3、除法程序结束
*/

可以发现加入了异常处理之后，程序之中即使有了异常，程序也可以正常执行完毕，但是现在发现，异常处理时的错误输出信息和之前相比，出错的信息不明确了，那么为了让错误的信息更加完整，一般而言，都会调用printStackTrace()方法进行异常信息的打印

这个方法(printStackTrace)打印的异常信息是最完整的：

try{
	int x = 10/0;     //异常
	System.out.println("2,除法程序结果："+x);
}catch(ArithmeticException e){
	e.printStackTrace();
}

try catch finallly 操作

public class TestDemo1{
	public static void main(String args[]){
		System.out.println("1,除法程序开始");
		try{
			int x = 10/0;     //异常
			System.out.println("2,除法程序结果："+x);
		}catch(ArithmeticException e){
			e.printStackTrace();
		}finally{
			System.out.println("不管是否异常都会执行");
		}
		System.out.println("3,除法程序结束");
	}
}

但是，对于之前的程序现在又有了问题：现在执行数学计算的两个参数，都是由程序默认提供，那么如果说现在两个计算的参数通过初始化参数传递呢？

public class TestDemo2{
	public static void main(String args[]){
		System.out.println("1,除法程序开始");
		try{
			int x = Integer.parseInt(args[0]);	//接收参数
			int y = Integer.parseInt(args[1]);    //接收参数
			int result = x/y;   
			System.out.println("2,除法程序结果："+result);
		}catch(ArithmeticException e){
			e.printStackTrace();
		}finally{
			System.out.println("不管是否异常都会执行");
		}
		System.out.println("3,除法程序结束");
	}
}

时候发现，数据由外部传送，那么在这种情况下，就有可能出现一下几类问题：

​ 执行时不输入参数，ArrayIndexOutOfBoundsException，未处理。

​ 输入的参数不是数字，NumberFormatException，未处理。

​ 被除数为0，ArithmeticException，已处理。

可以发现，以上的程序实际上是存在三种异常，而程序之中只能处理一种，而对于不能处理的异常，发现程序依然会直接中断执行。

public class TestDemo2{
	public static void main(String args[]){
		System.out.println("1,除法程序开始");
		try{
			int x = Integer.parseInt(args[0]);	//接收参数
			int y = Integer.parseInt(args[1]);    //接收参数
			int result = x/y;   
			System.out.println("2,除法程序结果："+result);
		}catch(ArithmeticException e){
			e.printStackTrace();
		}catch(ArrayIndexOutOfBoundsException e){
			e.printStackTrace();
		}catch(NumberFormatException e){
			e.printStackTrace();
		}finally{
			System.out.println("不管是否异常都会执行");
		}
		System.out.println("3,除法程序结束");
	}
}

此时，问题就来了，如果按照以上的方式一次一次的测试来进行异常类型的推断，还不如直接编写if…else。

1.2 异常处理的流程

以上已经完成了异常的基本处理流程，但是也可以发现问题，所有的异常都像之前那样一条条的判断似乎是一件不可能完成的任务，因为以后肯定会接触到一些不常见的异常信息，那么下面就必须首先研究异常的流程和结构。

首先查看两个异常的继承结构

ArithmeticException
java.lang.Object
java.lang.Throwable
java.lang.Exception java.lang.RuntimeException
java.lang.ArithmeticException
    

ArrayIndexOutOfBoundsException
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
java.lang.IndexOutOfBoundsException
java.lang.ArrayIndexOutOfBoundsException

可以发现所有的异常类型最高的继承类是Throwable，通过doc文档可以发现Throwable下有两个子类：

​ Error:指的是JVM错误，这个时候的程序并没有执行，无法处理；

​ Exception:指的是程序之中出现了错误信息，可以进行异常处理，主要关心Exception。

​ 那么通过继承关系可以发现，肯定在进行日常处理的时候是以Exception为主，而这个时候就可以形成以下的异常处理流程。

1.3 throw关键字

throws关键字主要是在方法定义上使用的，表示的是此方法之中不进行异常处理，而交给被调用处处理。

class MyMath{
    //现在的div()方法之中抛了一个异常出来，表示的是，所有的异常交给被调用处进行处理。
	public int div(int x,int y) throws Exception{
			return  x/y;
	}
}
public class TestDemo3{
	public static void main(String args[]){
		try{
			System.out.println(new MyMath().div(10,0));
		}catch(Exception e){
			e.printStackTrace();	
		}
	}
}

在调用throws声明方法的时候，一定要使用异常处理操作进行异常的处理，这是是属于强制性的处理，而现在主方法本身也属于方法，那么实际上在主方法上也可以继续使用throws进行异常的抛出。

class MyMath{
    //现在的div()方法之中抛了一个异常出来，表示的是，所有的异常交给被调用处进行处理。
	public int div(int x,int y) throws Exception{
			return  x/y;
	}
}
public class TestDemo3{
	public static void main(String args[]) throws Exception{
		try{
			System.out.println(new MyMath().div(10,0));
		}catch(Exception e){
			e.printStackTrace();	
		}
	}
}

这个时候表示的是将异常继续向上抛，交给JVM进行异常的处理。

请解释throw和throws区别？

  • throw用于方法内部表示进行手工的抛出
  • throws主要用于方法声明上使用，明确的告诉本方法可能产生的异常，同时该方法可能不处理异常。
1.4 异常处理模型

现在觉得有两个内容实在没用finally，throw。

现在要求定义一个div()方法，而这个方法有如下一些要求：

​ 在进行除法操作之前，输出一行提示信息。

​ 在除法操作执行完毕后，输出一行提示信息。

​ 如果中间产生了异常，则应该交给被调用处来进行处理。

class MyMath{
	public static int div(int x, int y) throws Exception{
		int result = 0;
		//不写catch语句的执行流程
		//首先进行try代码块的执行后执行finally代码块执行完成后执行
		//throws进行异常捕获，捕获完成后再主方法catch语句中进行执行
		try{
			System.out.println("before进行除法计算");
			result = x / y;
		}finally{
			System.out.println("after进行除法计算");
		}		
		return result;
	}
}
public class TestDemo4{
	public static void main(String args[]){
		try{
			System.out.println(MyMath.div(10,0));
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}
1.5 RuntimeException
public class TestDemo4{
	public static void main(String args[]){
		String str = "123";
		int num = Integer.parseInt(str);
		System.out.println(num*num);
	}
}

这个方法就是将一个字符串变为了基本数据类型，而后执行乘法操作，但是下面来看一下parseInt()方法的定义:

Public static int parseInt(String s) throws NumberFomatException

发现这个方法上抛出了一个NumberFomatException的异常，按照之前所讲，如果存在了throw，则必须使用try….catch进行处理，可是现在去没有强制要求处理，来观察一下NumberFomatException的继承结构。

java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
java.lang.IllegalArgumentException
java.lang.NumberFormatException

发现NumberFormatException属于RuntimeException的子类，而在Java之中明确规定了，对于RuntimeException的异常类型可以有选择型的来进行处理，在开发之中，如果，没有处理，那么出现异常之后将交给JVM默认进行处理。

Exception和RuntimeException的区别？请你举出常见的RuntimeException？

  • Exception是RuntimeException的父类，使用Exception定义的异常必须使用异常处理

  • RuntimeException可以由用户选择性的异常处理

  • 常见的Exception：NumberFormatException，ClassCastException，NullPointException,ArithmeticException,ArrayIndexOutBoundException。

1.6 断言：assert

断言指的是程序执行到某行之后，其结果一定是预期的结果，而在JDK1.4之后增加了一个assert关键字。

public class DuanYan{	public static void main(String args[]){		int x = 10;		//假设经过了很多操作		assert x == 30:"x的内容不是三十";		System.out.println(x);	}}

默认情况下，Java之中的断言不会在正常执行的代码中出现，如果想要启用断言，则应该早呢更加一些选项。

1.7 自定义异常

在Java之中本省已经提供了大量的异常类型，但是在开发之中，这些异常类型根本就不能满足开发的需要，所以在一些系统架构之中往往会提供一些新的异常类型，来表示一些特殊的错误，而这种操作就称为自定义异常类，而要想实现这种自定义异常类，那么可以让一个类继承Exception或RuntimeException。

class MyException extends Exception{	public MyException(String str){		super(str);	}}public class TestDemo5{	public static void main(String args[]) throws Exception{		throw new MyException("自己的异常类");	}}

如果以后见到了一些没见过的异常类型，那么基本都是自定义的异常类。

2、链表

链表是一种基本的数据结构，但好似对于数据结构的部分，强调一下几点：

  1. 在整个Java开发领域之中，没有一本书去真正讲解数据结构的书，只能去看C语言的数据结构：
  2. 在所有开发之中，都会存在数据结构的身影，可以这样去解释：数据结构的精通与否，完全决定于以后。
  3. 数据结构的核心：引用数据类型操作。

链表实际上可以理解为遗传数据，或者按照专业性的说法，可以理解为动态的对象数组，对象数组的最大优点：是表示“多”的概念，例如：多个雇员。但是传统的对象数组有一个最大的问题在于，里面保存的数据长度是固定的。思考：如果现在想要扩大一个对象数组的范围？

建立一个新的对象数组，而后将原本的内容拷贝到新的数组之中，再改变原数组的引用方式。

public class TestLinkDemo{
	public static void main(String args[]){
		Object ob[] = new Object [3];
	}
}

但是再实际的开发之中，要面临的一个问题是：数组是一个定长的线性结构，也就是说虽然以上代码可以满足于存放多个内容，但是一旦我们呢的内容不足或者是内容过多，可能会导致资源的浪费。要想解决此类问题最好的做法就是不定义一个固定长度的数组 ，有多少数据就保存多少数据。

2.1 链表基本的结构
class Node{//因为只有Node类才可以在保存数据的同时设置数据
	private Object data;//真正要保存的数据
	private Node next;//定义下一个节点
	public Node(Object data){
		this.data = data;
	}
	public void setData(Object data){
		this.data = data;
	}
	public Object getData(){
		return this.data;
	}
	public void setNext(Node next){
		this.next = next;
	}
	public Node getNext(){
		return this.next;
	}
}
public class TestLinkDemo{
	public static void main(String args[]){
		//1.封装几个节点
		Node root = new Node("火车头");
		Node n1 = new Node("车厢1");
		Node n2 = new Node("车厢2");
		Node n3 = new Node("车厢3");
		//2.设置节点关系
		root.setNext(n1);
		n1.setNext(n2);
		n2.setNext(n3);
		//3.输出链表
		print(root);
	}
	public static void print(Node node){
		if(node != null){//表示当前是有节点的
			System.out.println(node.getData());
			print(node.getNext());//继续向下取出
		}
		
	}
}

在整个链表的实现过程中，Node类的作用：保存数据和保存下一个节点，但是我们发现客户端需要自己来进行节点的创建操作以及关系的配置。所谓的链表就是需要有一个单独的类，假设叫Link，通过Link类来实现Node的数据保存和关系处理。

2.2 链表实现结构说明

通过之前的分析，可以发现链表的最大作用类就是Node，但是以上程序都是由用户自己去匹配节点关系的，但是这些节点的匹配工作不应该由用户完成，应该由一个程序专门去负责。

那么专门负责几点操作的类，就成为链表类——Link,负责处理几点关系，而用户不用关心节点的问题，只需关心Link的处理操作即可。

真实开发——标准过程

class Link{//负责对链表的操作
	//将Node定义内部类，表示Node类只能为Link类提供服务
	private class Node{//负责数据与节点的关系匹配
		private Object data;//真正要保存的数据
		private Node next;//定义下一个节点
		public Node(Object data){
			this.data = data;
		}
		public void setData(Object data){
			this.data = data;
		}
		public Object getData(){
			return this.data;
		}	
	}
	//以下为Link类
}
public class TestLinkDemo{
	public static void main(String args[]){
		
	}
}
2.3 增加链表数据—public void add(数据)

通过上面程序的分析，可以发下，对于链表的

以上是关于# Day10-Java基础的主要内容，如果未能解决你的问题，请参考以下文章

day06-jsp

[vscode]--HTML代码片段（基础版，reactvuejquery）

[Go] 通过 17 个简短代码片段，切底弄懂 channel 基础

AI基础_Day02

Java基础Day5

python基础-day9-函数