JAVA基础-泛型、序列化和反序列化、克隆

4.JAVA泛型

1）泛型方法：该方法可以在调用时接受不同的参数，根据传递给泛型方法的参数类型适当的处理每一个方法调用。注意： $\color{red}{将一个泛型方法声明为任何其他方法时，类型参数只能表示引用类型,而不是原始类型（int,double和char）}$ ，示例如下：

package cn.tedu.test;

public class Test {
    public static  void print(E[] inputArray){
        for(E e:inputArray) {
            System.out.print(e+" ");
        }
    }
    public static void main(String[] args) {
        System.out.println("字符数组：");
        Character s[]= {'A','B','C'};
        print(s);
        System.out.println("\nint数组：");
        Double d[]= {2.1,1.2,3.3};
        print(d);
        System.out.println("\ndouble数组：");
        Integer i[]= {1,2,34};
        print(i);
    }
}

输出结果如下：

泛型方法.png

2）泛型类：泛型类的类型参数声明部分也包括一个或多个类型参数，参数间用逗号隔开，注意：,示例如下：

package cn.tedu.test;

public class Test1 {
    private T t;
    private K k;
    public void set(T t,K k) {
        this.t=t;
        this.k=k;
    }
    public void print() {
        System.out.println("T:"+t+",K:"+k);
    }
    public static void main(String[] args) {
        //不可以直接使用原始类
        Test1 t=new Test1();
        t.set(1, "ABC");
        t.print();
    }
}

输出如下：

泛型类.png

3）类型通配符：一般使用？代替具体的参数，例如List在逻辑上是List、List等所有List<具体类型实参的父类>。表示该通配符所代表的类型是T类型的子类，表示该通配符所代表的类型是T类型的父类。
4）类型擦除：Java中的泛型基本上都是在编译器这个层次上实现的。在生成的Java字节码中是不包含泛型中的类型信息，使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉，这个过程就称为类型擦除。

5.JAVA序列化与反序列化

1）概念：序列化：把对象转换为字节序列的过程称为对象的序列化
反序列化：把字节序列恢复为对象的过程称为对象的反序列化。
2）序列化API：
java.io.ObjectOutoutStream代表对象输出流，他的writeObject(Object obj)方法可对指定对象obj对象进行序列化，把得到的对象字节序列写入到一个目标输出流。
java.io.ObjectInputSTream代表对象输入流，他的readObject（）方法可从输入流中读取字节序列，再把他们反序列化转换为一个对象，并将其返回。
只有实现了Serlizable的接口对象才能被序列化。
凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量，如果类中没有添加serialVersionUID,那么就会出现警告提示，通过鼠标点击警告提示，可以对其进行添加，若不进行添加该变量，之后对序列化对象进行修改时，再次运行反序列化函数将会抛出异常信息
代码实例如下：
定义一个Person对象，实现Serialiable接口

package cn.tedu.test;

import java.io.Serializable;

public class Person implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private int age;
    private String name;
    private String sex;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + ", sex=" + sex + "]";
    }
    
}

执行序列化和反序列化的功能：

package cn.tedu.test;

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;

public class SerializeTest {
    //序列化
    public static void SerializablePerson() throws FileNotFoundException, IOException {
        Person p=new Person();
        p.setAge(11);
        p.setName("张一思");
        p.setSex("男");
        ObjectOutputStream oo=new ObjectOutputStream(new FileOutputStream
                (new File("person.txt")));
        oo.writeObject(p);
        System.out.println("person对象序列化成功");
        oo.close();
    }
    
    //反序列化
    public static Person DeserializablePerson() throws FileNotFoundException, IOException, ClassNotFoundException{
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream
                (new File("person.txt")));
        Person p=(Person) ois.readObject();
        System.out.println("person对象反序列化成功！");
        ois.close();
        return p;
    }
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        SerializablePerson();
        Person p=DeserializablePerson();
        System.out.println(p.toString());
    }
}

输出结果如下：

序列化与反序列化.png

3）transient关键字阻止该变量被序列化到文件中
-在变量声明前加上transient关键字，可以阻止该变量被序列化到文件中，在反序列化后，tanslent变量值被设为初始值，如int型的是0，对象型的是null.下图中仍旧是用上述代码，将Person类中的age变量前面加入transient后，可以看到在进行序列化时并未将该变量加入到序列化文件中。结果如下所示：

transient.png

6.Java克隆

在Java中若对对象进行直接赋值时，将会直接将对象的引用复制给另外一个对象,两个不同的变量将会同为一个对象的引用，无法实现将某一个对象作为另外一个对象的初始值，之后再对其进行相应改变的功能。而要实现该功能，将会引入两种复制方式：浅复制和深复制。
*浅克隆：首先被复制的类需要实现Cloneable接口，之后覆盖clone方法，访问修饰符设为public。方法中调用super。clone()方法得到需要复制的对象，该对象贺源对象不为同一个。直接赋值复制和浅克隆的示例如下：

package day01;

public class Demo1 {
    public class Student{
        private String name;
        private int age;
        public Student(String name,int age) {
            // TODO Auto-generated constructor stub
            this.name=name;
            this.age=age;
        }
        @Override
        public String toString() {
            return "Girl [name=" + name + ", age=" + age + "]";
        }
        
    }
    public class Girl implements Cloneable{
        private String name;
        private int age;
        public Girl(String name,int age) {
            // TODO Auto-generated constructor stub
            this.name=name;
            this.age=age;
        }
        @Override
        public String toString() {
            return "Student [name=" + name + ", age=" + age + "]";
        }
        @Override
        protected Object clone() throws CloneNotSupportedException {
            // TODO Auto-generated method stub
            return (Girl)super.clone();
        }
    }
    public static void main(String[] args) throws CloneNotSupportedException {
        Demo1.Student s1=new Demo1().new Student("A",11);
        //直接赋值复制
        Demo1.Student s2=s1;
        s1.age=22;
        System.out.println("直接赋值复制：");
        System.out.println("是否相等："+(s1==s2));
        System.out.println("student1:"+s1);
        System.out.println("studnet2:"+s2);
        //浅复制
        Demo1.Girl girl1=new Demo1().new Girl("丽丽", 18);
        Demo1.Girl girl2=(Girl) girl1.clone();
        System.out.println("浅复制：");
        System.out.println("是否相等："+(girl1==girl2));
        System.out.println(girl1);
        System.out.println(girl2);
    }
}

输出结果如下:

浅复制和直接赋值复制.png

深克隆：经过浅克隆的学习，感觉只有浅克隆就足以应对我们需要的功能，那么在这样的情况下，我们为什么还需要再次增加一个深克隆的内容，我们以下面的情况为例：当我们需要在上面的girl类中增加一个属性Address类元素时，再次进行浅复制的内容，将会出现下面的结果，代码如下：

package day01;

public class Demo11 {
    public class Address{
        private String addr;

        public String getAddr() {
            return addr;
        }

        public void setAddr(String addr) {
            this.addr = addr;
        }

        @Override
        public String toString() {
            return "Address [addr=" + addr + "]";
        }
    }
    public class Girl implements Cloneable{
        private String name;
        private int age;
        private Address address;
        public String getName() {
            return name;
        }
        public int getAge() {
            return age;
        }
        public Address getAddress() {
            return address;
        }
        public void setName(String name) {
            this.name = name;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public void setAddress(Address address) {
            this.address = address;
        }
        @Override
        public String toString() {
            return "Girl [name=" + name + ", age=" + age + ", address=" + address + "]";
        }
        @Override
        protected Object clone() throws CloneNotSupportedException {
            // TODO Auto-generated method stub
            return (Girl)super.clone();
        }
    }
    public static void main(String[] args) throws CloneNotSupportedException{
        //深复制
        Demo11.Girl firGirl=new Demo11().new Girl();
        Address address=new Demo11().new Address();
        address.setAddr("浙江省");
        firGirl.setAddress(address);
        firGirl.setAge(11);
        firGirl.setName("B");
        Demo11.Girl g2=(Girl) firGirl.clone();
        address.setAddr("山西省");
        System.out.println("g2:"+g2);
        System.out.println("g1"+firGirl);
    }
}

输出结果如下：

深复制.png

由结果很明显可以看到，两个对象的地址元素同步进行了更新，这是我们需要使用深克隆来实现其功能，具体代码如下：

package day01;

public class Demo111 {
    public class Address implements Cloneable{
        private String addr;

        public String getAddr() {
            return addr;
        }

        public void setAddr(String addr) {
            this.addr = addr;
        }

        @Override
        public String toString() {
            return "Address [addr=" + addr + "]";
        }
        @Override
        protected Object clone() throws CloneNotSupportedException {
            // TODO Auto-generated method stub
            return super.clone();
        }
    }
    public class Girl implements Cloneable{
        private String name;
        private int age;
        private Address address;
        public String getName() {
            return name;
        }
        public int getAge() {
            return age;
        }
        public Address getAddress() {
            return address;
        }
        public void setName(String name) {
            this.name = name;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public void setAddress(Address address) {
            this.address = address;
        }
        @Override
        public String toString() {
            return "Girl [name=" + name + ", age=" + age + ", address=" + address + "]";
        }
        @Override
        protected Object clone() throws CloneNotSupportedException {
            // TODO Auto-generated method stub
            Girl g=(Girl) super.clone();
            g.address=(Address) this.address.clone();
            return g;
        }
    }
    public static void main(String[] args) throws CloneNotSupportedException{
        //深复制
        Demo111.Girl firGirl=new Demo111().new Girl();
        Address address=new Demo111().new Address();
        address.setAddr("浙江省");
        firGirl.setAddress(address);
        firGirl.setAge(11);
        firGirl.setName("B");
        Demo111.Girl g2=(Girl) firGirl.clone();
        address.setAddr("山西省");
        System.out.println("g2:"+g2);
        System.out.println("g1"+firGirl);
    }
}

输出结果如下：

深克隆使用.png

很明显由输出结果可知，我们需要的功能完全实现。

JAVA基础-泛型、序列化和反序列化、克隆

4.JAVA泛型

5.JAVA序列化与反序列化

6.Java克隆

你可能感兴趣的:(JAVA基础-泛型、序列化和反序列化、克隆)