泛型，序列化

何为泛型？
1.JDK1.5以后推出的一种新的参数化的类型。
2.通常可以理解为一种一种编译类型，在运行时无效。
3.类型生活中的标签

**为什么使用泛型？**
1.约束类中属性类型，方法参数类型，方法返回值类型
2.提高运行时性能 List s = new ArrayList(); s.add(100); Integer 0 = (Integer)s.get(0);

**泛型常用的方式分析？**
1.泛类型：类名<泛型>  class PageObject<T>{}
2.泛型方法：<泛型>方法返回值类型
3.泛型接口：interface 接口名<泛型>{}

**泛型的通配符？**（这里的通配符可以看成一种不确定的值）
1.泛型应用是有一个特殊符号“？”，可以代表任意参数类型，注释是实参。
2.通配符单行只能应用于变量的定义

**泛型上下界问题？**
1.指定泛型下界：<? super 类型>
2.指定泛型上界：<? extends类型> 例如： List<？ Extends CharSequence> list1= new ArrayList<String >(); List<? super Intenger> list2 = new
ArrayList<Number>(); 说明： 这种上下界一般会用于方法参数变量定义，方法返回值类型定义。

**如何理解泛型类型擦除？**
1.泛型是编译时的一种类型，在运行时无效，运行时候都会变成Object类型。 

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class Test {
	public static void main(String[] args) throws Exception {
		List<String>list = new ArrayList<>();
		list.add("100");
		list.add("200");
		//list.add("300");
		//利用反射机制将300存入list集合
		//1.获取类型对象
		Class<?> c = list.getClass();
		//2.获取类中add方法对象
		Method m = c.getDeclaredMethod("add", Object.class);
		//3.执行方法对象，执行list对象的add方法，将300存入
		m.invoke(list, 300);
		System.out.println(list);
	}
}

何为序列化&反序列化
1.序列化：将对象转换为字节的过程。
2.反序列化：将字节转换为对象的过程。

序列化的应用场景？
1.网络通讯
2.数据存储（例如文件，缓存）

Java中对象的序列化与反序列化？
1.对象要实现Serializable接口。
2.添加序列化id（为反序列化提供保障）。
3.借助流对象实现序列化与反序列化。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class SysLog implements Serializable{
	private static final long serialVersionUID = -6695311142916641655L;
	private Integer id;
    private transient Integer time;
    
	public Integer getTime() {
		return time;
	}
	public void setTime(Integer time) {
		this.time = time;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	//序列化定义的一种规范方法：用于对象序列化
	private void writeObject(ObjectOutputStream out)
	throws IOException{
		System.out.println("==writeObject==");
		//对数据加密
		id=id+1;
		//对对象执行序列化
		out.defaultWriteObject();
	}
	//序列化定义的一种规范方法：用于对象反序列化
	private void readObject(ObjectInputStream in)
	throws IOException,ClassNotFoundException{
		System.out.println("==readObject==");
		//执行反序列化
		in.defaultReadObject();
		//执行解密操作
		id=id-1;
	}
	

}
public class TestSerializable01 {
	public static void main(String[] args)throws Exception {
	//1.构建一个文件对象?
	File file=new File("data.dat");
	//2.将日志对象序列化到文件
	doMethod01(file);
	//3.从文件中读取对象
	doMethod02(file);
	}
	public static void doMethod02(File file)throws Exception{
		//1.构建流对象，读取文件
		ObjectInputStream in=
		new ObjectInputStream(new FileInputStream(file));
		//2.读取对象
		SysLog log=(SysLog)in.readObject();
		System.out.println(log.getId());
		System.out.println(log.getTime());
		//3.释放资源
		in.close();
	}
    //序列化//提取方法 alt+shift+m
	private static void doMethod01(File file) throws IOException, FileNotFoundException {
		//2.1 构建日志对象
		SysLog log=new SysLog();
		log.setId(100);
		log.setTime(1000);
		//2.2 构建对象流对象
		ObjectOutputStream out=
		new ObjectOutputStream(new FileOutputStream(file));
		//2.3执行对象的序列化
		out.writeObject(log);
		//2.4.释放资源	
		out.close();
		System.out.println("序列化ok");
	}
}

Java中序列化存在安全性问题吗？ 如何解决:
1.添加writeObject（ObjectOutpuStream out）方法，对内容进行加密在执行序列化
2.添加readObject（ObjectIntpuStream in）方法，对内容进行反序列化然后在执行解密操作

/*//序列化定义的一种规范方法：用于对象序列化
    	private void writeObject(ObjectOutputStream out)
    	throws IOException{
    		System.out.println("==writeObject==");
    		//对数据加密
    		id=id+1;
    		//对对象执行序列化
    		out.defaultWriteObject();
    	}
    	//序列化定义的一种规范方法：用于对象反序列化
    	private void readObject(ObjectInputStream in)
    	throws IOException,ClassNotFoundException{
    		System.out.println("==readObject==");
    		//执行反序列化
    		in.defaultReadObject();
    		//执行解密操作
    		id=id-1;
    	}*/

Java中序列化的粒度如何控制？``
1.Transient(当少量属性不需要序列化是，使用此关键字)
2.Externalizable(当只有少量属性需要序列化时实现此接口操作，但是要序列化的对象必须是public修饰)

      
         @Override
        	public void writeExternal(ObjectOutput out) throws IOException {
        		out.writeInt(id);
        	}
        	//将需要反序列化的内容在此方法执行反序列化
        	@Override
        	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        		id=in.readInt();
        	}

写的有点粗糙，不足的地方希望大家指出。
谢谢！！