//10进制------>16进制（利用查表法，并且不利用StringBuffer输出结果）
                        public static void toHex_2(int a)
                        {
                               
                                //定义一个十六制中能用到的表
                                char[] table = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
                                                                                        // 0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15
                                //定义一个用来装结果的数组
                                char[] result = new char[8];
                                //定义一个指针来指示有效位,指针从最大位开始。
                                int pos = result.length-1;
                                //当移位完a为0时，就没有必要往数组中装数据，指针也不需要移动了
                                while(a != 0)
                                {
                                                //因为四位2进制转为一位16进制，a&15即将最后4位提取出来并计算它所代表的16进制的值。
                                                //并的结果作为table的下表，正好找到所代表的16进制的值
                                                //因为最后输出结果为出c3000000，而最后值为0000003c,所以从最大位开始装数据
                                                result[pos--] = table[a&15];
                                                //a右移4位，此方法最高位不论正负都补0
                                                a = a>>>4;
                                               
                                }
                                //从当前位+1开始输出数组
                                for(int b=pos+1;b<=result.length-1;b++)
                                {
                                        System.out.print(result[b]+",")        ;
                                }
                        }       
2.//10进制转化2进制，8进制，16进制
                class Ary_Transform
                {
                        public static void main(String[] args)
                        {
                                toBin(60);
                                toBa(60);
                                toHex(60);
                        }
                       
                        //定义转换函数 num:要转换的10进制数
                        //                                                 base:转换2进制：与1&   转换8进制：与7&  转换16进制与15&
                        public static void transform(int num,int base,int move)
                        {
                                //定义查找表
                                char[] cha = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
                                //定义装数据的数组
                                char[] result = new char[32];
                                //定义指向末尾的指针
                                int pos = result.length-1;
                                while(num != 0)
                                {
                                        //查表找出对应的字符
                                        char temp = cha[num&base];
                                        //将结果存入数组中，从末尾开始存放
                                        result[pos--] = temp;
                                        /*
                                                如17：0000 0000 0000 0000 0000 0000 0001 0001
                                                转16进制   0000 0000 0000 0000 0000 0000 0001  0001 = 1
                                                                                                                0000 0000 0000 0000 0000 0000 0001 = 1
                                                                                                                所以结果为0x11;
                                        */
                                        num = num>>>move;
                                }
                                for(int x=pos+1;x<result.length;x++)
                                {
                                        System.out.print(result[x]);
                                }
                        }
                       
                        //转2进制
                        public static void toBin(int num)
                        {
                                transform(num,1,1);
                        }
                       
                        //转8进制
                        public static void toBa(int num)
                        {
                                 transform(num,7,3);
                        }
                       
                        //转16进制
                        public static void toHex(int num)
                        {
                                 transform(num,15,4);
                        }
                }
3.二维数组
        int[][] arr1 = new int[3][];                
        int[][] arr2 = new int[4][2];//二维数组中有4个一维数组，
                                                                                                                        //每一个一维数组中有2个元素
        int[][] arr2 = {{2,3},{1,4,6,7,2}};
        System.out.println(arr1[2]); //打印的是arr1[2]的地址
        System.out.println(arr1[2]);//打印结果是null
        //也是一种定义二维数组的方式
        int[][] arr4 = new int[3][];
        arr4[0] = new int[3];
        arr4[1] = new int[1];
        arr4[2]        = new int[2];
4.数组的一些定义方法。
        a.int[] x;   int x[];//都对
        b.int[][]y;        int y[][];  int[] y[];//都对
        c.int[] x,y[];//x是一维，y是二维
        判断：
        a.x[0] = y;      //error
        b.y[0] = x;      //true
        c.y[0][0] = x;   //error
        d.x[0][0] = y;   //error
        e.y[0][0] = x[0];//true
        f.x = y;               //error
5.面向对象的三个特征：继承性，封装性，多态
        以后开发就是找对象，建立对象，使用对象，维护对象的关系
6.描述事物其实就是在描述事务的属性和行为。
        定义类就是在描述事物，就是在定义属性和行为
7.java中的数据类型：基本数据类型：byte,short,char,int,long,float,double,boolean
                                                                                引用数据类型：数组，类，接口
8.成员变量和局部变量的区别？
                a.成员变量作用于整个类，局部变量作用于函数，或者语句中。
                b.成员变量在堆内存中，因为对象的存在，才在内存中存在。
                        局部变量存在于栈内存中。
9.匿名对象的使用方式一：当对象的方法只调用一次，可以用        匿名对象来完成，这样写比较简化。new Car().run();
                                                                                                        如果对一个对象进行多个成员调用，必须给这个对象起个名字。
                                                                 方式二：可以将匿名对象作为实际参数进行传递 change(new Car());
                                                                                                         public static void change(Car c) {
                                                                                                                 c.num = 4;
                                                                                                                 c.run();
                                                                                                         }
10.封装：隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
         好处：将变化隔离，便于使用，提高重用性，提高安全性。
         封装原则：将不需要对外提供的内容都隐藏起来，把属性隐藏起来，提供公共的方法对其访问。
11.private:私有，权限修饰符，用于修饰类中的成员（成员变量和成员方法）;         
         私有只有在本类中有效。
         私有只是封装的一种表现形式。
12.构造函数
                特点：1.函数名与类名相同
                                        2.不用定义返回值类型
                                        3.不可以写return语句
                作用：给对象进行初始化
                注意：多个构造函数是以重载的形式存在的。         
13.对象一建立就会调用与之对应的构造函数。
                构造函数的作用，可以用于给对象进行初始化。         
                当一个类中没有定义构造函数时，那么系统就会默认给该类加入一个空参数的构造函数。
                当在类中自定义了构造函数后，默认的构造函数则不定义。
                构造函数是在对象一建立就运行，给对象初始化。
                而一般方法是对象调用才执行
                一个对象建立构造函数只运行一次，而一般函数可以被对象调用多次。
14.什么时候定义构造函数呢？
                当分析事物时，改事物存在就具备一些特性或行为，那么将这些内容定义在构造函数中。       
         

学习一下