java基础学习——（11）异常、Object类

最新推荐文章于 2021-03-08 21:03:20 发布

小乖～

最新推荐文章于 2021-03-08 21:03:20 发布

阅读量351

点赞数

分类专栏： java基础学习

本文链接：https://blog.csdn.net/weixin_43199838/article/details/96441211

版权

java基础学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

异常

在运行时期发生的不正常情况。

Throwable（可抛）
Error（错误）通常出现重大问题如：运行的类不存在或者内存溢出等不编写针对代码对其处理
Exception（异常）在运行时运行出现的一起情况，可以通过try catch finally

Exception和Error的子类名都是以父类名作为后缀

在java中用类的形式对不正常情况进行了描述集合封装对象。描述不正常的情况的类，就称为异常类。
以前正常流程代码和问题处理代码相结合，现在将正常流程和异常问题处理相分离，提高阅读性。

其实异常就是java通过面向对象的思想将问题封装成了对象。用异常类对其进行描述。不同的问题用不同的类进行具体的描述，比如角标越界，空指针等等。问题很多，意味着描述的类也很多。将其共性进行向上抽取，形成了异常体系。

最终问题（不正常情况）就分成了两大类：（Throwable以下两类的父类）
1、一般不可处理的。Error
2、可以处理的。Exception

Throwable：无论是error ，还是Exception，问题发生就应该可以抛出，让调用者知道并处理。该体系的特点就在于Throwable及其所有的子类都具有可抛性。

可抛性到底指的是什么？怎么体现可抛性呢？
其实通过两个关键字体现的。throws throw,凡是可以被这两个关键字所操作的类和对象都具备可抛性。

1、一般不可处理的。Error 。特点：是由jvm抛出的严重性的问题，这种问题发生一般不针对性处理，直接修改程序。
2、可以处理的。Exception

该体系的特点：

子类的后缀都是用其父类名作为后缀，阅读性很强。

负数角标这种异常在java中并没有定义过。那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述，并封装成对象。这种自定义的问题描述称为自定义异常。

自定义异常：

class Demo
{
	public int method(int[] arr,int index)
	{
		if(arr==null)
			throw new NullPointerException("数组的引用不能为空。")；
		if(index>=arr.length)
		{
			throw new ArrayIndexOutOfBoundsException("数组的角标越界啦~"+index);
		}
		if(index<0)
		{
			throw new ArrayIndexOutOfBoundsException("角标的数值不能为负啊兄弟："+index);
		}
		return arr[index];
	}
}
class  InnerClassDemo2
{
	public static void main(String[] args) 
	{
		int[] arr = new int[3];
		Demo d = new Demo();
		int num = d.method(arr,30);
		System.out.println("num"+num);
	}
}
//输出结果：
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 数组的角标越界啦~30
	at Demo.method(InnerClassDemo2.java:7)
	at InnerClassDemo2.main(InnerClassDemo2.java:18)

注意：如果过让一个类称为异常类，必须要继承异常体系。因为只有成为异常体系的子类才有资格具备可抛性，才可以被两个关键字所操作，throw 、throws

java虚拟机会先检查语法错误，然后再检查异常。

class FuShuIndexException extends Exception
{
	FuShuIndexException()
	{}
}
class Demo
{
	public int method(int[] arr,int index)
	{
		if(index<0)
		{
			throw new FuShuIndexException();
		}
		return arr[index];
	}
}
class  InnerClassDemo2
{
	public static void main(String[] args) 
	{
		int[] arr = new int[3];
		Demo d = new Demo();
		int num = d.method(arr,30);
		System.out.println("num"+num);
	}
}
//InnerClassDemo2.java:18: 错误: 未报告的异常错误FuShuIndexException; 必须对其进行捕获或声明以便抛出
//			throw new FuShuIndexException();
//			^
//1 个错误

对异常进行声明

class FuShuIndexException extends Exception
{
	FuShuIndexException(String msg)
	{
		super(msg);//继承的父类有相应的处理
	}
}
class Demo
{
	public int method(int[] arr,int index)throws FuShuIndexException  //在所调用的地方加一个throws FuShuIndexException
	{
		if(index<0)
		{
			throw new FuShuIndexException("角标为负的啦");
		}
		return arr[index];
	}
}
class  InnerClassDemo2
{
	public static void main(String[] args)throws FuShuIndexException//在所调用的地方加一个throws FuShuIndexException
	{
		int[] arr = new int[3];
		Demo d = new Demo();
		int num = d.method(arr,-3);
		System.out.println("num"+num);
	}
}
//Exception in thread "main" FuShuIndexException: 角标为负的啦
// at Demo.method(InnerClassDemo2.java:14)
//	at InnerClassDemo2.main(InnerClassDemo2.java:25)

异常的分类：

1.编译时被检测异常：只要是Exception和其子类都是,除了特殊子类RuntimeException体系。
这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式，这样的问题都可以针对性的处理。

2.编译时不检测异常（运行时异常）：就是Exception中的RuntimeException和其子类
这种问题的发生无法让功能继续，运算无法进行，更多是因为调用者的原因导致的，或者引发了内部状态的改变导致的。那么这种问题一般不处理，直接接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行修正。

所以自定义异常时，要么继承Exception，要么继承RuntimeException。

RuntimeException是那些可能在java虚拟机正常运行期间抛出的异常的超类。可能在执行方法期间抛出但未被捕获的RuntimeException的任何子类都无需再throws子句中进行声明。

throws和throw的区别

1.throws使用在函数上，
throw使用在函数内
2.throws抛出的是异常类，可以抛出多个，用逗号隔开。
throw抛出的时异常对象。

异常捕捉

这是可以对异常进行针对性处理的方法。

具体格式：

try
{
			//需要被检测异常的代码。
}
catch（异常类 变量）//该变量用于接收发生的异常对象
{
           //处理异常的代码
}
finally
{
		//一定会被执行的代码
}

异常捕获实例

class FuShuIndexException extends Exception
{
	FuShuIndexException(String msg)
	{
		super(msg);//继承的父类有相应的处理
	}
}
class Demo
{
	public int method(int[] arr,int index)throws FuShuIndexException //在所调用的地方加一个throws FuShuIndexException
	{
		if(index<0)
		{
			throw new FuShuIndexException("角标为负的啦");
		}
		return arr[index];
	}
}
class  InnerClassDemo2
{
	public static void main(String[] args)
	{
		int[] arr = new int[3];
		Demo d = new Demo();
		try                    //在有可能出现异常的语句进行try
		{
			int num = d.method(arr,-3);
			System.out.println("num"+num);
		}                                //出现异常以后对异常进行捕获、处理
		catch (FuShuIndexException e)
		{
			System.out.println("负数角标异常啦");
			System.out.println("massage："+e.getMessage());  //继承，getMassage()，是父类中的方法。
			System.out.println("string："+e);  //这里自动调用函数，e==>e.toString()
			e.printStackTrace();  //jvm默认的异常处理机制就是调用异常对象的这个方法。
		}
		System.out.println("结束");
	}
}
---------- 执行 ----------
负数角标异常啦
massage：角标为负的啦
string：FuShuIndexException: 角标为负的啦
FuShuIndexException: 角标为负的啦
	at Demo.method(InnerClassDemo2.java:14)
	at InnerClassDemo2.main(InnerClassDemo2.java:27)
结束

注意：一个try可以对应多个catch。多catch父类的catch放在最下面，否则编译失败。

异常处理原则
1.函数内部如果抛出需要检测的异常，那么函数上必须要声明。否则必须在函数内用try catch捕捉，否则编译失败。
2.如果调用到了声明异常的函数，要么try catch，要么throws，否则编译失败。
3.什么时候catch？什么时候throws呢？
功能内部可以解决，用catch
解决不了，用throws告诉调用者，由调用者解决
4.一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理。
内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

finally代码块
一定会执行的代码。只有一种情况执行不到，即退出jvm : System.exit(0);
通常用于关闭（释放）资源。

例如：连接数据库—>查询。Exception—>关闭连接—>

try catch finally 代码块的组合特点：

1.try catch finally
2.try catch（多个）当没有必要资源需要释放时，可以不用定义finally
3.try finally 异常无法直接catch处理，但是资源需要关闭

异常的注意事项：

1.子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。
2.如果过父类抛出多个异常，那么子类只能抛出父类异常的子集。
简单说：子类覆盖父类只能抛出父类的异常或子类或者子集
注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try。

class A extends Exception
{}
class B extends A
{}
class C extends Exception
{}
class Fu
{
	void show()throws A
	{}
}
class Zi extends Fu
{
	void show()throws A//或者B，而不能是C，子类覆盖父类只能抛出父类的异常或子类或者子集
	{}
}

Object类

类object是类层次结构的根类。每个类都使用object作为超类。所有对象（包括数组）都实现这个类的方法。
object是不断抽取而来的，具备所有对象都具备的共性内容。

常用的共性内容：

（1）equals（object obj）//意味着可以比较obj下的所有类对象
指示其它某个对象是否与此对象是否“相等”。

默认是比较地址

class Person extends Object
{
	private int age;
	Person(int age)
	{
		this.age = age;
	}
	public
}
class  InnerClassDemo2
{
	public static void main(String[] args)
	{
		Person p1 = new Person(20);
		Person p2 = new Person(20);
		Person p3 = p1;
		System.out.println(p1 == p2);   //比较的是地址值
		System.out.println(p1.equals(p3));   //比较的是地址值
	}
}
---------- 执行 ----------
false
true

对equals进行复写，重新定义它的比较内容。这里是复写为比较年龄。

class Person extends Object
{
	private int age;
	Person(int age)
	{
		this.age = age;
	}
	//比较Person的年龄，是否是同龄人。
	public boolean equals(Object obj)
	{
		Person p = (Person)obj; 
		return this.age == p.age;
	}
}
class  InnerClassDemo2
{
	public static void main(String[] args)
	{
		Person p1 = new Person(20);
		Person p2 = new Person(20);
		Person p3 = p1;
		System.out.println(p1.equals(p2));
		System.out.println(p1.equals(p3));
	}
}
---------- 执行 ----------
true
true

对以上代码进行改进，因为Object类下有多个子类，若不是传入Person类就没有比较的意义，所以向下转型需要健壮性判断。对判断结果进行异常抛出

class Person extends Object
{
	private int age;
	Person(int age)
	{
		this.age = age;
	}
	//比较Person的年龄，是否是同龄人。
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
		{
			throw new ClassCastException("类型错误");//RuntimeException的任何子类都无需再throws子句中进行声明。

		}
		Person p = (Person)obj; 
		return this.age == p.age;
	}
}
class Demo
{}
class  InnerClassDemo2
{
	public static void main(String[] args)
	{
		Person p1 = new Person(20);
		Person p2 = new Person(20);
		Person p3 = p1;
		Demo d = new Demo();
		System.out.println(p1.equals(d));
		System.out.println(p1.equals(p3));
	}
}
---------- 执行 ----------
Exception in thread "main" java.lang.ClassCastException: 类型错误
	at Person.equals(InnerClassDemo2.java:14)
	at InnerClassDemo2.main(InnerClassDemo2.java:30)

equals():比较两个对象是否相等(判断地址还有内容)。一般都会覆盖此方法，根据对象的特有内容建立判断对象是否相同的依据。

注意:
当此方法被重写时,通常有必要重写hashCode方法,以维护hashCode方法的常规协定，该协定声明相等对象必须具备相等的哈希值码。

(2) hashCode()
返回该对象的哈希码值。支持此方法是为了提高哈希表（例如 java.util.Hashtable 提供的哈希表）的性能。实际上，有Object类定义的hashCode方法确实会针对不同的对象返回不同的整数。（一般是通过将该对象的内部地址转换成一个整数来实现的，但是Java编程语言不需要这种实用技巧）。

class  InnerClassDemo2
{
	public static void main(String[] args)
	{
		Person p1 = new Person(20);
		Person p2 = new Person(20);
		Person p3 = p1;
		Demo d = new Demo();
		System.out.println(p1);//哈希值1
		System.out.println(p1.hashCode());//哈希值2
		System.out.println(Integer.toHexString(p1.hashCode()));//实际上转换为16进制字符后就是一样的数值。
	}
}
---------- 执行 ----------
Person@4e25154f
1311053135
4e25154f

复写哈希值方法。

class Person extends Object
{
	private int age;
	Person(int age)
	{
		this.age = age;
	}
	//比较Person的年龄，是否是同龄人。
	public int hashCode()
	{
		
		return this.age;
	}
}
class Demo
{}
class  InnerClassDemo2
{
	public static void main(String[] args)
	{
		Person p1 = new Person(20);
		Person p2 = new Person(20);
		Person p3 = p1;
		Demo d = new Demo();
		System.out.println(p1.hashCode());
	}
}
---------- 执行 ----------
20

(3) getClass()
返回此Object运行时类。
在这里插入图片描述
向上抽取的是class Class。包括抽取类名、方法、构造器等。


class Person extends Object
{
	private int age;
	Person(int age)
	{
		this.age = age;
	}
	//比较Person的年龄，是否是同龄人。
}
class Demo
{}
class  InnerClassDemo2
{
	public static void main(String[] args)
	{
		Person p1 = new Person(20);
		Person p2 = new Person(2);
		Class clazz1 = p1.getClass();
		Class clazz2 = p2.getClass();
		System.out.println(clazz1==clazz2);
		System.out.println(clazz1.getName());
	}
}
---------- 执行 ----------
true
Person

(4) toString()
public String toString()
返回该对象的字符串表示。：getClass().getName() + ‘@’ + Integer.toHexString(hashCode())
建议所有子类都重写此方法。

小乖～

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础学习——（11）异常、Object类

异常在运行时期发生的不正常情况。Throwable（可抛）Error（错误）通常出现重大问题如：运行的类不存在或者内存溢出等不编写针对代码对其处理Exception（异常）在运行时运行出现的一起情况，可以通过try catch finallyException和Error的子类名都是以父类名作为后缀在java中用类的形式对不正常情况进行了描述集合封装对象。描述不正常的情况的类，就称...
复制链接

扫一扫

专栏目录