一.今日完成

今天为了修改任务8代码,把一些基础知识重新梳理了一遍,主要内容如下:

1.继承泛型类

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。常用的继承泛型类做法如下:

//具有泛型的ClassA
public class ClassA<T>{
    T t;
}

//继承泛型
public class ClassB<T> extends ClassA<T>{
    T t;
}

//缩小泛型的范围，是准许的，但是不允许扩大泛型的范围
public class ClassC<T extends Temp> extends ClassA<T>{
    T t;
}

//具有泛型的类ClassD,泛型具有父类约束
public class ClassD<T extends Temp> {
    T t;
}

//继承ClassD,声明泛型时至少具有父类同样的约束
public class ClassE<T extends Temp> extends ClassD<T>{
    T t;
}
}

2.集合遍历Iterator/foreach

(1)Iterator接口

程序开发中经常需要遍历集合元素，Java jdk 专门提供一接口iterator. 与Collection、Map接口主要用于存储元素不同，iterator接口主要用于迭代访问（即遍历）Collection中的元素。因此iterator也被称为迭代器。

/**
 * 练习使用迭代器    遍历集合元素
 * */
public class IteratorDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList arrayList = new  ArrayList<>();
        arrayList.add("day_1");
        arrayList.add("day_2");
        arrayList.add("day_3");
        arrayList.add("day_4");
        Iterator iterator =arrayList.iterator();//获取Iterator对象
        while (iterator.hasNext()) {            //判断ArrayList中是否存在下一个元素
            Object object = (Object) iterator.next();   //取出ArrayList集合中的元素
            System.out.println(object)
}
}
}

遍历过程如下： 

i.首先调用ArrayList集合的iterator()方法获得迭代器对象。 

ii.然后 hasNext()方法判断集合中是否有下一个元素。 

iii.若存在; 则next()方法获取元素;否则,说明已到达了集合末尾，停止遍历元素。 

注意：next()方法获取元素时，必须保证获取元素的存在，否则，回抛出NoSuchElementException .

需要特别说明的是：

当通过迭代器获取ArrayList集合元素时，都会将这些元素当做Object类型看待，如果要得到特定类型的元素。需要进行强制类型转换。

(2)foreach循环

虽然Iterator可以用来遍历集合元素，但写法上比价繁琐，为了简化书写，jdk5。0开始提供了foreach循环。foreach循环是一种更加简洁的for循环，也称为增强for循环。

foreach循环用途： 

用于遍历 : 数组 或 集合

语法格式：for(容器中元素类型 临时变量 ： 容器变量 ){ 

执行语句； 

}

与for循环区别： 

不需要获取容器的长度 

不需要根据索引访问容器中的元素，但会自动遍历容器中的每一个元素。 

没有循环条件 

没有迭代语句.

foreach循环编辑集合:

public class ForEachDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LinkedList linkedList = new LinkedList<>();
        //增操作
        System.out.println("增加元素:");
        linkedList.add("stu1");
        linkedList.add("stu2");
        linkedList.add("stu3");
        linkedList.add("stu4");
        for (Object object : linkedList) {
            System.out.println(object);
        }
    }

}

 for循环遍历集合:

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LinkedList linkedList = new LinkedList<>();
        //增操作
        System.out.println("增加元素:");
        linkedList.add("stu1");
        linkedList.add("stu2");
        linkedList.add("stu3");
        linkedList.add("stu4");
        /*
        for (Object object : linkedList) {
            System.out.println(object);
        }*/
        int length ;
        length= linkedList.size();
        System.out.println(length);

        for(int i =0;i<length;i++) {
            System.out.println(linkedList.get(i));
        }
    }

}

(3)foreach遍历集合方便的同时，有其局限性： 在遍历数组或者集合时，只能访问集合里元素，不能对其进行修改。

在Iterator迭代器对集合元素遍历时，不允许其他对象引用自身的 remove（）方法进行删除！若想删除，须用迭代器自身的remove（）方法。否则会抛出异常。

3.序列化和反序列化

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，即Java对象序列号，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象，即反序列化。

把Java对象转换为字节序列的过程称为对象的序列化。

把字节序列恢复为Java对象的过程称为对象的反序列化。

对象的序列化主要有两种用途：

1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

2） 在网络上传送对象的字节序列。

(1) JDK类库中的序列化API

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。、

只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以采用默认的序列化方式 。

对象序列化包括如下步骤：

1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；

2） 通过对象输出流的writeObject()方法写对象。

对象反序列化的步骤如下：

1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；

2） 通过对象输入流的readObject()方法读取对象。

(2)实现Serializable接口

ObjectOutputStream只能对Serializable接口的类的对象进行序列化。默认情况下，ObjectOutputStream按照默认方式序列化，这种序列化方式仅仅对对象的非transient的实例变量进行序列化，而不会序列化对象的transient的实例变量，也不会序列化静态变量。

当ObjectOutputStream按照默认方式反序列化时，具有如下特点：

1） 如果在内存中对象所属的类还没有被加载，那么会先加载并初始化这个类。如果在classpath中不存在相应的类文件，那么会抛出ClassNotFoundException；

2） 在反序列化时不会调用类的任何构造方法。

如果用户希望控制类的序列化方式，可以在可序列化类中提供以下形式的writeObject()和readObject()方法。

(3)实现Externalizable接口

Externalizable接口继承自Serializable接口，如果一个类实现了Externalizable接口，那么将完全由这个类控制自身的序列化行为。Externalizable接口声明了两个方法：

public void writeExternal(ObjectOutput out) throws IOException

public void readExternal(ObjectInput in) throws IOException , ClassNotFoundException

前者负责序列化操作，后者负责反序列化操作。

在对实现了Externalizable接口的类的对象进行反序列化时，会先调用类的不带参数的构造方法，这是有别于默认反序列方式的。如果把类的不带参数的构造方法删除，或者把该构造方法的访问权限设置为private、默认或protected级别，会抛出java.io.InvalidException: no valid constructor异常。

(4)凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：

private static final long serialVersionUID;

以上serialVersionUID的取值是Java运行时环境根据类的内部细节自动生成的。如果对类的源代码作了修改，再重新编译，新生成的类文件的serialVersionUID的取值有可能也会发生变化。

显式地定义serialVersionUID有两种用途：

1） 在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；

2） 在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。

通过判断实体类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。

public class Student implements Serializable {

    private static final long serialVersionUID = -1596386419628770864L;

如何用idea自动生成实体类的serialVersionUID,参见:https://www.cnblogs.com/mjzhang/p/6970946.html

二.明日计划

继续总结梳理基础知识,把之前遗漏的知识点补充起来,跑通任务8的代码.

三.遇到问题

暂无.

四.收获

以上.

禅道进度:与之前一致,任务无进度.