System 类的基本使用（final、finally、finalize的区别和Cloneable接口）

说到System类一定会首先想到两个方法：

输出：System.out.println()

数组拷贝：System.arraycopy()

-完整定义：

public static void arraycopy(Object src,int srcPos,Object dest,intdestPos,int length)

在System类中定义有取得当前时间的方法：

                       public static long currentTimeMillis()

范例：利用此方法实现操作花费的时间的统计

package com.lohas.demo.runtime;

public class SystemDemo {

    public static void main(String[] args) {

        long startTime = System.currentTimeMillis();

        try {

            Thread.sleep(2000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        long endTime = System.currentTimeMillis();

        System.out.println("计算花费的时间:"+ (endTime - startTime));

    }

}

运行的结果：不是非常准确

计算花费的时间:2001

计算花费的时间:2000

        但是在System类中定义有这样的一个方法：publicstatic void gc(),但是这个方法并不是实现新的方法，而是继续调用了Rumtime类中的gc()方法。（java中垃圾回收只有Runtime类中的方法gc()）。

    在新对象实例化的时候可以利用构造方法进行相应的处理操作，但是在某一个对象回收之后，那么该如何在回收前给他一些处理的机会呢？

    在Object类中提供有一个对象回收前的释放操作：

    方法：protected void finalize()throws Throwable，

    此处可以抛出Error或Exception，但是不管抛出谁，最终都一定要被回收。

范例：观察对象回收

package com.lohas.demo.runtime;

class Person{

    public Person(){

        System.out.println("Person come on...");

    }

    @Override

    protected void finalize() throws Throwable {

        System.out.println("Person dead ...");

        throw new Exception("Person don't dead...");

    }

}

public class ObjectDemoo {

    public static void main(String[] args) {

        Person person = new Person();

        person = null;

        System.gc();

    }

}

运行结果：

Person come on...

Person dead ...

Exception("Person don't dead...")没有被执行

请解释final、finally、finalize的区别？

    Final:定义不能够被继承的父类，不能够被子类所覆写的方法、定义常量。
    Finally:是在异常处理中进行异常处理的统一出口，总是会被执行。

    Finalize:是Object类的一个方法（protected void finalize()throws Throwable），是在对象回收前进行对象收尾操作。

System总结：
    System.currentTimeMillis()

    gc永远只有一个方法，在Runtime类中定义的。

克隆的操作实现：

写代码的过程之中很少能够见到这样的操作

                    对象克隆指的就是复制对象，在Object类中提供有一个对象克隆的操作方法：

方法：protectedObject clone() throws CloneNotSupportedException

由于所有类的对象都可能出现克隆的情况，所以此方法的返回值是Object。

protected 只能够在同一包或不同包的子类中访问。

克隆方法会抛出一个异常，如果要克隆对象所在的类没有实现Cloneable接口，那么会抛出此异常。但是打开Cloneable接口之后会发现，在这个接口里面没有定义任何的操作方法，因为它是一个标识接口，表示一种能力。

范例：

package com.lohas.demo.runtime;

class Man implements Cloneable{//表示本类对象可以克隆

    private String name;

    private int age;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public Man(String name, int age) {

        this.name = name;

        this.age = age;

    }

    @Override

    public String toString() {

        return "Man{" +

"name='"+ name + '\'' +

",age=" + age +

                '}';

    }

    @Override

    protected Object clone() throwsCloneNotSupportedException {

        return super.clone(); //调用父类中的方法

    }

}

public class CloneDemoo {

    public static void main(String[] args) {

        Man man = newMan("Lohas",21);

        Man man1 = null;

        try {

            man1 = (Man) man.clone();

            man1.setAge(18);

        } catch (CloneNotSupportedException e){

            e.printStackTrace();

        }

        System.out.println(man);

        System.out.println(man1);

    }

}

运行结果:

Man{name='Lohas', age=21}

Man{name='Lohas', age=18}

 

对象克隆的关键是在于Cloneable接口的使用。

标识接口的最大特征在于表示一种能力，而不会定义方法