Java常用高级特性

1、isAssignableFrom和instanceof
AA.class.isAssignableFrom(BB.class)的作用是判定AA表示的类或接口是否同参数BB指定的类表示的类或接口相同，或AA是否是BB的父类。

//如:Object.class.isAssignableFrom(String.class) Object是String的超类 //所以返回true 
//String.class.isAssignableFrom(String.class) 返回true 

//instanceof左边是对象,右边是类.判断对象是否是类的实例.
//如:继承关系 
class Manager extends Employee
　　　public void doSomething(Employee e) {
　　  if ( e instanceof Mangaer){
　  　  Manager m = (Manager) e ;
　　  }
　　}

 

2、hashCode() 和equals

 

class Person02{ 
 private String name;
 private int age;
 
 public Person02(String name,int age){
  this.name=name;
  this.age=age;
 }
 
 public String toString(){
  return "姓名："+this.name+"年龄："+this.age;
 }
  
 //复写equals 和 HashCode 方法
 //HashCode 方更多的是表示对象 的地址
 public boolean equals(Object obj){
  return true;
 }
 
 public int hashCode(){
  return this.name.hashCode()+this.age*1000;
 }
}
public class AdvDemo02 {

 public static void main(String[] args) {

  Map m=new HashMap();
  
  m.put(new Person02("zhansan",30),"zhansan");
  m.put(new Person02("zhansan",20),"zhansan");
  
  //如果不覆写equals 和 HashCode 方法的话是不能查找的得到 的
  System.out.println(m.get(new Person02("zhansan",30)));
  System.out.println(m.get(new Person02("zhansan",10)));
 }
}

  

3、Serializable

//对象序列化
//对象序列化是指把对象写入到流中，对象的反序列化是指从流中恢复对象
//其优点是：即使程序运行结束，对象仍然可以保存下来。必须实现Serializable接口
//一个类想实现序列号，必须实现Serializable接口
//如果某个属性不要求进行序列化，则用关键字transient。
class Person implements Serializable
{
 private String name;
 //private int age;
 //如果某个属性不要求进行序列化
 private transient int age;
 public Person(String name,int age){ 
  this.name = name;
  this.age = age ;
 }
 public String toString(){
  return this.name+" "+this.age ;
 }
} 

//Serializable接口
//此接口只是一个声明接口，表示实现此接口的类可以被实例化
//如果某个属性不要求进行序列化，则用关键字transient。
public class SerializableTest 
{
 public static void main(String args[])throws Exception{
  Person p = new Person("liuwei",23);
  //序列化。谁为ObjectOutputStream对象实例化就向哪里输出
  ObjectOutputStream oos = null;
  oos = new ObjectOutputStream(new FileOutputStream(new File("c:\\123.txt")));
  oos.writeObject(p);
  
  //反序列化
  ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("c:\\123.txt")));
  Person p1 = (Person)ois.readObject();
  System.out.println(p1);
  ois.close();
  oos.close();
 }
}

 

4、Cloneable

//克隆方法的使用,必须实现Cloneable接口
//而且必须覆写Object类的clone方法
//protected Object clone()throws CloneNotSupportedException
//Cloneable也是一个标识接口。和类似于Serializable
class Person03 implements Cloneable{
 
 public String name; 
 private int age;
 
 public Person03(String name,int age){
  this.name=name;
  this.age=age;
 }
 
 public String toString(){
  return "姓名："+this.name+" 年龄："+this.age;
 }
 
 //扩大父类的权限为公共的
 @Override
 public Object clone()
  throws CloneNotSupportedException{
  
  return super.clone();
 } 
}
public class AdvDemo03 {

 public static void main(String[] args) throws Exception {

  Person03 p=new Person03("zhansan",12);
  Person03 p2=(Person03) p.clone();
  p2.name="lisi";
  
  System.out.println(p);
  System.out.println(p2);
  //System.out.println(p2.age);
 }
}

 

5、Comparable,Comparator和Collections,Arrays

java.util.Collections是集合类帮助类,Arrays是j数组帮助类.定义了大量的静态方法.其中sort排序功能最为常用.
Conlleciions.sort(List list);
Arrays.sort(Object [] o);
(1).Comparator接口
通过java.util.Collections.sort(List list，Comparator c)里临时声明的Comparator
可以方便的实现顺序或者倒序排列。

  Collections.sort(imageList, new Comparator() {
    public int compare(Object a, Object b) {   //要实现public int compare(Object a, Object b)方法
      int orderA = Integer.parseInt( ( (Image) a).getSequence());
      int orderB = Integer.parseInt( ( (Image) b).getSequence());
      return orderA - orderB;
    }
  });

 (2).Comparable接口
Comparable要实现 public int compareTo(Object arg0) {]
返回值大于0,则this被排在后面。arg0放在前面。
可以参看Integer 的compareTo()方法：

    public int compareTo(Integer anotherInteger) {
      int thisVal = this.value;
      int anotherVal = anotherInteger.value;
      return (thisVal<anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));
    }

 如果要进行排序的话调用Arrays.sort(IntegerArrays)或Connection.sort(IntegerList)就行了.
注意:Collections是针对Connection接口的,Arrays是针对数组的
     Comparable是在要排序的类中添加compareTo方法,Comparator是另建一个排序类.

 

6.java反射机制Reflection
关于反射机制会另外再讲