万物鼻祖Object和Java异常

                                   

一：万物鼻祖Object

1.概述：

         类 Object是类层次结构的根类。每个类都使用Object 作为超类。所有对象（包括数组）都实现这个类的方法。

          Object是不断抽取出来的，具备着所有对象都具备的共性内容

2.方法介绍：

          (1) Object.equals()方法比较的是保存在内存中的地址，新定义的类可以重写equals方法，两个不同的类型
                 之间比较会抛出 ClassCastException 类型转换异常
                  instanceof关键字：比较是否是同类型
                 在创建类时都会默认继承Object类，并且一般会重写equals方法，equals方法重写时通常要重写hashCode方法，
                 以便于hashCode协定中声明相等对象必须具有相等的哈希码

          (2) Object.hashCode()方法返回一个对象在内存中的哈希值（10进制表示），Integer.toHexString()可将该值转换为               16进制,此方法为本地方法，有本地操作系统去实现

          (3) Object.getClass()返回Class对象，该类是运行时类，在内存中只会有一份，在Java中所有的类在内存中都有
              一个字节码文件.class,而所有的字节码文件也是对象，这些对象所属类型为Class类，如下图所示

          (4) Object.toString()方法返回 类名和哈希码 如同：
              Object.getClass().getName+object.hashCode();一般所有的子类都会重写该方法

          

二.异常

1.概述：

         所谓异常就是在运行时期发生的不正常情况，在Java中用类的形式对不正常情况进行了描述和封装,描述不正常的情况
    的类，就称为异常类，以前正常流程代码和问题处理代码相结合，而现在将正常流程代码和问题处理代码分离，提高阅读性。

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

2.最终异常问题分成了两大类：

  基类：Throwable   子类：Error和Exception，如图1

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


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


      (1)一般不可处理的：Error
                       特点：是由jvm抛出的严重性问题（即jvm也不能处理的问题，这时jvm已经不能正常运行）。
                             这种问题发生一般不针对性处理，直接修改程序


      (2)可处理的：Exception（jvm还能处理的问题，这时jvm还能正常运行）

3.该体系的特点：子类的后缀名都是父类名作为后缀，阅读性很好。

4.自定义异常类：用于解决Java中异常体系里没有的异常类

     (1)如果要让一个类成为异常类必须要继承异常体系，因为只有成为异常体系的子类才有资格具备可抛性,才可以让
        throw和throws关键字所操作
     (2)要让jvm抛出还得声明或捕获异常（throws ...）或（try catch）

5.异常分类：

  (1)编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系
     这种问题一旦出现希望在编译时就进行检测，让这种问题有对应的处理方式（声明或者捕获）
     这样的问题都可以针对性的处理
  (2)编译时不被检测异常(运行时异常)：就是Exception中的RuntimeException体系
     这种问题的方式无法让功能继续，运算无法进行，更多是调用者的原因造成的或者引发了内部状态的改变导致的。
     这种问题一般不处理，直接变异通过，在运行是直接让调用者调用时的程序直接停止，让调用者对代码进行修改。              

6.throws和throw的区别

  (1)throws使用在函数上；throw使用在函数内
  (2)throws抛出的是异常类，可以抛出多个，用逗号隔开；throw抛出的是异常对象
  (3)throws是在声明时使用，throw是在捕获是使用

7.异常处理的捕捉形式：这是可以对异常进行针对性处理的方式

  (1)具体格式是：
    try{
       需要被检测的代码
    }catch(异常类 变量){ 该变量用于接受用于发生的异常对象
       处理异常的代码,异常对象的printStackTrace()方法就是默认的异常处理机制调用异常对象的这个方法，打印信息 
       和运行时异常类似（代码出现的异常位置）
    }finally{ 通常用于关闭（释放）数据库之类的资源
     一定会执行的代码
    }
  (2)组合特点：
  (1)try catch finally(同时用,一旦try发现异常，则异常后面的代码就不执行啦，若有像数据库连接资源之类的
                       这时finally就起作用啦，这时可以再finally中关闭资源)
  (2)try catch catch catch ....(一个或多个catch,try发现异常时根据catch代码顺序捕获)
  (3)try finally(特殊情况：没有捕获异常，因此必须用throws声明异常)

8.异常处理原则：

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

9.异常注意事项：

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

10.附上一个异常代码的程序

/*
 * 异常类LanPingException 继承 Exception 是一个编译时异常类
 */
public class LanPingException extends Exception{
    LanPingException(){		
	}
	LanPingException(String msg){
		super(msg);
	}
}

/*
 * 异常类MaoYanException 继承 Exception 是一个编译时异常类
 */
public class MaoYanException extends Exception{
    MaoYanException(){
		
	}
	MaoYanException(String msg){
		super(msg);
	}
}

/*
 * 异常类NoPlanException 继承 Exception 是一个编译时异常类
 */
public class NoPlanException extends Exception {
	NoPlanException(){
		
	}
	NoPlanException(String msg){
		super(msg);
	}
}
public class Person{
		private Computer com;
		public Person(){
			this.com = new Computer();
		}
		public void startWork()throws NoPlanException{
			try{
				com.start();
			}catch(LanPingException e){
				com.reset();
				System.out.println(e.getMessage());
				System.out.println("重启成功");
				startWork();
			}catch(MaoYanException e){
				throw new NoPlanException("课时进度无法完成，原因："+e.getMessage());
			}

		}
	}
public class Computer{
	private int state = 2;
	public Computer() {}
	public Computer(int state){
		this.state = state;
	}
	public void reset(){
		this.state = 0;
	}
	public void start() throws LanPingException, MaoYanException {
		if(this.state == 0){
			System.out.println("电脑启动");
			System.out.println("开始上课");
		}
		if(this.state == 1){
			throw new LanPingException("电脑蓝屏，等待重启");
		}
		if(this.state == 2){
			throw new MaoYanException("电脑冒烟");
		}						
	}		
}

/*
 * 主类
 */
public class ExceptionTest {	
	public static void main(String[] args) { 
		Person person = new Person();
		try{
			person.startWork();
		}catch(NoPlanException e){
			System.out.println(e.getMessage());
			System.out.println("换人");
		}
	}		
}