java基础

一.java基础
1.java基本数据类型：
  整型：  byte(-2的7次方--2的7次方-1,占1个字节8位),包装类Byte
          short(-2的15次方--2的15次方-1,占2个字节16位),包装类Short
          int(-2的31次方--2的31次方-1,占4个字节32位),包装类Integer
          long(-2的63次方--2的63次方-1,占8个字节64位),包装类Long
  浮点型：float(占4个字节32位),包装类Float,默认为double,所以要申明为float应该这 样：float a=1.3f;去掉f就是double型了(且强制 要求，但是写成float a=1就不强制要求，实际上也是float类型)。
          dobule(占8个字节64位),包装类Double
  字符型：char(占12个字节16位),包装类Character
  布尔型：true/false,包装类Boolean
2.java操作符：
  2.1自增自减
     i++与++i的区别：前者是先赋值后自增1，后者是先自增1在赋值。比如：
     int a=1; int b=a++;  int b=++a;结果前者b=1,a=2,后者b=2,a=2
     但是当a++赋值给a后a自增的1将不起作用，如：a=a++;最后的值始终为a的初始值。
  2.2三元操作符:
     如：char a='x'; int b=0; 则true?a:b与true?a:0前者值为120 ,后者值为x
     原因：如果a,b都是变量，则char提升为int,如果b为常量，则char不提升。
  2.3运算的最终数据类型为所有数据的最高类型。
  2.4数据类型越界的处理:
     如：long a=100*10000*100000*1000;因为默认是int类型的运算，尽管最终是long型，但是运算中已经越界了，所有最后会截掉。改为long a=100*10000*100000*1000L
  2.5运算符优先级与结合性
    
3.控制流程：
  3.1对for循环一定要注意判断越界问题。
     如：for(int i=Integer.MAX_VALUE-1;i<=Integer.MAX_VALUE;i++){
           System.out.println("aaaaa");
         }
     初看值循环一次，但是当i的值为Integer.MAX_VALUE再自增就会变成最小值了，所以变成了无限循环。
  3.2 switch语句的条件为byte,short,int,char即能转化了int型的参数。不要忘了break。
4.java类的初始化：
  4.1基本数据类型的默认值（对类变量而言，局部变量会强制要求初始化）
     byte,int,short,long初始化为0，float,double初始化为0.0,布尔值为false,字符串为null,char为□
  4.2 对于数组：
      int[] a=new int[10],则a[1]为0，其他类型取默认初始值。
  4.3 “=”对基本数据类型是传值，即一个变量的改变不会影响另一个变量。
       int a=1;intb=a;则b的改变不会影响a。
      “=”对引用数据类型是传地址，一个变量的改变不会影响另一个变量。数组，对象。
       int[]a={1,2,3};int[]b=a;则b的改变会影响a。但是String例外，对String的操作会拷贝一个副本，即生成新的数据。
  4.4类初始化顺序：
     父类静态块（静态变量）>子类静态块（静态变量）>父类变量（初始化块）>父类构造方法>子类变量（子类初始化块）>子类构造方法。
     静态块（静态变量）变量（初始化块）都是以出现的顺序加载的。
     当调用类的静态变量时，该类只发生部分加载，即只加载静态块，静态变量;当调用类的构造方法或非静态方法时发生完全加载，即加载所有的数据。
     永远记住：静态数据只加载一次。
5.java访问权限控制：
  5.1   public     protected        默认      private
       完全开放  对包及子类开放   对包开放   对本类开放
     对继承而言，当子类构造器带参数时，需要显示调用super(xx)放到子类构造方法的第一句。
  5.2 final修饰类时，表示该类是不可以继承的，同时它里面的方法全部自动为final，不可重写,final修饰方法表示该方法不可重写，final修饰属性表示改属性为常量，一般修饰成静态常量。
6.java抽象类与接口的区别：
  6.1区别：前者有构造方法，后者无；前者属性的申明无限制，可以为静态非静态，后者必 须为public(默认)静态常量，可不显示申明，自动就是，且必须手动初始化；前者必须有一个抽象方法，可以有其他实现方法，后者全部是抽象方法(public,默认)，可不显示申明;前者实现了单继承，后者实现了多继承。
  6.2 子类继承来的方法必须是public,接口中属性要显示初始化。
7.java异常处理：
  7.1异常的超类是Throwable，下分Exception,Error,前者是可以处理的异常，后者是严重 的错误，不可处理，也不用捕获了。
  7.2运行时异常与一般异常区别：前者可以不用catch或throws,后者必须；前者典型的NullPointerException,ArrayIndexOutOfBoundsException后者IOException,SqlException
  7.3 try{}finally{}执行finally后退出程序,因为没有捕获异常。
  7.4自定义异常：继承Exception或RuntimeException，调用父类的super(message)

  7.5如果上层程序处理了异常，内层也处理（没有从新抛出），那么上层将捕获不到，内层如果直接抛出或者处理了从新抛出，上层才能

       捕获到。
8."="与equals()区别：
  前者比较基本数据类型时，直接比较其值，比较引用数据类型时，是比较其内存地址。
  后者默认比较内存地址，但是java类基本都重写了object类的该方法，是比较其内容。所有自定义的类要使用equals()比较内容的话就要重写该方法。
9.java集合框架：
  9.1                Collection                           Map
           List                          Set
    ArrayList LinkedList Vector   HashSet  TreeSet   HashMap  TreeMap
    List与Set的区别：前者按顺序放入，可以有重复的，后者不可重复，无序。

10.时间的处理:
  Date,SimpleDateFormat,Calendar的使用
  Calendar ca=Calendar.getInstance();
  SimpleDateFormat simp=new SimpleDateFormat("yyyy-MM-dd");
  simp.format(ca.getTime());

11.**对于String的方法，返回的都是新的字符串，和原来的无关。比如：

         String str="abcde";   str.replace("a","s");     str始终还是abcde

         String str="abcde";   str=str.replace("a","s");   str就变成sbcde

12.金额转换为RMB大写:

{
    public static void main(String[] args)
    {
        String str = "15551001000101.21";
        System.out.println(changeToBig(Double.parseDouble(str)));
    }

    public static String changeToBig(double value)
    {
        char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示
        char[] vunit = { '万', '亿' }; // 段名表示
        char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示
        // long midVal = (long)(value*100); ////存在精度问题,如0.9->0.8999...
        BigDecimal midVal = new BigDecimal(Math.round(value * 100)); // 转化成整形,替换上句
        String valStr = String.valueOf(midVal); // 转化成字符串
        String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
        String rail = valStr.substring(valStr.length() - 2); // 取小数部分
        String prefix = ""; // 整数部分转化的结果
        String suffix = ""; // 小数部分转化的结果
        // 处理小数点后面的数
        if (rail.equals("00"))
        { // 如果小数部分为0
            suffix = "整";
        } else
        {
            suffix = digit[rail.charAt(0) - '0'] + "角"
                    + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
        }
        // 处理小数点前面的数
        char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
        boolean preZero = false; // 标志当前位的上一位是否为有效0位（如万位的0对千位无效）
        byte zeroSerNum = 0; // 连续出现0的次数
        for (int i = 0; i < chDig.length; i++)
        { // 循环处理每个数字
            int idx = (chDig.length - i - 1) % 4; // 取段内位置
            int vidx = (chDig.length - i - 1) / 4; // 取段位置
            if (chDig[i] == '0')
            { // 如果当前字符是0
                preZero = true;
                zeroSerNum++; // 连续0次数递增
                if (idx == 0 && vidx > 0 && zeroSerNum < 4)
                {
                    prefix += vunit[vidx - 1];
                    preZero = false; // 不管上一位是否为0，置为无效0位
                }
            } else
            {
                zeroSerNum = 0; // 连续0次数清零
                if (preZero)
                { // 上一位为有效0位
                    prefix += digit[0]; // 只有在这地方用到'零'
                    preZero = false;
                }
                prefix += digit[chDig[i] - '0']; // 转化该数字表示
                if (idx > 0)
                    prefix += hunit[idx - 1];
                if (idx == 0 && vidx > 0)
                {
                    prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
                }
            }
        }

        if (prefix.length() > 0)
            prefix += '圆'; // 如果整数部分存在,则有圆的字样
        return prefix + suffix; // 返回正确表示
    }

}