精华内容
下载资源
问答
  • 如题,在一个静态方法中写一个匿名内部类可以序列化,但是在非静态方法中却不行,为什么? 编译后的Class文件中后者的构造方法中有一个对外部类引用的参数但是前者却没有,会是这个原因吗?
  • 1-5 反序列化-内部类-待定其他知识1-序列化1-1一些资料2-内部类2-1静态内部类和非静态内部类2-1-1区别2-1-2静态内部类2-1-3成员内部类2-1-4方法内部类2-2匿名类 这里是easy的java基础面试 下面是总的阅览: java基础 ...

    上一篇:
    1-4 异常-接口和抽象类-socket通信原理-Runtime类-泛型-字节流和字符流

    这里是easy的java基础面试
    下面是总的阅览:

    java基础
    java集合
    JVM
    多线程
    mysql_数据库
    计算机网络
    nosql_redis
    设计模式
    操作系统
    消息中间件activeMq
    SSM框架面试题
    服务中间件Dubbo

    目录

    1-序列化

    1-1一些资料

    序列化1
    序列化2
    序列化3

    序列化是将对象编码成字节流以及从字节流中重新构建对象的操作。

    序列化实现原理: 
    

    serializable 该接口没用方法,只是一种标记,序列化传输时使用默认writeObject 和readObject,并通过反射调用ObjectInputStream和 ObjectOutputStream,如果没有设置serializable标识,则报错。

    序列化4

    2-内部类

    如果你不需要内部类对象与其外围类对象之间有联系,那你可以将内部类声明为 static。这通常称为嵌套类(nested class)。
    Static Nested Class 是被声明为静态(static)的内部类,它可以不依赖
    于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。想要理解 static 应用于内部类时的含义,你就必须记住,
    普通的内部类对象隐含地保存了一个引用,指向创建它的外围类对
    象。然而,当内部类是 static 的时,就不是这样了。

    嵌套类意味着:1. 嵌套类的对象,并不需要其外围类的对象。
    2. 不能从嵌套类的对象中访问非静态的外围类对象。

    如下所示代码为定义一个静态嵌套类
    public class StaticTest{
    	private static String name = "woobo";
    	private String num = "X001";
    	static class Person{ // 静态内部类可以用 public,protected,private 修饰
    		// 静态内部类中可以定义静态或者非静态的成员
    		private String address = "China";
    		Private Static String x=as;
    		public String mail = "kongbowoo@yahoo.com.cn";//内部类公有成员
    		public void display(){
    			//System.out.println(num);//不能直接访问外部类的非静态成员
    			// 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
    			System.out.println(name);//只能直接访问外部类的静态成员
    			//静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
    			System.out.println("Inner " + address);//访问本内部类成员。
    		}
    	}
    	
    	public void printInfo(){
    		Person person = new Person();
    		// 外部类访问内部类的非静态成员:实例化内部类即可
    		person.display();
    		//System.out.println(mail);//不可访问
    		//System.out.println(address);//不可访问
    		System.out.println(person.address);//可以访问内部类的私有成员
    		System.out.println(Person.x);// 外部类访问内部类的静态成员:内部类.静态成员
    		System.out.println(person.mail);//可以访问内部类的公有成员
    	}
    	public static void main(String[] args){
    		StaticTest staticTest = new StaticTest();
    		staticTest.printInfo();
    	}
    }
    
    

    在静态嵌套类内部, 不能访问外部类的非静态成员, 这是由 Java 语法中"静态方法不能直接访问非静态成员"所限定.注意, 外部类访问内部类的的成员有些特别, 不能直接访问, 但可以通过内部类实例来访问, 这是因为静态嵌套内的所有成员和方法默认为静态的了.同时注意,
    内部静态类 Person 只在类 StaticTest 范围内可见, 若在其它类中引用或初始化, 均是错误的.

    2-1静态内部类和非静态内部类

    在这里插入图片描述

    2-1-1区别

    静态内部类可以有静态成员,而非静态内部类无静态成员

    静态内部类的非静态成员可以访问外部类的静态变量,而不可以访问外类的非静态成员

    非静态内部类的非静态成员,可以访问外类的非静态成员变量(不论是private 还是成员方法。)

    Outer.Inner in = new Outer().Inner() Inner是静态内部类, -----> 成了一个顶级类

    2-1-2静态内部类

    package com.xlg.InnerClassAll.静态内部类;
    
    /**
     * @program: designpattern
     * @description: 外部类
     * @author: Mr.Wang
     * @create: 2020-09-22 14:28
     **/
    public class Outer {
    
        private int outerVariable = 1;
    
        private int commonVariable  = 2;
    
        private static int outerStaticVariable = 3;
    
        static  {
            System.out.println("outer 的静态块被执行了......");
        }
    
        /**
         *  成员方法
         */
        public void outerMethod() {
            System.out.println("我是外部类的outerMethod方法。。");
        }
        public static void outerStaticMethod() {
            System.out.println("我是外部类的outerStaticMethod方法..");
        }
    	
    	// 静态内部类 
        public static class Inner {
            private int innerVariable = 10;
            private int commonVariable = 20;
    
            static {
                System.out.println("Outer.inner的 静态块执行了");
            }
            private static int innerStaticVariable = 30;
    
            // 内部类的成员方法
            public void innerShow() {
                System.out.println("innerVariable : "  + innerVariable);
                System.out.println("内部的 commonVariable : " + commonVariable);
                System.out.println("outerStaticVariable : " + outerStaticVariable);
                outerStaticMethod();
            }
    
            // 静态方法
            public static void innerStaticShow() {
                // 被调用时会先加载Outer类
                outerStaticMethod();
                System.out.println("outerStaticVariable :" + outerStaticVariable);
            }
        }
    
        // 外部类的内部如何和内部类打交道
        public static void callInner() {
            System.out.println(Inner.innerStaticVariable);
            Inner.innerStaticShow();
        }
    }
    
    package com.xlg.InnerClassAll.静态内部类;
    
    /**
     * @program: designpattern
     * @description: 其他类使用静态内部类
     * @author: Mr.Wang
     * @create: 2020-09-22 14:38
     **/
    public class Other {
    
        public static void main(String[] args) {
            // 访问静态内部类的时候,Inner类被加载, 此时外部类未被加载。独立存在,不依赖于外部lei
            Outer.Inner.innerStaticShow();
            // 访问静态内部类的成员方法
            Outer.Inner inner = new Outer.Inner();
            inner.innerShow();
        }
    }
    
    
    执行结果: 
    
    Outer.inner的 静态块执行了
    outer 的静态块被执行了......
    我是外部类的outerStaticMethod方法..
    outerStaticVariable :3
    innerVariable : 10
    内部的 commonVariable : 20
    outerStaticVariable : 3
    我是外部类的outerStaticMethod方法..
    
    

    2-1-3成员内部类

    package com.xlg.InnerClassAll.成员内部类;
    
    /**
     * @program: designpattern
     * @description: 外部类 成员内部类的定义
     * @author: Mr.Wang
     * @create: 2020-09-22 10:58
     **/
    public class Outer {
    
        private int outerVariable = 1;
        private int commonVariable = 2;
    
        private static int outerStaticVariable = 3;
    
        /**
         * @author Mr.wang        外部类普通方法
         * @date 2020/9/22 11:00
         * @param []
         * @return void
         */
        public void outerMethod() {
            System.out.println("我是 外部类的 outerMethod 普通方法");
        }
    
        public static void outerStaticMethod() {
            System.out.println("我是 外部类的outerStaticMethod的静态方法 ");
        }
        
        /**
         * 内部类
         */
        public class Inner {
            private int commonVariable = 20;
    
            public Inner() {
    
            }
            
            /**
             * 成员方法, 访问外部类信息(属性 ,,方法)
             */
            public void innerShow() {
                //  当和外部类冲突时, 直接引用属性名, 是内部类的成员属性
                System.out.println("内部类的commonVariable: " + commonVariable);
                // 内部类访问 外部属性
                System.out.println("outerVariable : " + outerVariable);
                // 当和外部类属性名重叠时, 可通过外部类名.this.属性名 访问
                System.out.println("外部类的commonVariable: " + Outer.this.commonVariable);
                System.out.println("outerStaticVariable: " + outerStaticVariable);
                // 访问外部类的方法
                outerMethod();
                outerStaticMethod();
            }
        }
    
        /**
         *  外部类访问内部类信息
         */
        public void outerShow(){
            Inner inner = new Inner();
            inner.innerShow();
        }
    }
    
    
    package com.xlg.InnerClassAll.成员内部类;
    /**
     * @program: designpattern
     * @description: 其他类使用成员内部类
     * @author: Mr.Wang
     * @create: 2020-09-22 11:08
     **/
    public class Other {
        public static void main(String[] args) {
            // 外部类对象
            Outer outer = new Outer();
            // 创建内部类
            Outer.Inner inner =  outer.new Inner();
            inner.innerShow();
    
            outer.outerShow();
            // 或者
            Outer.Inner kk = new Outer().new Inner();
        }
    }
    
    
    执行结果: 
    
    内部类的commonVariable: 20
    outerVariable : 1
    外部类的commonVariable: 2
    outerStaticVariable: 3
    我是 外部类的 outerMethod 普通方法
    我是 外部类的outerStaticMethod的静态方法 
    内部类的commonVariable: 20
    outerVariable : 1
    外部类的commonVariable: 2
    outerStaticVariable: 3
    我是 外部类的 outerMethod 普通方法
    我是 外部类的outerStaticMethod的静态方法 
    
    

    2-1-4方法内部类

    package com.xlg.InnerClassAll.方法内部类;
    
    import java.awt.image.PackedColorModel;
    
    /**
     * @program: designpattern
     * @description: 方法外部类
     * @author: Mr.Wang
     * @create: 2020-09-22 15:05
     **/
    public class Outer {
    
        private int outerVariable = 1;
        private int commonVariable  = 2;
        private static int outerStaticVariable = 3;
    
        public void outerMethod() {
            System.out.println("我是 外部类的outerMethod方法 ");
        }
    
        public static void outerStaticMethod() {
            System.out.println("我是 外部类的outerStaticMethod方法 ");
        }
    
        /**
         *   程序的入口
         * @param args
         */
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.outerCreateMethod(100);
        }
    
        /**
         *  成员方法
         * @param value
         */
        public void outerCreateMethod(int value) {
            // 女性
            boolean sex = false;
            
            // 方法内部类 
            class Inner {
                private int innerVariable = 10;
                private int commonVariable = 20;
    
                /**
                 *   局部类方法
                 */
                public void innerShow() {
    
                    System.out.println("innerVariable : " + innerVariable);
                    // 方法的变量
                    System.out.println("是否男性: "  + sex);
                    // sex = true  报错
                    System.out.println("参数value : " + value);
                    // 调用外部类的 信息
                    System.out.println("outerVariable : "+ outerVariable);
                    System.out.println("方法内部类的 commonVariable :" + commonVariable);
                    System.out.println("外部类的 commonVariable : " + Outer.this.commonVariable);
                    System.out.println("outerStaticVariable : " + outerStaticVariable);
                    outerMethod();
                    outerStaticMethod();
                }
            }
            // 局部类 只能在方法类使用
            Inner inner = new Inner();
            inner.innerShow();
        }
    }
    
    
    结果显示: 
    
    innerVariable : 10
    是否男性: false
    参数value : 100
    outerVariable : 1
    方法内部类的 commonVariable :20
    外部类的 commonVariable : 2
    outerStaticVariable : 3
    我是 外部类的outerMethod方法 
    我是 外部类的outerStaticMethod方法 
    
    

    2-2匿名类

    几点说明: 
    

    匿名内部类是因为没有类名,可知道 匿名内部类不能定义构造器

    因为在创建匿名内部类时,会立即创建它的实例,可知匿名内部类不能是抽象类,必须实现接口或抽象父类的所有抽象方法

    匿名内部类会继承一个父类(只有一个) 或实现一个接口(只有一个),实现父类/接口中的抽象方法,/ 添加自定义方法。

    当匿名内部类和外类同名变量时,默认访问的是匿名内部类的变量(方法),要访问外部类的static变量或者static方法,则需要加外类类名

    package com.xlg.InnerClassAll.匿名内部类;
    
    /**
     * @program: designpattern
     * @description: 接口 中方法默认为 public
     * @author: Mr.Wang
     * @create: 2020-09-22 15:33
     **/
    public interface IAnimal {
        void speak();
    }
    
    package com.xlg.InnerClassAll.匿名内部类;
    
    /**
     * @program: designpattern
     * @description: 外部内,内部类
     * @author: Mr.Wang
     * @create: 2020-09-22 15:35
     **/
    public class Outer {
    
        public static IAnimal getInnerInstance(String speak) {
            return new IAnimal() {
                @Override
                public void speak() {
                    System.out.println(speak);
                }
            };
        }
    
        public static void main(String[] args) {
            // 实际山就是 一个冲写了方法的对象调用
            Outer.getInnerInstance("小狗汪汪汪!").speak();
        }
    }
    小狗汪汪汪!
    

    下一篇:
    2-1 集合

    展开全文
  • 1.序列化与反序列化 [code="java"]private Blob msg; private Serializable serialiableMsg; public Serializable getSerialiableMsg() throws SQLException { InputStream is = getMsg()....
    一、对象操作
    1.序列化与反序列化

    private Blob msg; 
    private Serializable serialiableMsg;

    public Serializable getSerialiableMsg() throws SQLException {
    InputStream is = getMsg().getBinaryStream();
    serialiableMsg = (is == null) ? null : (Serializable) SerializationUtils.serialize(is);
    return serialiableMsg;
    }

    public void setSerialiableMsg(Serializable serialiableMsg) {
    this.serialiableMsg = serialiableMsg;
    byte[] b = SerializationUtils.deserialize(serialiableMsg);
    setMsg(b == null ? null : Hibernate.createBlob(b));
    }

    2.对象转换

    ByteArrayOutputStream bs = new ByteArrayOutputStream();
    ObjectOutputStream os = new ObjectOutputStream(bs);
    os.writeObject(msg);//把对象写到os里。
    byte[] b = bs.toByteArray();//通过bs获得转变后的byte数组。
    mss.setMsg(b);

    ByteArrayInputStream bi = new ByteArrayInputStream(mss.getMsg());
    ObjectInputStream oi;
    Serializable msg=null;
    oi = new ObjectInputStream(bi);
    msg = (Serializable)oi.readObject();



    /*
    * 复制对象obj,类似于值传递,非引用
    */
    private Object cloneObject(Object obj) throws Exception{
    ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
    ObjectOutputStream out = new ObjectOutputStream(byteOut);
    out.writeObject(obj);
    ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
    ObjectInputStream in =new ObjectInputStream(byteIn);
    return in.readObject();
    }


    二、java anonymous inner class
    1.interface

    public interface Animal {
    void sound();
    }

    2.实例

    //匿名内部类new <类或接口> <类的主体>
    public class JAnonymousInnerClass {

    //定义一个内部类
    class Cat{
    private String type;
    private String color;
    public void sound(){
    System.out.println(color + " "+ type + " is shouting...");
    }
    public void setType(String type){
    this.type = type;
    }
    public void setColor(String color){
    this.color = color;
    }
    }

    /**
    * 定义一个匿名内部类:new class方式
    * @param _type
    * @param _color
    * @return
    */
    public Cat get(final String _type,final String _color){
    return new Cat(){//new Class
    {//初始化块
    setType(_type);
    setColor(_color);
    }
    public String toString(){
    return _color.concat(" ").concat(_type);
    }
    };
    }

    /**
    * 定义一个匿名内部类:new interface方式
    * @param _type
    * @return
    */
    public Animal get(final String _type){
    return new Animal(){//new Interface
    private String type = _type;
    public void sound(){
    System.out.println(type + " is shouting...");
    }
    public String toString(){return type;}
    };//注意分号
    }

    public static void main(String[] args){
    JAnonymousInnerClass jaic = new JAnonymousInnerClass();
    jaic.get("panda").sound();
    jaic.get("cat", "black").sound();

    }
    }

    3.实现回调

    public interface CallBack {
    void execute();
    }


    public void testRunTime(CallBack callBack) {
    long begin = System.currentTimeMillis();
    callBack.execute();
    long end = System.currentTimeMillis();
    System.out.println("[use time]:" + (end - begin));
    }

    public void testCallback(){
    testRunTime(new CallBack(){//匿名内部类
    public void execute() {
    try {
    Thread.sleep(20);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    };
    });
    }
    展开全文
  • 原文 :...     1.概述2.Gson的目标3.Gson的性能和扩展性4.Gson的使用者5.... 通过Maven来使用Gson ...嵌套类(包括内部类) ...泛型的序列化和反序列化 ...任意类型集合的序列化和反序列化 内...

    原文 :http://www.jianshu.com/p/558844c96fc1

     

     

    1.概述
    2.Gson的目标
    3.Gson的性能和扩展性
    4.Gson的使用者
    5.如何使用Gson

    • 通过Maven来使用Gson
    • 基本举例
    • 对象举例
    • 使用对象的好处
    • 嵌套类(包括内部类)
    • 数组举例
    • 集合举例
    • 集合的局限性
    • 泛型的序列化和反序列化
    • 任意类型集合的序列化和反序列化
    • 内置的序列化器和反序列化器
    • 定制的序列化和反序列化
      • 写一个序列化解释器
      • 写一个反序列化解释器
    • 写一个实例化工厂(Writing a Instance Creator)
      • 一个参数化类型的实例工厂(InstanceCreator for a Parameterized Type)
    • 简洁和美观的Json格式化输出
    • 支持Null对象
    • 支持版本化
    • 忽略序列化和反序列化中的字段
      • Java修饰符忽略
      • Gson's @Expose
      • 自定义忽略策略
    • JSON字段取名帮助
    • 通过经典的序列化器和反序列化器分享状态

    • 6.在设计Gson中一些问题
      7.未来Gson需要加强的方面

    概述


    Gson是一个Java库,它不仅可以把Java对象转化为Json格式,它也能将一段Json格式的字符串转化为相对于的Java对象。
    Gson适用于所有Java对象,即使是那些你不知道源代码的对象。

    Gson的目标

    • 提供简单易用的方法比如 toString() ,构造方法来转化JAVA为JSON以及反转化。
    • 提供已存在的不可修改对象转化为JSON以及反转化。
    • 提供对象的惯例表示
    • 支持任意复杂对象
    • 生成健壮 可读的JSON输出

    Gson的性能和扩展性


    这里提供我们跑测试的电脑配置(dual opteron, 8GB RAM, 64-bit Ubuntu),你可以通过使用PerformanceTest类来运行测试

    • 能正常反序列化25MB大小的字符串(参照 PerformanceTest中的disabled_testStringDeserializationPerformance)
    • 超大集合:
      • 能正常序列化一百四十万对象(参见PerformanceTest中的disabled_testLargeCollectionSerialization)
      • 能正常反序列化87000个对象的集合(参见PerformanceTest中的disabled_testLargeCollectionDeserialization)
    • Gson 1.4 将反序列的字节数组和集合限制从80KB提高到11MB。
      注意:删除 disabled_前缀 来运行这些TEST,我们使用这个前缀来阻止运行这些测试样例当我们运行Junit的测试样例。

    Gson的使用者


    Gson最初创建是为了Google内部大量的项目所使用,它现在被很多的开源项目和公司使用。

    使用Gson


    你可以使用 new Gson()方法 作为使用Gson的开始。 还有一个类GsonBuilder来创建一个Gson实例, 通过这个类你可以设置各种参数包括版本控制等等...

    当你调用Json操作时,Gson实例不会维护任何状态, 所以你可以所以复用相同的对象来重复Json的序列化和反序列操作。

    通过Maven来使用Gson


    通过Maven2/3来使用Gson, 添加下面的依赖来在Maven使用Gson
    <dependencies> <!-- Gson: Java to Json conversion --> <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>2.5</version> <scope>compile</scope> </dependency> </dependencies>
    现在你的Maven项目就可以使用Gson

    基础举例


    // SerializationGson gson = new Gson();gson.toJson(1);// ==> 1 gson.toJson("abcd"); // ==> "abcd" gson.toJson(new Long(10)); // ==> 10 int[] values = { 1 }; gson.toJson(values); // ==> [1] // Deserialization int one = gson.fromJson("1", int.class); Integer one = gson.fromJson("1", Integer.class); Long one = gson.fromJson("1", Long.class); Boolean false = gson.fromJson("false", Boolean.class); String str = gson.fromJson("\"abc\"", String.class); String anotherStr = gson.fromJson("[\"abc\"]", String.class);

    对象举例


    class BagOfPrimitives { private int value1 = 1; private String value2 = "abc"; private transient int value3 = 3; BagOfPrimitives() { // no-args constructor } } // Serialization BagOfPrimitives obj = new BagOfPrimitives(); Gson gson = new Gson(); String json = gson.toJson(obj); // ==> json is {"value1":1,"value2":"abc"}
    注意 不要序列对象中使用循环引用,因为它将会导致无限递归
    // DeserializationBagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);// ==> obj2 is just like obj

    使用对象时的一些细节

    • 最好使用private修饰符
    • 不需要通过注释来表明哪些字段需要被序列化和反序列化,默认当前类的所有字段都会被包括
    • 如果一个字段被表示为 transient(默认) 它将会被忽略 不会被包含在Json序列化或者反序列化中
    • nulls会被正确处理
    • 当序列化时 一个Null字段会在输出时被跳过
    • 当反序列化时 Json中一个缺失的实体会自动设置相对应的字段为null
    • 如果一个字段是合成的,它会被直接忽略 也不会被包含在JSON的序列化和反序列化中。
    • 在内部类 匿名类 本地类中 相对应外部类的字段会被忽略,也不会被包含在JSON的序列化和反序列化中。

    嵌套类(包括内部类)

    Gson可以非常轻松的序列化静态内部类
    Gson也可以反序列化静态类,Gson不能自动反序列化完全内部类(pure inner classes) 因为他们无参构造函数需要一个内部对象的引用,然而这个引用在反序列化的时候是不可用的,你可以这样处理这个问题,要么使这个内部类静态化,或者为他提供一个静态工厂方法(instanceCreator),举个例子:
    public class A { public String a; class B { public String b; public B() { // No args constructor for B } } }
    注意 上面的B类默认是不能被Gson序列化
    Gson 不能反序列化{"a":"abc"} 进B实例 因为B类是一个内部类 如果它被定义为静态类ClassB Gson就能反序列化字符串 另外一个解决方案就是为B类写一个静态工厂方法
    public class InstanceCreatorForB implements InstanceCreator<A.B> { private final A a; public InstanceCreatorForB(A a) { this.a = a; } public A.B createInstance(Type type) { return a.new B(); } }
    上面解决方法是可行的,但是并不建议这么使用

    数组举例


    Gson gson = new Gson(); int[] ints = {1, 2, 3, 4, 5}; String[] strings = {"abc", "def", "ghi"}; // Serialization gson.toJson(ints); // ==> [1,2,3,4,5] gson.toJson(strings); // ==> ["abc", "def", "ghi"] // Deserialization int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class); // ==> ints2 will be same as ints
    我们也支持多维数组,任何复杂元素类型。

    集合举例

    Gson gson = new Gson(); Collection<Integer> ints = Lists.immutableList(1,2,3,4,5); // SerializationString json = gson.toJson(ints); // ==> json is [1,2,3,4,5] // Deserialization Type collectionType = new TypeToken<Collection<Integer>>(){}.getType(); Collection<Integer> ints2 = gson.fromJson(json, collectionType); // ==> ints2 is same as ints
    十分可怕: 注意我们是如何定义集合的类型,但是不幸的是,在Java中没有办法获取。

    集合的局限性

    • 可以序列化集合的任意对象 但是无法从中反序列化
    • 因为使用者根本没有办法声明一个结果对象的类型
    • 当序列化的时候,集合必须是一个特定泛型
      当遵循好的JAVA编码格式, 这一切都能解释通, 也不会成为问题。

    序列化和反序列泛型类型

    当你调用 toJson(obj) Gson会调用 obj.getClass来获取序列化字段的信息。类似,你可以特意指定MyClass.class 对象在fromJson(json,MyClass.class)方法,这种方式运行正常当它不是泛型类型,然而,当对象是一个泛型类型的时候,泛型类型的信息会丢失因为Java类型的擦拭,下面这个例子来展示这一点。
    class Foo<T> { T value; } Gson gson = new Gson(); Foo<Bar> foo = new Foo<Bar>(); gson.toJson(foo); // May not serialize foo.value correctly gson.fromJson(json, foo.getClass()); // Fails to deserialize foo.value as Bar
    上面的代码不能解析Bar类型的值 ,因为当Gson调用list.getclass()来获得类的信息时候,这个方法返回一个未处理的类 Foo.class 这意味着Gson根本无法知道这是一个Foo<Bar>类型的对象,而不是一个无格式的Foo

    你可以通过为你的泛型类型指定一个正确的参数来解决这个问题,你也可以通过使用TypeToken类来处理这个问题。

    Type fooType = new TypeToken<Foo<Bar>>() {}.getType(); gson.toJson(foo, fooType); gson.fromJson(json, fooType);
    我们通常获取fooType 的方式是定义一个匿名内部类,其中包含一个getType方法返回一个全部的参数类型。

    任意类型集合的序列化和反序列化


    有时 你处理的是JSON数组包含了混合类型 例如 ['hello',5, {name:'GREETINGS',source:'guest'}]
    集合实现这种JSON格式是通过:
    Collection collection = new ArrayList(); collection.add("hello"); collection.add(5); collection.add(new Event("GREETINGS", "guest"));
    然后event类是这样定义的:
    class Event { private String name; private String source; private Event(String name, String source) { this.name = name; this.source = source; } }
    你不需要做额外的操作 当用Gson的toJson(collection)来序列化集合 获得想要的输出结果

    然而 使用fromJson(json,Collection.class)反序列化却失效, 因为Gson没办法知道如何将结果映射到类型上,Gson要求你提供一个泛型版本的集合类型在fromJson(), 所以你有三个选择:

    1. 使用 Gson's 解析API(低版本的流解析或者DOM解析) 来解析数组元素 然后使用Gson.fromJson()在对应的数组元素上,这是一个比较好的解决方案,通过一个例子来说明如何使用。
    2. 为Collection.class注册一个类型adapter,来把每一个数组成员都映射到对应的对象,这个方法不好之处在于它会混淆其他集合类型的反序列化
    3. 为MyCollectionMemberType注册一个类型adapter 通过
      Collection<MyCollectionMemberType>来使用fromjson()
      这个方法仅用于数组以顶层元素出现 或者 你可以通过集合的类型Collection<MyCollectionMemberType>来改变字段的类型
      .

    内置的序列化器和反序列化器

    Gson拥有内置的序列化器和反序列化器,为那些默认显示可能不合适的常用类,下面是这些类的清单:

    1. java.net.URL to match it with strings like "https://github.com/google/gson/"
    2. java.net.URI to match it with strings like "/google/gson/"
      你也可以找一些常用类的源代码 比如JodaTime

      定制的序列化和反序列化

      有时 默认的表示可能不是你想要的,这常常发生当处理库类的时候(DateTime, etc)Gson允许你来注册你直接的常用的序列化和反序列化, 通常通过定义这两部分来完成。
    3. Json Serialiers: 需要为对象定义序列化
    4. Json Deserializers: 为需要的类型定义反序列化
    5. InstanceCreator: 一般不需要 如果无参构造器可以用或者反序列化以及被注册

    GsonBuilder gson = new GsonBuilder(); gson.registerTypeAdapter(MyType2.class, new MyTypeAdapter()); gson.registerTypeAdapter(MyType.class, new MySerializer()); gson.registerTypeAdapter(MyType.class, new MyDeserializer()); gson.registerTypeAdapter(MyType.class, new MyInstanceCreator());

    写一个序列化器


    如下是为 JodaTime DateTime class写一个定制的序列化器
    private class DateTimeSerializer implements JsonSerializer<DateTime> { public JsonElement serialize(DateTime src, Type typeOfSrc, JsonSerializationContext context) { return new JsonPrimitive(src.toString()); } }
    Gson调用serialize方法当有DateTime对象需要序列化

    写一个反序列化器

    如下是为 JodaTime DateTime class写一个定制的反序列化器
    private class DateTimeDeserializer implements JsonDeserializer<DateTime> { public DateTime deserialize(JsonElement json, Type typeOfT,JsonDeserializationContext context) throws JsonParseException { return new DateTime(json.getAsJsonPrimitive().getAsString()); } }
    Gson调用deserialize 当它需要反序列化JSON字符串碎片进DateTime对象

    序列化器和反序列化器需要注意事项

    通常你要注册单个处理器来为所有反省类型对应一个未处理类型

    • 例如 假设你有一个ID类来表示或者转化ID(比如 外部对应内部表示)
    • Id<T> 类型有相同的序列化为所有泛型类型
    • 反序列化非常相似但是不完全相同
      • 需要调用new Id(Class<T>,String)来返回Id<T>的实例

    编写静态工厂方法

    当反序列化一个对象时,Gson需要创建以个默认类的实例,一个好的类意味着序列化和反序列化都应该有一个无参构造器

    • public private都行
      通常 静态工厂方法在你处理库类时却没有定义一个无参构造器
      `
      private class MoneyInstanceCreator implements InstanceCreator<Money> { public Money createInstance(Type type) {
       return new Money("1000000", CurrencyCode.USD);
      }
      }
      `
      类型需要是对应的泛型类型
    • 当构造器需要制定的泛型类型信息非常有用
    • 举例 如果Id类能存储那些Id被创建的类

      参数化类型的静态工厂方法


    有时候 你需要实例化的类型是参数化类型,一般,这不是一个问题 应为实际创建的实例是raw类型,如下是一个例子
    class MyList<T> extends ArrayList<T> {}class MyListInstanceCreator implements InstanceCreator<MyList<?>> { @SuppressWarnings("unchecked") public MyList<?> createInstance(Type type) { // No need to use a parameterized list since the actual instance will have the raw type anyway. return new MyList(); }}

    然后,有时你确实需要创建一个基于现有的参数化类型,如果这样的话,你可以把参数化类型传给createInstance方法 像如下:
    public class Id<T> { private final Class<T> classOfId; private final long value; public Id(Class<T> classOfId, long value) { this.classOfId = classOfId; this.value = value; }}class IdInstanceCreator implements InstanceCreator<Id<?>> { public Id<?> createInstance(Type type) { Type[] typeParameters = ((ParameterizedType)type).getActualTypeArguments(); Type idType = typeParameters[0]; // Id has only one parameterized type T return Id.get((Class)idType, 0L); }}
    在上面例子中, 一个ID类的实例是不能被创建的 如果没有传入参数化类型的真实类型。我们是通过传入方法参数type来解决这个问题,类型对象在这个例子中是 Id<Foo>的Java参数化类型的表示,真正的实例应该被绑定到Id<Foo> 因为Id类仅有一个参数化类型的参数 T 我们使用由持有Foo.class的getActualTypeArgument()零元素的类型数组。

    简练 优雅打印JSON输出格式


    默认JSON输出是由Gson提供的简练JSON格式,这意味着JSON输出格式是没有任何空格,因此 在名 、值、对象数组、对象是没有任何空格的。与此同时null字段也会在输出时被忽略(注意: null值还是会存在集合/数组对象中) 在[Null Object Support] 中有更多关于如何配置Gson来输出所有的Null值

    如果你喜欢使用优雅的打印功能,你就一定通过使用GsonBuilder要配置你的Gson实例
    JsonFormatter方法是不会通过我们的公有api暴露出去的,所以客户端是无法通过配置默认的答应设置/间距来输出格式化的JSON 现在,我们仅仅提供一个默认的JsonPrintFormatter方法 这个方法默认一场的长度是80字节 2字节缩进 4字节右边距

    下面通过一个例子展示如何配置Gson实例,使用默认的JsonPrintFormatter
    而不是JsonCompactFormatter
    Gson gson = new GsonBuilder().setPrettyPrinting().create(); String jsonOutput = gson.toJson(someObject);

    Null对象支持


    对于null对象 Gson的默认处理方式是直接忽略 这将提供更简练的输出格式,然而 客户端必须提供一个默认值当JSON格式需要转会对应的JAVA对象中是
    你可以配置Gson实例来输出null:
    Gson gson = new GsonBuilder().serializeNulls().create();
    例子如下:
    public class Foo { private final String s; private final int i; public Foo() { this(null, 5); } public Foo(String s, int i) { this.s = s; this.i = i; }}Gson gson = new GsonBuilder().serializeNulls().create();Foo foo = new Foo();String json = gson.toJson(foo);System.out.println(json);json = gson.toJson(null);System.out.println(json);
    输出结果如下:
    {"s":null,"i":5} null

    版本支持


    可以使用@Since注解来维持相同的对象的不同版本,这个注释可以被用来类、域、在未来的版本也会支持 Methods ,为了提高这个功能的影响力,你必须配置你的Gson实例忽略任何版本更好的域 对象。如果Gson实例没有设置任何版本 那么序列化和反序列化所有字段和类 并无视版本。
    public class VersionedClass { @Since(1.1) private final String newerField; @Since(1.0) private final String newField; private final String field; public VersionedClass() { this.newerField = "newer"; this.newField = "new"; this.field = "old"; }}VersionedClass versionedObject = new VersionedClass();Gson gson = new GsonBuilder().setVersion(1.0).create();String jsonOutput = gson.toJson(someObject);System.out.println(jsonOutput);System.out.println();gson = new Gson();jsonOutput = gson.toJson(someObject);System.out.println(jsonOutput);
    输出结果
    `
    {"newField":"new","field":"old"}

    {"newerField":"newer","newField":"new","field":"old"}
    `

    忽略序列化和反序列化中的字段


    Java Modifier Exclusion

    默认 你可以表示一个字段为transient 它就会被忽略, 同样一个字段被表示为static也会被忽略,如果你想加入一些transicent字段 你可以按下面来操作:
    import java.lang.reflect.Modifier;Gson gson = new GsonBuilder() .excludeFieldsWithModifiers(Modifier.STATIC) .create();
    注意 你可以使用任意多的修饰符常量给excludeFieldsWithModifiers方法 例如

    Gson gson = new GsonBuilder() .excludeFieldsWithModifiers(Modifier.STATIC, Modifier.TRANSIENT, Modifier.VOLATILE) .create();

    Gson's @Expose

    如果上面的忽略字段和类的方法对你不起作用 你也可以写自己的忽略策略并配置到Gson里面,参照 ExclusionStrategy JavaDoc 查看更多的信息
    下面的例子展示如果忽略字段被注释为@Foo 并忽略顶层类String类。
    @Retention(RetentionPolicy.RUNTIME)@Target({ElementType.FIELD})public @interface Foo { // Field tag only annotation}public class SampleObjectForTest { @Foo private final int annotatedField; private final String stringField; private final long longField; private final Class<?> clazzField; public SampleObjectForTest() { annotatedField = 5; stringField = "someDefaultValue"; longField = 1234; }}public class MyExclusionStrategy implements ExclusionStrategy { private final Class<?> typeToSkip; private MyExclusionStrategy(Class<?> typeToSkip) { this.typeToSkip = typeToSkip; } public boolean shouldSkipClass(Class<?> clazz) { return (clazz == typeToSkip); } public boolean shouldSkipField(FieldAttributes f) { return f.getAnnotation(Foo.class) != null; }}public static void main(String[] args) { Gson gson = new GsonBuilder() .setExclusionStrategies(new MyExclusionStrategy(String.class)) .serializeNulls() .create(); SampleObjectForTest src = new SampleObjectForTest(); String json = gson.toJson(src); System.out.println(json);}
    输出结果:
    {"longField":1234}

    JSON字段命名支持

    Gson支持预定义字段命名策略,包含标准JAVA字段命名(骆驼峰命名 这玩意不是微软定义的吗 以小写字母开始--- sampleFieldNameInJava),并用它来给Json字段命名。参照 FieldNamingPolicy类来获取更多关于预定义命名策略
    它也提供一套基于注释策略来允许客户端自定义各自字段基础,注意基于注释策略有字段命名确定机制 ,如果注释值提供的字段命名不合法则会包Runtime异常
    下面是一个如何使用的例子:
    `
    private class SomeObject { @SerializedName("custom_naming") private final String someField; private final String someOtherField; public SomeObject(String a, String b) { this.someField = a; this.someOtherField = b; }}SomeObject someObject = new SomeObject("first", "second");Gson gson = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE).create();String jsonRepresentation = gson.toJson(someObject);System.out.println(jsonRepresentation);

    输出结果如下:
    {"custom_naming":"first","SomeOtherField":"second"}
    `
    如果你有一个自定义的命名策略的需要(见讨论),你可以使用“serializedname注释。

    在自定义序列化和反序列化中共享状态


    有时你需要在自定义序列化/反序列化器共享状态(见讨论)。你可以使用以下三种策略来完成这个:
    1.在静态域存储分享的状态
    2.声明序列化器或者反序列化器作为父类型的内部类,并使用父类型的实例字段来存储共享状态
    3.使用Java ThreadLocal
    1.2不是线程安全,3是线程安全的


    此外gson的对象模型和数据绑定,您可以使用gson读取和写入流。您还可以将流媒体和对象模型的访问组合起来,以获得最佳的两种方法。

    在设计gson时的一些问题

    当我们设计Gson的一些讨论 详见Gson设计文档。它还包括与其他Java库,可用于JSON转换gson比较。

    Gson未来加强方向


    详情查看最新列表关于需要加强的方向,或者你想提一些新的建议,在项目网站上看到问题部分。



    文/人失格(简书作者)
    原文链接:http://www.jianshu.com/p/558844c96fc1
    著作权归作者所有,转载请联系作者获得授权,并标注“简书作者”。
    展开全文
  • 各自的用途二、为什么局部内部类和匿名内部类只能访问局部final变量?三、内部类意义根类Object中包含的方法局部变量和成员变量java运算符String装箱和拆箱序列化和反序列化 java特点 1.平台无关性 2....

    java特点

    1.平台无关性
    2.GC
    3.语言特性
    4.面向对象
    5.异常处理
    6.库类

    类加载顺序

    (1) 父类静态代码块(包括静态初始化块,静态属性,但不包括静态方法)
    (2) 子类静态代码块(包括静态初始化块,静态属性,但不包括静态方法 )
    (3) 父类非静态代码块( 包括非静态初始化块,非静态属性 )
    (4) 父类构造函数
    (5) 子类非静态代码块 ( 包括非静态初始化块,非静态属性 )
    (6) 子类构造函数

    面对对象

    一、面向对象的特性

    1.封装

    • 抽象的过程

    2.继承

    • 重用的过程
    • 子类将继承父类所有的数据域和方法(包括私有的)
      • 可以通过反射的方式暴力获得
    • 重写(Overwrite)两小两同一大原则:
      • 方法名相同,参数类型相同
      • 子类返回类型小于等于父类返回类型
      • 子类抛出异常小于等于父类抛出异常
      • 子类访问权限大于等于父类访问权限

    3.多态

    二、面向对象和面向过程的区别

    待完善

    java四种修饰符的限制范围

    类本部 本包 子类 外部类
    public
    protected ×
    default × ×
    private × × ×

    接口和抽象类的区别和联系

    1.抽象类可以有构造方法,接口中不能有构造方法。
    2.抽象类中可以有普通成员变量,接口中没有普通成员变量
    3.抽象类中可以包含非抽象的普通方法,接口中的所有方法必须都是抽象的,不能有非抽象的普通方法。
    4. 抽象类中的抽象方法的访问类型可以是public,protected和(默认类型,虽然 eclipse下不报错,但应该也不行),但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。
    5. 抽象类中可以包含静态方法,接口中不能包含静态方法
    6. 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static final类型,并且默认即为public static final类型。
    7. 一个类可以实现多个接口,但只能继承一个抽象类。

    内部类

    一、内部类有哪几种?各自的用途

    • 静态内部类:
      1. 静态内部类本身可以访问外部的静态资源,包括静态私有资源。但是不能访问非静态资源,可以不依赖外部类实例而实例化。
    • 成员内部类:
      1. 成员内部类本身可以访问外部的所有资源,但是自身不能定义静态资源,因为其实例化本身就还依赖着外部类。
    • 局部内部类:
      1. 局部内部类就像一个局部方法,不能被访问修饰符修饰,也不能被static修饰。
      2. 局部内部类只能访问所在代码块或者方法中被定义为final的局部变量。
    • 匿名内部类:
      1. 没有类名的内部类,不能使用class,extends和implements,没有构造方法。
      2. 多用于GUI中的事件处理。
      3. 不能定义静态资源
      4. 只能创建一个匿名内部类实例。
      5. 一个匿名内部类一定是在new后面的,这个匿名类必须继承一个父类或者实现一个接口。
      6. 匿名内部类是局部内部类的特殊形式,所以局部内部类的所有限制对匿名内部类也有效。

    二、为什么局部内部类和匿名内部类只能访问局部final变量?

    1.若不是final,会造成数据不一致性
    2.内部类和外部类是处于同一个级别的,内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁.
    3.当外部类的方法结束时,局部变量就会被销毁了,但是内部类对象可能还存在。

    • 就将局部变量复制了一份作为内部类的成员变量,这样当局部变量死亡后,内部类仍可以访问它,实际访问的是局部变量的”copy”

    4.将局部变量复制为内部类的成员变量时,必须保证这两个变量是一样的,也就是如果我们在内部类中修改了成员变量,方法中的局部变量也得跟着改变,怎么解决问题呢?

    • 这实际上也是一种妥协
    • 就将局部变量设置为final,对它初始化后,我就不让你再去修改这个变量,就保证了内部类的成员变量和方法的局部变量的一致性

    三、内部类意义

    待完善

    根类Object中包含的方法

    • clone();//克隆一个对象
    • equals();
    • finalize();
    • getClass();
    • notify();
    • notifyAll();
    • hashCode();
    • toString();
    • wait();

    局部变量和成员变量

    1.变量声明的位置决定变量作用域
    2.变量作用域确定可在程序中按变量名访问该变量的区域
    3.成员变量:定义在类中的变量(类或其他类中可以调用)
    4.局部变量:定义在方法中的变量(方法)
    5.区别:

    • a.作用域不同

      • 局部变量的作用域仅限于定义它的方法
      • 成员变量的作用域在整个类内部都是可见的
    • b.初始值不同

      • Java会给成员变量一个初始值
      • 不会给局部变量赋予初始值

    6.在同个方法中,不允许有同名局部变量 ,在不同方法中,可以有同名的局部变量,在同个类中,成员变量和局部变量同名时,局部变量具有更高的优先级。

    java运算符

    淡云一笔安洛三幅 ( 单目 >运算>移位>比较>按位>逻辑> 三目 > 赋值 )
    单目运算符
    算术运算符
    位移运算符
    关系运算符
    位运算符
    逻辑运算符
    三目运算符
    赋值运算符

    String

    装箱和拆箱

    装箱就是自动将基本数据类型转换为包装器类型;拆箱就是自动将包装器类型转换为基本数据类型。

    序列化和反序列化

    序列化:将数据结构转换称为二进制数据流或者文本流的过程。序列化后的数据方便在网络上传输和在硬盘上存储。
    反序列化:与序列化相反,是将二进制数据流或者文本流转换称为易于处理和阅读的数据结构的过程。

    展开全文
  • Java基础知识点.html

    2020-02-24 16:18:54
    加载器 ClassLoader 反射 Stream 流 函数式编程 Lambda 表达式 网络编程-协议 网络编程-端口 网络编程-IP 多线程 IO流-字节流 IO流-字符流 IO流-转换流 File Map HashMap 序列化和反序列化 可变参数 类型通配符 ...
  • 可以用双检索、枚举、匿名内部类实现。 分为懒汉式(延迟加载,需要再创建)和饿汉式(一开始就创建好)。 由JVM保证static修饰的内容,堆中只有一份 枚举:避免通过反序列化来创建多个对象 JVM保证枚举实例的唯一...
  • 文章目录有毒的括号等价的自性、传递性和对称性原生类型泛型序列化问题匿名内部类的继承常量表达式随机shuffle的公平性最终章,一些小知识 有毒的括号 问题:给定一个合法的 Java 表达式,添加一个注解赋值顺序的...
  • 11.11.2 实现序列化与反序列化 515 11.11.3 transient关键字 517 本章小结 518 课后习题 519 第12章 Java网络编程 521 12.1 网络编程 521 12.2 开发第一个网络程序 522 12.3 网络开发的经典模型——Echo程序...
  • 【基础】Anonymous Inner Class(匿名内部类)是否可以继承其它类?是否可以实现接口? 30 【基础】Java 中的final关键字有哪些用法? 31 【基础】内部类可以引用它的包含类(外部类)的成员吗?有没有什么限制? 31 ...
  • 内部类 反射 序列化 nIo 匿名类 包装类 优先级 引用 语言工具类库 容器类 集合 链表 map 工具类 系统类 日期类 数字类 字符串+正则 流 字符流 字节流 语言特性 继承 封装 多态 JVM 多...
  • 10.1.4 匿名类型 10.1.5 System.Tuple类型 10.2 有参属性 10.3 调用属性访问器方法时的性能 10.4 属性访问器的可访问性 10.5 泛型属性访问器方法 第11章 事件 11.1 设计要公开事件的类型 11.1.1 第一步:...
  • 实例121 匿名内部类的简单应用 实例122 静态内部类的简单应用 第2篇 Java高级应用 第6章 多线程技术 6.1 线程的基础 实例123 新建无返回值的线程 实例124 查看线程的运行状态 实例125 查看JVM中的线程名 ...
  • 实例121 匿名内部类的简单应用 实例122 静态内部类的简单应用 第2篇 Java高级应用 第6章 多线程技术 6.1 线程的基础 实例123 新建无返回值的线程 实例124 查看线程的运行状态 实例125 查看JVM中的线程名 ...
  • Java范例开发大全 (源程序)

    热门讨论 2011-04-27 07:47:22
     实例130 对象的序列化与反序列化 185  实例131 同时显示多个文件 187  实例132 生成zip压缩文件 189  实例133 解压缩zip文件 192  实例134 生成Excel文件 194  实例135 读取Excel文件中的内容 198  ...
  • java范例开发大全源代码

    热门讨论 2011-10-30 23:31:51
     实例130 对象的序列化与反序列化 185  实例131 同时显示多个文件 187  实例132 生成zip压缩文件 189  实例133 解压缩zip文件 192  实例134 生成Excel文件 194  实例135 读取Excel文件中的内容 198 ...
  • java范例开发大全

    2013-03-08 20:06:54
    实例130 对象的序列化与反序列化 185 实例131 同时显示多个文件 187 实例132 生成zip压缩文件 189 实例133 解压缩zip文件 192 实例134 生成Excel文件 194 实例135 读取Excel文件中的内容 198 实例136 生成PDF文件 ...
  • C# For Unity系列之进阶篇

    千人学习 2019-04-29 15:49:16
    "进阶篇"是在中级篇的基础之上,进一步研究与讲解关于IO操作、序列化、正则表达式、系统委托(Action、Function、Predicate等)、反射原理与特性、Linq查询表达式、多线程、线程池、任务、Socket套接字编程(Tcp与...
  • java面试题

    2018-01-01 15:35:15
    29. Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类,是否可以implements(实现)interface(接口)? 15 30. 构造器Constructor是否可被override 15 31. try {}里有一个return语句,那么紧跟在这个try...
  • Java经典编程300例(code)

    千次下载 热门讨论 2013-01-09 10:26:53
    实例068 匿名内部类的简单应用 104 实例069 静态内部类的简单应用 105 实例070 实例Class类的几种方式 107 实例071 查看类的声明 108 实例072 查看类的成员 110 实例073 查看内部类信息 112 实例074 动态设置类的...
  • 实例121 匿名内部类的简单应用 153 实例122 静态内部类的简单应用 154 第2篇 Java高级应用 第6章 多线程技术 158 6.1 线程的基础 159 实例123 新建无返回值的线程 159 实例124 查看线程的运行状态 160 实例125 查看...
  • 实例121 匿名内部类的简单应用 153 实例122 静态内部类的简单应用 154 第2篇 Java高级应用 第6章 多线程技术 158 6.1 线程的基础 159 实例123 新建无返回值的线程 159 实例124 查看线程的运行状态 160 实例125 查看...
  • JAVA 范例大全 光盘 资源

    热门讨论 2012-03-07 16:30:00
    实例27 匿名内部类 68 实例28 静态内部类 70 实例29 成员内部类 71 实例30 局部内部类 73 实例31 单例模式(Singleton) 75 实例33 开车(简单工厂模式) 77 实例33 旅游(工厂方法模式) 79 实例34 花园布局...
  • Java范例开发大全(全书源程序)

    热门讨论 2013-04-05 11:50:26
    实例130 对象的序列化与反序列化 185 实例131 同时显示多个文件 187 实例132 生成zip压缩文件 189 实例133 解压缩zip文件 192 实例134 生成Excel文件 194 实例135 读取Excel文件中的内容 198 实例136 生成PDF...
  • 在另一端,反序列化将从该流重新构造对象。 5.概述o/r mapping 的原理 利用反射,配置 将于数据库表映射 7.用sealed修饰的有什么特点 sealed 修饰符用于防止从所修饰的派生出其它。如果一个密封被指定为...
  • 5.1 的定义和实例 141 5.2 实例字段 144 5.2.1 实例字段的声明 144 5.2.2 实例字段的访问 144 5.3 实例方法 145 5.4 使用this关键字 146 5.5 访问修饰符 151 5.6 属性 153 5.6.1 ...
  • 13.11.1 对象序列化与泛型 13.11.2 .NET Remoting与泛型 13.11.3 集合与泛型 13.11.4 不支持泛型的领域 第14章 不安全代码、异常、匿名方法和迭代器 14.1 指针和不安全代码 14.1.1 允许不安全代码的编译器选项 ...
  • 序列化,串行化 ['siәriәlaiz]'(serializable adj.)(deserialize反序列化,反串行化) Socket [java] 网络套接字['sɒkit] stack n.堆栈 [stæk] (对应 heap 堆) statement 程序语句; 语句 ['steitmәnt]' n. 陈述,...
  • 1. 目录 1. 2. 目录 .........................................................................................................................................................1 JVM ........................
  • 第06节、使用匿名内部类方式创建线程 第07节、多线程常用api 第08节、守护线程与非守护线程 第09节、多线程几种状态 第10节、join方法介绍 第11节、t1、t2、t3执行顺序面试题讲解 第12节、使用多线程分批处理信息 ...

空空如也

空空如也

1 2
收藏数 31
精华内容 12
关键字:

匿名内部类反序列化