最近一段时间忙着学习JAVA，本来net学的也不怎么好，趁着这个机会转下方向学习JAVA。
    不过.NET core的开源还是有点搞头的，微软了解一下。
    接下来几天我也会陆续写一些内容关于线程和集合等方面，现在让我来讲一下类型转换的内容吧。
    衍生知识：
     1.基本类型比较用==  而对象比较用equals 如果改写了equals 那么也要顺便改写
    hascode 别问为什么，只是习惯。   equals是比较引用是否指向一个对象 hasCode是返回对象
    地址。
    2.System.out.println(对象)；    println方法里默认调用了toString（） 
    而toString（）默认是返回对象的完整类名+@+地址。有些对象会改写toString（）
    比如ArraysList对象的toString（）就是输出数组的每一个元素外加[]
    3.当 "=="运算符的两个操作数都是 包装器类型的引用，则是比较指向的是否是同一个对象，而如
    果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）
    5.基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上；
    引用数据类型在被床架时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储 
    在堆内存上，然后由栈上面的引用指向堆中对象、
    6.基础数据类型的比较只能使用==号，比的是数据的值，而不能使用equals；引用类型两个都可
    以，当使用 ==比较的是内存地址，使用equals比较的是堆内存里面的内容   
    7.不能把对象类型转换成不相关类的对象。  
    8.只有double和float的自动装箱代码没有使用缓存，每次都是new 新的对象，其它的6种基本类 
    型都使用了缓存策略。 使用缓存策略是因为，缓存的这些对象都是经常使用到的（如字符、-128至

    127之间的数字），防止每次自动装箱都创建一次对象的实例。
     而double、float是浮点型的，没有特别的热的（经常使用到的）数据的，缓存效果没有其它几
     种类型使用效率高。
9.判断是否具有继承关系用instanceof
A(某个类的对象引用) instanceof(操作符号) B (某个类的名称)。这个操作符最后返回的是一个布尔值。如果是false的话，则说明A对象不是类B的实例对象。相反，如果返回的值是true的话，则说明对象A是类B的实例对象。
作者：jijs
链接：https://www.jianshu.com/p/0ce2279c5691
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
先贴上一个网址：
http://cmsblogs.com/?p=70
讲的是引用类型的转换，父类引用指向子类引用之类的。
重点总结：向上转换和向下转换需要有继承关系，向下不需要强制转换，向上需要强制转换。
应用：多态。
JAVA类型可以分为两种：基本类型和引用类型 常类型
1.基本类型有8大类型：
低———————————————>高
byte,short,char-> int -> long -> float -> double
还有boolean 注意：boolean不能进行类型转换
精度大的赋值给精度小的需要强制类型转换 比如 int a=（int）12.4
byte的范围是-128~127
long的数值结尾要加L 如2000000L
float结尾要加f 如12.5f
double不需要结尾 如2.33

    2.引用类型： 类、接口类型、数组类型、枚举类型、注解类型 都是 而Object是所有引用类型的根类 意思就是说所有的类
    都可以赋值给Object。
    3.常类类型  要加final
    这个时候有必要介绍一些拆装箱：
    百度百科：装箱就是把byte ，int ，short， long ，double，float，boolean，char

这些Java的基本数据类型在定义数据类型时不声明为相对应的引用类型，在编译器的处理下自动转化为引用类型的动作就叫做装箱。
拆箱就是把Long，Integer，Double，Float 等将基本数据类型的首字母大写的相应的引用类型转化为基本数据类型的动作就叫拆箱。

讲到Integer又可以衍生到 包装类。先来介绍一下包装类再继续拆装箱，因为是连贯的知识
包装类就是指的是八个和基本数据类型对应的类统称为包装类
因为八大类型都是值类型，可是我们常常需要用的是引用类型。比如方法参数是Object

 具体的可以看一下这个博客 ：https://blog.csdn.net/hjf19790118/article/details/7081925
 我也就懒得手动敲了 人家写的更详细。
 结论：
 为了使基本类型具备对象的特性，所以出现了包装类，就可以像操作对象一样操作基本类型数据。
 接下来再来就可以介绍拆装了

原始类型byte, short, char, int, long, float, double 和 boolean 对应的封装类为Byte, Short, Character, Integer, Long, Float, Double, Boolean。
举例：装箱
Integer i = new Integer(10); 手动转换
Integer i = 10; 自动转换
这里面就涉及到了装箱 10是int类型 Integer是引用类型
相当于父类指向子类
拆箱：
Integer i = 10; //装箱
int n = i; //拆箱
将对象重新转换成基本类型
内部：装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。
Integer i1 = 100;
Integer i2 = 100;
问题： i1==i2吗？
答案是 false
JVM为了节省内存会在里面缓存[-128,127]的Integer 那么值在中间的对象其实是指向一个对象
除非超出这个范围才会重新创建一个新的对象
而 Double i1 = 100.0;
Double i2 = 100.0;
i1==i2
答案是false

参考：http://www.cnblogs.com/dolphin0520/p/3780005.html
     https://www.jianshu.com/p/0ce2279c5691
拆装箱注意：
避免 Integer integer = 10；起码得是Integer integer = new Integer(10);
尽量不要用Integer.valueOf(String str);而要用Integer.parseInt(String str)
Integer.valueOf()把String 型转换为Integer对象。因此在int countNum = ? 的情况下用   
Integer.parseInt() 很好的，直接变成int类型的值，而不用再拆箱变成基础类型了。
Integer.parseInt()把String 型转换为Int型，就是说Integer.valueOf(S)是针对包装类来说 
的，而Integer.parseInt(s) 是针对变量而言

接下来讲一下类型转换的问题：
基本类型之间的转换：
1.如果char+int  结果返回的值是int型 自动转换为int 来操作 因为int精度大 意思就是说
两个数如果进行算数运算 最后返回的结果是精度大的那一个 比如 4.0/2 返回的是2.0
2.强制转换是精度大的转换为精度小的，会有精度缺失，而小的转换为大的则没有影响 
关键是基本类型和引用类型的转换和引用类型之间的转换。
里面最基本的是父类子类的转换关系  上面已经介绍了 这就不多说了 看下面的 
再贴一个博客：https://blog.csdn.net/darxin/article/details/5163043
 Object和String的内容 明天再写 不早了  先上传保存

类型转换主要Object String 基本类型
插个题外话 介绍下String
            String zz=new String("sdf");
            String qq=new String("sdf");
            System.out.println(zz==qq);
            true or false
            答案：false；
            String zz="sdf"；
            String qq="sdf"；
            System.out.println(zz==qq);
            答案：true
            原因： 当创建string的时候每次都会从方法区的String变量池（单一性 只存在一个）
            里面查找有无该变量。如果有 那么不管是直接赋值还是new 都不会在变量池中创建新
            的变量，但是new的话 还会在堆中创建一个对象。如果没有的话 ，都会在变量池中创建
            该变量 ，而new会在堆中创建一个对象 ，直接赋值不会

            引用类型就是 句柄（指针）在栈中，   指向的对象在堆中
            题外话：static变量是在方法区中 当刚加载class的时候执行

            接下来介绍下Object 和String 基本类型的关系
            Object是对象 String也是对象 但是Object是 String的父类 
            基本类型会在从操作的时候自动进行封装箱，所以对应的是包装类也是对象 如
            int 对应Integer 
            用instanceof验证一下：
            String a=“sdf”；
            Integer b=33；
            int c=33；
            a instanceof Object                true
            b instanceof Object                true
            c instanceof Object                false

            接下来介绍转换的时候   记住  一定要有**继承关系**才可以！  牢记这点就行
            比如 
                Object xx=new Object();
                String zz="sdf";
                xx=zz;
                String qq=(String)xx;
                是可以的 
                如果是
                Object xx=new Object();
                String qq=(String)xx;
                就不行 因为Object不能强装为String
                前提必须Object是由String装箱进来的   才可以再次转换出来
                就相当于 香蕉放进笼子，拿出来还是香蕉   本质很重要。不然 xx可以为任何子
                类型 只有确定好了他本来的类型才可以转换。
                题外话：我写这篇也是因为 学习集合的时候遇到了这个问题：
                Collection collection=new ArrayList();
                collection.add("sdf");
                collection.add("qwe");
                Object[] arr=collection.toArray();
                System.out.println(arr[1]); //自动调用tostring 所以可以输出
                一般来说 要输出arr中的元素需要一个循环 for（xx）
                                                {
                                                    print((String)arr[xx]）;
                                                }//简略写
                因为toArray返回的Object类型  都是由String转换过来的
                可是 如果这样的话就有问题：
                Collection collection=new ArrayList();
                collection.add("sdf");
                collection.add("qwe");
                String[] arr=(String[])collection.toArray();
                Google和百度都说不能将Object数组转换为String数组类型  
                可是 明明这个Object是由String转换过来的 为什么不能再转换成String

                我百思不得其解，昨晚睡前冥思了下  一下子就出来了
                原来只是Object数组中的元素是String转换过来的  而Object数组本身也是个
                Object 而他并不是由String转换过来的
                意思就是Object[]这个引用并不是String[]转换过来的  所以无法再强转为
                Object[]  这就符合了 前面讲的   一定要有继承关系
                不过百度其他是这样解释的：
                java中的强制类型转换只是针对单个对象的

                题外话：
                Collection<String> collection=new ArrayList<String>();
                Collection collection=new ArrayList();
                前者用到了泛型 只能存放String类型 而后者保存形式是Obejct所以可以存放任
                何类型 for(String zz: collection) {
                            System.out.println(zz);
                        }针对第一种需要如此 第二种需要将String换成Object也是根据继承关系


                回归正题 ：先来注意下  如果Object是null的话 那可以强制转为任何类型
                Object与String之间转换：
                Object zzObject="sdf";
                String aa1=String.valueOf(zzObject);
                String aa2=（String）zzObject;

                String aa3=zzObject.toString();                     

                    强调：前提Object是String转换过来的 
                null值可以强制转换为任何java类类型，(String)null也是合法的 

                （内容来自网络）
                String转换数字：
                尽量不要用Integer.valueOf(String str);而要用Integer.parseInt(String str)

Integer.valueOf()把String 型转换为Integer对象。因此在int countNum = ? 的情况下用Integer.parseInt() 很好的，直接变成int类型的值，而不用再拆箱变成基础类型了。
Integer.parseInt()把String 型转换为Int型，
就是说Integer.valueOf(S)是针对包装类来说的，而Integer.parseInt(s) 是针对变量而言
3.基本类型与字符串之间的转换
String类中内置的方法很多，所以会有时候我们会选择将基本类型转换为字符串然后使用内置的方法
那么这里我们也分为两个方面：
（1）基本类型转换为字符串
（2）字符串转换为基本类型

（1）基本类型转换为字符串
基本类型转换为字符串的方法有三种方法：
①使用包装类中的toString()方法
②使用String类的valueOf()方法
③加入空字符

String i = Integer.toString(h);//使用包装类中的toString()方法
String i = String.valueOf(h);//使用String类的valueOf()方法
String i = h + “”;//加入空字符
（2）字符串转换为基本类型
包装类转换为基本类型有两种方法：
①使用包装类中的parseXXX()方法
②使用包装类中的valueOf()方法

int j = Integer.parseInt(i);//使用包装类中的parseXXX()方法 直接转换为数值型
int j = Integer.valueOf(i);//使用包装类中的valueOf()方法 把i转换成包装类Interger类型 然后拆箱