异常和常用API(Object类)

(一):异常

以下是个人在学习时,在电脑上记得笔记.现在分析给大家.

异常：是什么？
是对问题的描述，将问题进行对象的封装。
---------------------------------------
异常体系：
Throwable
   --Error
   --Exception
--RuntimeException

异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性。
也就是说可以被throws和throw关键字所操作
只要异常体系具备这个特点
-------------------------------------------
throws和throw的用区别：


throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
throw 定义在函数内，用于抛出对象。
-----------------------------------------------------------------
当函数内有throw抛出异常对象，并未进行try处理。必须在函数上声明，否则编译失败


注意：RuntimeException 除外。


如果函数声明了异常，调用者需要进行处理。处理方式可以throws可以try。




异常有两种：
编译时被检测异常（在javac时会查代码）
该异常在编译时，如果没有被处理（没有throw没有try），
那么编译失败。该异常被表示，代表着这异常可以被处理。

运行时异常（编译时不检测）
在编译时，不需要处理，编译器不检查。该异常发生
建议不处理，让程序停止，需要对代码进行修正。
-----------------------------------------------------------------
异常处理的语句：
try
{
被检测的代码;
}
catch()
{
处理异常的代码;
}
finally
{
一定会被执行的代码;
}
--------------------------
有是三种结合方式

try
{
被检测的代码;
}
catch()
{
处理异常的代码;
}


----------------------------
try
{
被检测的代码;
}
finally
{
一定会被执行的代码;
}
-----------------------------
try
{
被检测的代码;
}
catch()
{
处理异常的代码;
}
finally
{
一定会被执行的代码;
}
-------------------------------


注意！！
1，finally中定义的通常是：关闭资源代码。因为资源必须被释放。

2，finally 有一种情况是读取不到的。
当执行到System.exit(0);//系统，退出。jvm结束。finally读取不到。
-----------------------------------------------------------------------


自定义异常：
定义类继承Exception或者RuntimeException
1，让该自定义具备可抛性。
2，让该类具备操作异常的共性方法。




当要定义自定义异常信息时，可以使用父类定义好的功能。
异常信息传递给父类的构造函数。
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}




自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。
--------------------------------------------------------------------




异常的好处：
1,将问题进行封装。
2，京正常流程代码和问题处理代码分离，方便阅读。


异常的处理原则：
1，处理方式有两种：try和throws。
2，调用到抛出异常的功能时，抛出几个就处理几个。
可能会出现一个try对象多个catch的情况
3，多个cathch，父类catch放在最下面。
4，catch内需要定义针对性的处理方式，不要简单的定义
  printStackTrace输出语句也不要不写。
  当捕获到的异常，本功能处理不了时，可以继续在catch抛出。
  具体代码如下:
try
{
throw new AException();
}
catch(AException e)
{
throw e;
}


如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，再抛出和该功能相关的异常。




或者异常可以处理，但需要将异常产生后和本功能相关的问题
提供出去，让调用者知道，并处理。也可以将捕获的异常处理后，
转换新的异常放出。


try
{
throw new AException();
}
catch(AException e)
{
//抛出B之前先对AException进行处理。 
throw new BException();
}


比如：汇款的例子


异常注意的事项：
在子父类覆盖时：
1，子类抛出的异常必须是父类异常的子类或者是子集。
2，如果父类或者接口没有异常抛出时，子类覆盖出现异常
只能try不能抛

案例分析:

下面贴出我一个自己写的代码:

需求;
有一个长方形和圆形。
都可以获取面积，对于面积如果出现非法数值，视为获取面积出现问题
问题通过异常来表示。
现在对这个程序进行基本的设计。

class NoValueException extends RuntimeException
{
	NoValueException(String message)
	{
		spuer(message);
	}
}


interface Shape
{
	void getArea();
}


class Rec implements Shape
{
	private int len,wid;
	
	Rec(int len,int wid) //throws NoValueException
	{
		if(len<=0 或者 wid<=0)
			throw new NoValueException("出现非法值");
		this.len = len;
		this.wid = wid;
	}
	public void getArea()
	{
		System.out.println(e.toString());
	}
}


class ExceptionTest
{
	public static void main(String[] args)
	{
		
			Rec r = new Rec(-3,4);
			r.getAre();
			Circle c = new Circle(8);
			System.out.println("over");
	}
}


class Circle implements Shape
{
	private int radius;//半径
	public static final PI = 3.14;

	Circle(int radius)
	{
		//if(radius<=0)
		//throw new NoValueException("非法");//RuntimeException("非法");
		//便于阅读 使用自定义名称throws NoValueException表示。
		this.radius = radius;
	}

	public void getArea()
	{
		System.out.println(radius*radius*PI);
	}
}

(二):API  Object类.(我会具体的列举案例说明他的重要性)

(1)什么是API?

API其实就是,java提供给我们使用的类,这些类底层都是被封装额,其实很好理解,面向对象思想,我们只需要知道怎么用即可.

(1)Object类

A:object类的概述.

他是所以得类直接或者间接的父类,他就是上帝般的存在.

(2)Object类常用方法.

getClass()

 返回此 Object 的运行时类。

hashCode()

返回该对象的哈希码值。

toString()

返回该对象的字符串表示。

equalis()

指示其他某个对象是否与此对象“相等”。

接下来我局的案例,全部是实现了我自己写的bean.Student;而且我复写了Object类中的hashCode方法,

(3)Object类hashCode()方法的使用.

  hashCode()方法特点
    * a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
    * b:不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同

下面简单的举一个案例,

(3)Object类toString()方法的使用.(非常重要必须记住)

接下来我列举案例,全部是实现了我自己写的bean.Student类中;而且我复写了Object类中的toString()方法,和equals()方法,具体为什么复写,我会在案例的总结中写出!下面列出我复写他们在Object中的方法.

1,复写Object类中toString方法.

public String toString() {
	 	return "我的姓名是:"+name+"我的年龄是:"+age;
	 }	

2, 复写 Object类中equals()方法.

public boolean equals(Object obj) {
		Student s = (Student)obj;//多态
		return this.name.equals(s.name)&&this.age==s.age;
	}

(1)复写 Object类中 toString方法的案例.

package com.heima.object;

import com.heima.bean.Student;

public class ToString {     
	public static void main(String[] args) {
		Student  s = new Student("张三",23);
		String str = s.toString();
		System.out.println(s.toString());
		System.out.println(str);
		System.out.println(s);  //	系统默认调用了toString
	}
}
/*
 * 							我的分析:
 * Objet类中
 * String toString() 
          返回该对象的字符串表示。 
          
 * 下面就是Object类中toString()方法的返回值,@的左边返回的该类的字节码文件,@右边是返回这个地址值的十六进制的表现形式
 * getClass().getName() + '@' + Integer.toHexString(hashCode())
 * 
 * 所以此时我们必须在我们要使用的bean包下,该对象的类中,也就是说在Student类中复写,Object类中的toString方法
 * 让输出的结果变成我们想要的通熟易懂的格式.下面就是我在bean包下Student类中复写Object类中的toString方法的具体表达
 * 形式:
 * 
 * public String toString() {
 * 	return "我的姓名是:"+name+"我的年龄是:"+age;
 * }
 * 	
 * 
 * 							我的总结:
 * 
 * 在某些类中需要输出具体属性值得时候,在调用toString方法的时候,必须在本类中复写Object类中的toString方法,这样输出的
 * 值得格式才是我们能设置的想要看的格式
 * 具体如下;
 * 
 * Object 类中 toString()方法返回的是,该对象的hashCode的十六进制的格式,简单地说就是你看不懂的字符串.
 * 在对象类中复写的toString()方法,返回值格式可以使我们能看懂的汉字.格式如下
 * 
 * public String toString() {
 * 		return (返回值:返回你想要的任何格式)
 * }

 * 
*/

(2) 复写 Object类中equals()方法的案例

package com.heima.object;

import com.heima.bean.Student;

public class Equals {
	public static void main(String[] args) {
		Student s = new Student("李四",24);		
		Student s1 = new Student("李四",24);		
		boolean b = s==s1;
		boolean c = s.equals(s1);	//equals 比较的是属性值就是具体的值.  
		System.out.println(b);
		System.out.println(c);			
	}
}

 /*不复写结果是false,false
  * 复写后的结果是true true
  * 
  * 						个人分析
  * Object类中的equals()方法底层是依赖于==比较的,所以Objet类中的equals()方法是比较地址值,所以我对象
  * 想要比较就必须复写,Object类中的equals方法,复写后比较的是属性值,也就是说比较的是值.这样它才有存在的价值和意义
  * 
  * ==符号,本身就是运算符
  * 比较基本数据类型的时候比较的是,属性值
  * 比较引用数据类型的时候比较的是,地址值(毫无价值的存在,可以忽略)
  * 
  * 						个人总结
  * 复习后的equals 比较的是   属性值.
  *      ==      比较的是   地址值.
  * 
  * 
  */