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接口的使用。
标识接口的最大特征在于表示一种能力，而不会定义方法