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

4.JAVA泛型

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

package cn.tedu.test;

public class Test {
    public static <E> 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<T,K> {
    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<Integer,String> t=new Test1<Integer,String>();
        t.set(1, "ABC");
        t.print();
    }
}

输出如下：


泛型类.png

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

5.JAVA序列化与反序列化

1）概念：序列化：把对象转换为字节序列的过程称为对象的序列化
反序列化：把字节序列恢复为对象的过程称为对象的反序列化。
2）序列化API：
java.io.ObjectOutoutStream代表对象输出流，他的writeObject(Object obj)方法可对指定对象obj对象进行序列化，把得到的对象字节序列写入到一个目标输出流。
java.io.ObjectInputSTream代表对象输入流，他的readObject（）方法可从输入流中读取字节序列，再把他们反序列化转换为一个对象，并将其返回。
只有实现了Serlizable的接口对象才能被序列化。
\color{red}{注意：}凡是实现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

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

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 205,386评论 6赞 479
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,939评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,851评论 0赞 341
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,953评论 1赞 278
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,971评论 5赞 369
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,784评论 1赞 283
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,126评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,765评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,148评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,744评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,858评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,479评论 4赞 322
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,080评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,053评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,278评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,245评论 2赞 352
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,590评论 2赞 343