何为泛型？
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();
}
写的有点粗糙，不足的地方希望大家指出。
谢谢！！
