Java异常抛出与对象深浅复制

package com.sanmao6;

import com.sanmao5.Student;

import java.util.Scanner;

/**

 *
 * 异常知识点
 *      异常捕获机制
 *      try{
 *          可能发生错误的语句
 *      }catch(错误类型 e){
 *          出错了
 *      }finally{
 *          后续处理
 *      }
 *      */
public class Error {
    public static void main(String[] args)
    /** throws Exception
     * 在main方法后面一般不加错误抛出，因为抛给main就相当于抛给JVM，所以在自定义的方法中加上错误抛出
     * 在方法后面加了throws  就不用在内部用 try 了*/{
// *************************************************************************
//       int i;
//        i=11-11;
//        try{
//            /**
//             * thow 抛出异常 主动的去抛出一个异常*/
//            throw new NumberFormatException();
//            //int j=11/i;
//        }catch (Exception e)
//        /**Exception 是所有出错类的父类
//         * （在Java中有许多错误类）*/
//        {
//            System.out.println("error");
//            System.out.println(e.toString());
//            /**
//             * java.lang.ArithmeticException: / by zero*/
//            e.printStackTrace();
//            /**
//             * java.lang.ArithmeticException: / by zero
//             * +详细错误信息*/
//            //e.printStackTrace();
//        }finally
//        /**
//         * 无论出不出错，都会执行 finally语句块*/
//        {
//            System.out.println("end!");
//        }
//        /**if(i!=0)
//            System.out.println(11/i); //被0除是错误的 在计算机中
//        else
//            System.out.println("除数不可以为零");
//        */
// *********************************************************************************

*********************************************************************************
//        Scanner cin = new Scanner(System.in);
//        String str = cin.nextLine();
//        int n;
//            try{
//                /**
//                 * try捕获异常，发生错误后，让catch块去执行，该执行的动作*/
//                n=Integer.parseInt(str);
//            }catch (Exception e){
//                /**
//                 * 解决错误*/
//                n=0;
//            }
//        System.out.println(n);
*******************************************************************************
        Student s=new Student("sanmao",123);
        Student ss=null; //ss要进行初始化
        try {
            ss= (Student) s.clone();
            /**
             * 克隆是怎样拿到其他类的私有变量呢？
             * 是通过反射机制，拿到克隆类的私有成员变量和方法
             *
             * 通过克隆产生的对象是一个新的对象，二者不是同一个对象
             * 地址值也不一样 s==ss 返回false
             *
             * 克隆属于浅拷贝  对应的概念是深拷贝
             * */
        }catch (CloneNotSupportedException e){
            //e.printStackTrace();
        }
        //System.out.println(s.toString());
        System.out.println(ss.toString());
        System.out.println(s==ss); //flase
        System.out.println(s.getName()==ss.getName());
        /**
         * s.name==ss.name 这是浅拷贝的体现，两个对象的成员变量 居然是同一个字符串*/
//***********************************************************************************


    }
}
package com.sanmao5;

/**
 */
public class Student implements Cloneable{

    /**
     * 实现Clobeable接口
     * 可以进行克隆功能,对克隆接口中的克隆方法进行初始化*/
    @Override
    public Object clone() throws CloneNotSupportedException {
        //return super.clone();
        //下边代码块是对 super.clone()的解释
        Student copy=null;
        copy=(Student)super.clone();
        /**
         * copy=(Student)super.clone();
         * 这句话是可能产生异常的但是，在方法后面
         * 有异常抛出，所以这里不报异常，留给调用这个方法的代码块去处理
         **/
        copy.setName(this.name); //浅拷贝
        copy.setAge(this.age);
        /**
         * copy.setName(new String(name))
         * copy.setAge(this.age) 简单类型跟深浅拷贝没有关系，简单类型直接赋值，深浅拷贝在于
         * 是否给新引用指定新开辟的内容，引用原来的就是浅拷贝，新开辟空间， 给新的引用，这就是深拷贝
         * */
        return copy;

    }

    private String name;
    private int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    /**
     * public String toString()
     * a:返回该对象的字符串表示。
     *
     public Stirng toString() {
     return name + "," + age;
     }
     * b:它的值等于：
     * getClass().getName() + "@" + Integer.toHexString(hashCode())
     * c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
     * B:最终版
     * 自动生成
     */
    @Override
    public String toString(){//toString(),是Object存在的非抽象方法原来是返回地址
        return "name="+name+"  age="+age;
    }

    /**
     * a:指示其他某个对象是否与此对象“相等”。
     * b:默认情况下比较的是对象的引用是否相同。
     * c:由于比较对象的引用没有意义，一般建议重写该方法。
     */
    @Override
    public boolean equals(Object obj) {
    //     return super.equals(obj);
        if(this==obj)
            return true;
        if(this==null)
            return false;
        if(!(this instanceof Student)) //对象1 instanceof 对象2, 对象2（实例）
                                       //instanceof 只比较同一类型对象
             return false;             //是不是对象1的实例
        if(!name.equals(((Student)obj).getName()))
            return false;
        if(age!=((Student)obj).getAge())
            return false;
        if(hashCode()!=obj.hashCode())
            return false;
        return true;
    }

    /**
     * * public int hashCode()
     * a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
     * b:不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。
     */
    @Override
    public int hashCode() { //数据存储方式
//        return super.hashCode();
        int hashcode=name.hashCode();
        return 37+hashcode+age;
    }

    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
}