黑马程序员 java 基础知识

（1）、java序列化

序列化就是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据

public class Person implements Serializable{
    private String name;
    private int age;
    public Person(){
        
    }
    public Person(String str, int n){
        System.out.println("Inside Person's Constructor");
        name = str;
        age = n;
    }
    String getName(){
        return name;
    }
    int getAge(){
        return age;
    }
}

public class SerializeToFlatFile {
    public static void main(String[] args) {
        SerializeToFlatFile ser = new SerializeToFlatFile();
        ser.savePerson();
        ser.restorePerson();        
    }
    
    public void savePerson(){
        Person myPerson = new Person("Jay",24);
        try {
            FileOutputStream fos = new FileOutputStream("E:\\aa.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            System.out.println("Person--Jay,24---Written");
            System.out.println("Name is: "+myPerson.getName());
            System.out.println("Age is: "+myPerson.getAge());
            
            oos.writeObject(myPerson);
            oos.flush();
            oos.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
    
    public void restorePerson() {
        try {
            FileInputStream fis = new FileInputStream("E:\\aa.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            
            Person myPerson = (Person)ois.readObject();
            System.out.println("\n--------------------\n");
            System.out.println("Person--Jay,24---Restored");
            System.out.println("Name is: "+myPerson.getName());
            System.out.println("Age is: "+myPerson.getAge());
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
}

（2）、泛型

泛型的主要目标是提高java程序的类型安全。通过知道使用泛型定义的变量的类型限制。

1，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数，比如集合 Map<String,String> map = new HashMap<String,String>，这就规定集合只能将 String 键映射到 String 值，当然也可以使用反射机制添加不同类型的元素。如：Set集合

public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub

		Set<String> set = new HashSet<String>();//定义一个Set集合
		//使用getMethod方法获得set对象的add方法和参数
		Method addMethod = set.getClass().getMethod("add", Object.class);
		String ss = "abc";
		Integer i = 123;
		//使用invoke方法进行赋值，
		addMethod.invoke(set, ss);
		addMethod.invoke(set, i);
		System.out.println(set);   //打印
	}

Map集合的话可以使用 Map<String,Object> map = new HashMap<String,Object>

2，使用泛型和不使用泛型的比较

//不使用泛型
List li = new ArrayList();
li.put(new Integer(3));
Integer i = (Integer) li.get(0);

//该代码使用泛型：

List<Integer> li = new ArrayList<Integer>();
li.put(new Integer(3));
Integer i = li.get(0);

http://www.cnblogs.com/panjun-Donet/archive/2008/09/27/1300609.html

（3）、动态绑定

运行时绑定也叫动态绑定，它是一种调用对象方法的机制。Java调用对象方法时，一般采用运行时绑定机制。

package cn.oyb.test;

class Person{
	protected String name="Person";
	public void soy(){
		System.out.println("Person");
	}
	public String getName(){
		return name;
	}
}
class Studen extends Person{
	protected String name="Studen";
	public void soy(){
		System.out.println("Studen");
	}
	public String getName(){
		return name;
	}
}
public class Test1 {
	public static void main(String[] args) {

		Person p = new Studen();//向上转型  
		p.soy();
		System.out.println(p.getName());
		
		System.out.println(p.name);//运行时（动态）绑定针对的范畴只是对象的方法
	}
}

（4）、sleep和wait的区别有：

1，这两个方法来自不同的类分别是Thread和Object

2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在

任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }
4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

（5）、值传递和引用传递