Java各种数据类型，自己学习写的笔记！！！

摘要：局部变量声明在函数内部的变量。在作用域范围内不能出现命名冲突。

java编程规范：

1.良好的标识符的命名
        保留字不能作为标识符命名：    class、public、static..., goto,const
        区分大小写：helloWorld、HelloWorld
2.良好的注释习惯
3.良好的缩进：没遇到一个代码块缩进一次（一个tab键）

变量：代表内存中的一个区域，区域可以存值

|--声明：int helloWorld;//数据类型 变量名;
|--赋值：helloWorld = 100;
|--声明+赋值：int helloWorld = 100;
|--值传递：int j = i;

8种基本数据类型：

整型数字：
    byte                        1个字节            -128~127            
                
    short                       2个字节            -2^15~2^15-1  -32768~32767   short s = 1000;(自动将int转为short,但会进行精度的校验)
    
    int                         4个字节            -2^31~2^31-1  -2147483648~2147483647
    
    long(长整型)                8个字节            -2^63~2^63-1    long l = 1000;（整型字面值默认类型int）
                                                                                        long l = 1000L;(后面跟l或L表示该字面值是long类型)
                                                                                        
浮点型：
    float(单精度浮点型)                4个字节   存储格式类似于科学计数法，1bit符号位     8bit指数    23bit尾数
                                                                                                                                1.11 * 2^111 
                                                                                                                                0              0000 0111   11000000...
                                                                            范围：1.4E-45~3.4028235E38
                                                                            
                                                                            float f = 100.01F;(后面跟f或F表示该字面值是float类型)
                                                                            float f = 1.0001E2f;//即1.0001*10^2
                                                                
    double(双精度浮点型)            8个字节   范围：4.9E-324~1.7976931348623157E308
                                                                            double d = 200.02; 或double d = 200d;(后面跟d或D表示字面值是double类型)
                                                                            double d = 2.0002E2;或double d = 2.0002E2D;
    
字符型：
    char                         char c = "A";//赋值单个字符
                                    char c = "ab";//错误的        
                                    
                                    char c = "u0041";//可以使用字符对应的unicode编码赋值
                                    //1*16^0 + 4*16^1=    65
                                    char c= 65;    //可以使用unicode编码的十进制编码赋值    
                                    
布尔型：
    boolean                    boolean b = true;   
                                    boolean b= false;
                                    

自动类型提升：

double d = 100 + 100.01;

short s = 100;
short s2 = s+1;//错误的

short s1 = 100;
short s2 = 200;
short s3 = s1 + s2;//错误的
    如果表达式中存在double类型的数据，则参与运算的数据都会自动提升为double类型;
    如果表达式中存在float类型的数据，则参与运算的数据都会自动提升为float类型;
    如果表达式中存在long类型的数据，则参与运算的数据都会自动提升为long类型;
    其余情况，则均自动提示为int类型；(byte、short、int、char)
    
注：不能将数据类型精度大的数据赋值给数据类型精度小的变量。

强制类型转换：
short s3 = (short)(s1 + s2);//在需要强制类型转换的数据前使用 (指定强制转换的类型)
//注意:强制类型转换的数据不要超过变量数据类型能够表示的范围

对象类型

     String
     String s;
     s = "a";
     s = "abbcdgfghh";
     s = "abcd" + "efgh";// "abcdefgh",+可以进行字符串的拼接
     s = "10" + 20;//1020,字符串和其他类型数据进行加法运算都是字符串拼接；
     s = 10 + 20 + "30";//3030

====================================================================================================================================

转义字符：

char c1 = "
";//换行符
char c2 = "	";//制表符
char c3 = """;//"本身是特殊字符，通过转义将其看成普通字符。
char c4 = "";
String s = "他的名字叫"小明"";

char可以进行算术运算：

char类型数据参与算术运算时，使用其编码参与运算。
char c = "A";//65
short s = 100;
short s2 = c + s;//错误的
int   s2 = c + s;//正确的
System.out.println(c+1);//66

====================================================================================================================================

运算符：

算术运算符
    +   -    *    /     %（取余）
        System.out.println("除法运算："+(100 / 49));//取整
        System.out.println("除法运算："+(100d / 49));//小数
        System.out.println("取余运算："+(100 % 49));//取余

赋值运算符
    =           int i = 100;

比较运算符
    >    <    >=     <=     ==（等于）    != (不等于)  
 

逻辑运算符
    &&(且)       ||（或）      !(非) 
    int i = 100;
    int j = 49;
    
    boolean b = (i<50) && (j>50);//当两边的布尔表达式都为true，则结果为true.
    boolean b2 = i>50 || j>50;//当两边的布尔表达式只要有一个为true，则结果为true.
    boolean b3 = !(i>50);//对布尔表达式结果取反
    
    &(且)                    |(或)
    
    &和&&  |和||的区别：
        &&  ||：具备短路特性
                        && 当第一个布尔表达式为false，则不会再运算第二个布尔表达式，直接返回结果false
                        || 当第一个布尔表达式为true，则不会再运算第二个布尔表达式，直接返回结果true
        &    |：不具备短路特性

位运算符:直接操作二进制数据
    &：
        2&1  使用二进制进行运算，上下两位都为1时才为1
    
    |：
        2|1  使用二进制进行运算，上下两位只要有一个为1则为1
        
    <<:
        左移运算符
            2<<1 //4
            每左移一位相当于乘以2
    
    >>:
        算术右移运算符
            算术右移最高位补符号位
            8>>1     //4
            -8>>1 //-4
            -8>>2 //-2
            每算术右移一位相当于除以2
    
    >>>:
        逻辑右移运算符
            逻辑右移最高位补0    
            正数进行逻辑右移和算术右移的结果一致
            8>>>1 //4
            负数进行逻辑右移：
            -8>>>1//2147483644
注：2*2 、 2>>1，位运算符相对于乘法或除法运算符效率高。

    ^:
        异或运算符  如果运算的两位不同值，则结果为1，如果相同则为0
            2^1//3
        
    ~：
        取反运算符    将二进制每位都进行取反
        ~1

三目运算符
    布尔表达式?结果1:结果2     //如果布尔表达式运算结果为ture，则返回结果1；否则返回结果2
    int age = 34;
    age>=18?"已成年":"未成年"
    
特殊用法：
    ++、--
    int a = 10;
    //a++;//等价于  a = a+1;
    ++a;    //等价于  a = a+1;
    int b = a++;
    System.out.println(a);
    System.out.println(b);
    
    ++如果前置，则先加一，后参与表达式运算
    ++如果后置，则先参与表达式运算，在加一
    
    a--;//等价于a=a-1
    
    例：
        int a = 10;
        int b = a-- + --a;// 10 + 8   18
        System.out.println(b);//18
        
  +=  -=  *=  /=  %=:
  int a = 10;
  a += 5;//a=a+5;
  System.out.println(a); 
  a -= 5;//a=a-5
  

运算符优先级：() ---> ++ -- ! ~(一元运算符) ---> * / % ---> + - ---> && ||

局部变量：声明在函数内部的变量。

特点：
    1.先赋值后使用
    2.作用域的范围：从定义位置开始到所处的代码块结束。
    3.在作用域范围内不能出现命名冲突。