重拾java系列一java基础（1）

　　前言，不知不觉，从接触java到工作至今已有两年的时间，突然感觉自己的基础知识还很薄弱，有些知识虽然知道，但是停留在表面上，没有深挖，或者实践过，感觉掌握的很肤浅，而且时间一长，就觉得忘记了，我觉得这种状态实在不好，作为一名开发人员，不应该只是会用，能满足需求就满足，而不去深究为什么这样做就行，它的实质是什么，底层到底是怎么样的结构，这样才能达到知其然知其所以然，所以，我觉得在工作闲暇时间，重新对我所认识的java进行一遍梳理，总结，实践，温故而知新嘛，希望我可以坚持下来，争取突破自己！！！

　　                                                                                                                                                                                         2015年9月10日

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　      刘月

　　1.java数据类型

　　在java中，有两大类数据类型：基本类型，引用类型，就是说除了8种基本类型，都是引用类型。而基本类型细分如下：

　　byte (8位有符号整数：表示范围：-128~127 -128~-1:10000000~11111111；0~127:00000000~01111111 )

　 short  (16位有符号整数)

　　int  (32位有符号整数)默认类型

　　long  (64位有符号整数)后缀L或l

　　float  (32位有符号小数)后缀F或f

　　double  (64位有符号小数)默认类型 后缀D或d

　　char（字符型）  Java 字符采用unicode编码，每个字符是一个16位无符号（不是补码，没有负数）整数，范围0~65535

常用的字符编码对应：

　　字符          编码

'0'~'9'    48~57

'A'~'Z'    65~90

'a'~'z'     97~122

　boolean （1byte 8位，但实际上只占用了1bit,0或1即可）

　补充：对于 byte short int long 4种类型，在定义和赋值时，小类型（表示范围小的）自动转化成大类型，反过来要强转，否则编译器会报错

　　     char也可强转成int(char本身就是整数，可以直接参与运算)

　　　　随机生成A~Z随机字符demo

 public static void main(String[] args) {
          Random random = new Random();
          int n = random.nextInt(26);//[0,26)
          char c = (char)('A' + n);//计算生成 A~Z 的随机字符
        System.out.println(c);
 }

　　2.java语言特点
  Java是强类型语言：变量是强类型的
  1）变量必须用明确类型声明。
  2）变量必须初始化以后才能使用。
  3）变量有作用域，离开作用域就回收
  4）变量不能重复定义 
 
    3.进制基础
 数学：计数的规律
 10进制：是逢10进1 的计数规则
 权：10000 1000 100 10 1 每个数位上代表1的个数
 基数：10  进位规律
 数字：0 1 2 3 4 5 6 7 8 9
 权是基数的n次幂
 
 2进制: 是逢2进1 的计数规则
 权：128 64 32 16 8 4 2 1 每个数位上代表1的个数
 基数：2  进位规律
 数字：0 1
 权是基数的n次幂
 
  10   2
  0    0
  1    1
  2   10
  3   11
  4  100
  5  101
  6  110
  7  111
  8 1000
  9 1001
 10 1010
 11 1011
 12 1100
 13 1101
 14 1110
 15 1111
 
 11000000(2) = 128 + 64 = 192(10)
 11000101(2) = 128 + 64 + 4+1 = 197(10)
 
 234(10) = ?(2) = 11101010(2)
 
           128 64 32 16 8 4 2 1
 234(10) =  1   1  1  0 1 0 1 0 (2)
           106 42 10    2   0
 201(10) = ?(2)
 218(10) = ?(2)
 188(10) = ?(2)

16进制: 是逢16进1 的计数规则
 权：256 16 1 每个数位上代表1的个数
 基数：16  进位规律
 数字：0 1 2 3 4 5 6 7 8 9 a b c d e f
 权是基数的n次幂
    
    141(16) = 1*256 + 4*16 + 1 = 321(10)
   
  10    16           2
   0    00   0000 0000
   1    01   0000 0001
   2    02   0000 0010
   3    03   0000 0011
   4    04   0000 0100
   5    05   0000 0101
   6    06   0000 0110
   7    07   0000 0111
   8    08   0000 1000
   9    09   0000 1001
  10    0a   0000 1010
  11    0b   0000 1011
  12    0c   0000 1100
  13    0d   0000 1101
  14    0e   0000 1110
  15    0f   0000 1111
  16    10   0001 0000
  17    11   0001 0001
  18    12   0001 0010
  ...
  65    41   0100 0001
  66    42   0100 0010
  ...  
 192    c0   1100 0000
 193    c1   1100 0001
 ...
 255    ff   1111 1111

4.补码的概念

补码：为了成本考虑，解决负数问题，利用大数作为负数使用。（在计算机系统中，数值一律用补码来表示和存储）

一种算法规定：以4位补码为例。
 4位补码规定：
 1）高位为1的数作为负数使用
 2）计算时候如果超过4位，自动溢出舍弃
 3) 补码是有范围的数：-8 ~ 7 不能表示超范围数字
 4）在不超过范围情况下，补码满足数学运算，避免进行溢出计算
 5）补码有对称现象, 不是数学现象！
 “~” 取反运算，就是翻转0 1

~0=-1, ~1=-2, ~2=-3 ...  ~n = -(n+1)
   => ~n = -(n+1)
   => ~n = -n -1
   => 1+~n = -n (大学讲的补码公式！)
  
   根据 1+~n = -n 可以快速，计算负数补码（即一个负数的补码是其取绝对值后（正数）的补码（其本身）求反码后加1）正数的补码是其本身
   6 的补码 0110 => 取反 1001 => 加1 1010

10   2
 -8 1000
 -7 1001
 -6 1010
 -5 1011
 -4 1100
 -3 1101
 -2 1110 + 1 = 1111  数学上 ？+ 1 = -1
 -1 1111 + 1 = 0000  数学上 ？+ 1 = 0
  0 0000
  1 0001              
  2 0010         -3 + -3 = ？
  3 0011         
  4 0100          -3  1101
  5 0101          -3  1101
  6 0110        +    11 1 
  7 0111        -------------
                  -6  1010    
 
 补码的高位数推广, 推广范围
  10 4补  8位补码(byte) 32位(int)
min  --- ---------  10000000 00000000 00000000 00000000
min -1              10000000 00000000 00000000 00000001
....                ....
-129      --------  11111111 11111111 11111111 01111111
-128      10000000  11111111 11111111 11111111 10000000
-127      10000001  11111111 11111111 11111111 10000001
-126      10000010
....                ....
-10 ----  11110110
 -9 ----  11110111 
 -8 1000  11111000
 -7 1001  11111001
 -6 1010  11111010
 -5 1011  11111011
 -4 1100  11111100
 -3 1101  11111101
 -2 1110  11111110
 -1 1111  11111111  11111111 11111111 11111111 11111111
  0 0000  00000000  00000000 00000000 00000000 00000000
  1 0001  00000001  00000000 00000000 00000000 00000001             
  2 0010  00000010
  3 0011  00000011       
  4 0100  00000100      
  5 0101  00000101     
  6 0110  00000110 
  7 0111  00000111
  8 ----  00001000
  9 ----  00001001
 10 ----  00001010
 ...----  ...
126 ----  01111110
127 ----  01111111   00000000 00000000 00000000 01111111
128 ---- ---------   00000000 00000000 00000000 10000000
...
                     01111111 11111111 11111111 11111110
max       --------   01111111 11111111 11111111 11111111
       
5.关于Java的补码        
 1）Java 中数是补码，补码有正数也有负数
    （负数高位为1，正数高位是0，高位也称为符号位）
 2) Java采用补码计算，注意计算范围，避免超范围计算，避免溢出
 3）记住关键数字： -1  0  max  min 的补码
 int  重要推论： max+1=min
  -1 : 11111111 11111111 11111111 11111111  （常用数字）
  0  ：00000000 00000000 00000000 00000000
  min: 10000000 00000000 00000000 00000000
  max: 01111111 11111111 11111111 11111111
 
 4)记住推论 ：-n = ~n+1  =>  -n-1 = ~n
   System.out.println(~-6); // ~-6 = -(-6)-1 = 5
 5) 16进制，是2进制的简写形式。
    是2进制每4位对应一位的简写。
    本质上16进制就是2进制
   
 -1 : 11111111 11111111 11111111 11111111  （常用数字）
         f   f    f   f    f   f    f   f
  0  ：00000000 00000000 00000000 00000000
          0   0    0   0    0   0    0   0             
  min: 10000000 00000000 00000000 00000000
          8   0    0   0    0   0    0   0
  max: 01111111 11111111 11111111 11111111
          7   f    f   f    f   f    f   f
   
　6.java运算符

> < >= <= == !=
  && || !   & |　

位运算符：

（1）数学上的移动

>>:右移，移的是二进制形式，（非负数时）前面的空位补0；负数时，前面的空位补1；右移一次相当于除以2

<<:左移，无论正数、负数、0，后面的通通补0；左移一次相当于乘以2

（2）无符号右移：

>>>:逻辑右移，前边的空位一律补0

条件运算符：表达式？a:b              (前面的表达式为真时，整个结果为a,否则为b)

这里要强调的是：

（1）+是java中唯一的一个重载的运算符，既可以作为数学上的加法，又是作为字符串的连接使用

（2）&& || 的短路问题：例如if(a && b) 若a为假，则不再判断b的真假即可判定 a && b为假 ；同理 if (a || b) 若a为真，则整个表达式为真，不再判定b的真假

穿插小demo:

判断闰年：

 import java.util.Scanner;
 /**
  * 闰年规定
  * 注：闰年的判断公式为：
  * 1.年份能被4整除，且不能被100整除的是闰年。
  * 2.年份能被400整除的是闰年。
  * 总结：四年一润，百年不润，四百年再闰
  */
 public class LeapYear {
     public static void main(String[] args) {
         Scanner in = new Scanner(System.in);
         int year;
         System.out.print("输入年份：");
         year = in.nextInt();//2000
         if( (year%4==0 && !(year%100==0)) || (year%400==0)){
               System.out.println(year+"是闰年");
         }
     }
 }