Java-基础 数据类型

变量
    变量的概念：记录一个可变的数据
    使用流程：
        1、声明：
            语法：数据类型 变量名；
        2、赋值：
            语法：变量名 = 值；
            注意：①等号两边数据类型要一致
                  ②变量第一次赋值称为变量的初始化
        3、使用：直接使用变量名
        特殊用法：
            1、一次可以声明多个变量
                注意：变量的数据类型一致
                语法：数据类型 变量名1,变量名2,.....;
            2、变量在声明时，可以第一次赋值
        注意：同一个作用域中，变量名不能重复
数据类型：Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
    基本数据类型：
        1、byte：字节、占1字节
            byte 数据类型是8位、有符号的，以二进制补码表示的整数；
            最小值是 -128（-2^7）；
            最大值是 127（2^7-1）；
            默认值是 0；
            byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
            例子：byte a = 100，byte b = -50。
        2、short：短整型、占2字节
            short 数据类型是 16 位、有符号的以二进制补码表示的整数
            最小值是 -32768（-2^15）；
            最大值是 32767（2^15 - 1）；
            Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
            默认值是 0；
            例子：short s = 1000，short r = -20000。
        3、int：（默认）占4字节
            int 数据类型是32位、有符号的以二进制补码表示的整数；
            最小值是 -2,147,483,648（-2^31）；
            最大值是 2,147,483,647（2^31 - 1）；
            一般地整型变量默认为 int 类型；
            默认值是 0 ；
            例子：int a = 100000, int b = -200000。
        4、long：长整型、占8字节
            long 数据类型是 64 位、有符号的以二进制补码表示的整数；
            最小值是 -9,223,372,036,854,775,808（-2^63）；
            最大值是 9,223,372,036,854,775,807（2^63 -1）；
            这种类型主要使用在需要比较大整数的系统上；
            默认值是 0L；
            例子： long a = 100000L，Long b = -200000L。
            "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写；
            注意：如果超出int取值范围的数要加1或L。
        5、float：单精度浮点型、占4字节
            float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
            float 在储存大型浮点数组的时候可节省内存空间；
            默认值是 0.0f；
            浮点数不能用来表示精确的值，如货币；
            例子：float f1 = 234.5f；
            注意：如果需要将小数设定为float型，需要给小数后加f或F。
        6、double：双精度浮点型（默认）、占8字节
            数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；
            浮点数的默认类型为 double 类型；
            double类型同样不能表示精确的值，如货币；
            默认值是 0.0d；
            例子：
                double  d1  = 7D ;
                double  d2  = 7.; 
                double  d3  = 8.0; 
                double  d4  = 8.D; 
                double  d5  = 12.9867; 
            7是一个 int字面量，而7D、7. 和 8.0 是 double 字面量。
        7、boolean：布尔型、true（真）false（假）
            boolean数据类型表示一位的信息；
            只有两个取值：true 和 false；
            这种类型只作为一种标志来记录 true/false 情况；
            默认值是 false；
            例子：boolean one = true。
        8、char：Java中的字符要使用''包裹，如'a','中','1'
            char 类型是一个单一的 16 位 Unicode 字符；
            最小值是 \u0000（十进制等效值为 0）；
            最大值是 \uffff（即为 65535）；
            char 数据类型可以储存任何字符；
            例子：char letter = 'A';。
    引用数据类型：
        在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
        对象、数组都是引用数据类型。
        所有引用类型的默认值都是null。
        一个引用变量可以用来引用任何与之兼容的类型。
        例子：Site site = new Site("Runoob")。
转义字符：
    \'：单引号
    \"：双引号
    \\：\
    \t：制表符
    \n：换行符
类型转换：
    基本数据类型转换    
        小类型转换为大类型,会自动转换,没有风险    
        大类型转小类型,要强制转换,有风险        
            强制类型转换语法：转换后的数据类型 变量名 = (转换后的数据类型) 要转换的数据;            
    基本数据类型转换为字符串    
        基本数据类+字符串都是字符串
运算符：
    字符串连接符：所有基本数据类型使用+与字符串拼接，结果都是字符串。
    算术运算符：
        +    加法——相加运算符两侧的值
        -    减法——左操作数减去有操作数
        *    乘法——相乘操作符两侧的值
        /    除法——左操作数除以右操作数
        %    取余——左操作数除以右操作数的余数
        ++    自增：操作数的值增加1
        --    自减：操作数的值减少1
        public class Demo01 {
            //算术运算符
            public static void main(String[] args) {
                int a = 10;
                int b = 20;
                int c = 25;
                int d = 25;
                System.out.println("a + b = " + (a + b) );
                System.out.println("a - b = " + (a - b) );
                System.out.println("a * b = " + (a * b) );
                System.out.println("b / a = " + (b / a) );
                System.out.println("b % a = " + (b % a) );
                System.out.println("c % a = " + (c % a) );
                System.out.println("a++   = " +  (a++) );
                System.out.println("a--   = " +  (a--) );
                // 查看  d++ 与 ++d 的不同
                System.out.println("d++   = " +  (d++) );
                System.out.println("++d   = " +  (++d) );
            }
        }
        自增自减运算符：
            1、自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。
                public class Demo02{
                    public static void main(String[] args){
                        int a = 3;//定义一个变量；
                        int b = ++a;//自增运算
                        int c = 3;
                        int d = --c;//自减运算
                        System.out.println("进行自增运算后的值等于"+b);
                        System.out.println("进行自减运算后的值等于"+d);
                    }
                }
            注意：
                1、int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4
                2、int d = --c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2
            2、前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。
            3、后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算 实例：
                public class Demo03{
                    public static void main(String[] args){
                        int a = 5;//定义一个变量；
                        int b = 5;
                        int x = 2*++a;
                        int y = 2*b++;
                        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
                        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
                    }
                }
            注意：小类型与大类型进行运算，运算结果为大类型。
    关系运算符：
        <:小于 
        >:大于 
        <=:小于等于 
        >=:大于等于 
        ==:判断符号两边是否相同 
        !=:判断符号两边是否不相同
            public class Demo04 {
                public static void main(String[] args) {
                    int a = 10;
                    int b = 20;
                    System.out.println("a == b = " + (a == b) );
                    System.out.println("a != b = " + (a != b) );
                    System.out.println("a > b = " + (a > b) );
                    System.out.println("a < b = " + (a < b) );
                    System.out.println("b >= a = " + (b >= a) );
                    System.out.println("b <= a = " + (b <= a) );
                }
            }        
    逻辑运算符：
        &:与,同真为真,有假为假 
        &&:短路与,同真为真,有假为假 
        |:或,有真为真,同假为假 
        ||:短路或,有真为真,同假为假 
        !:非,非真为假,非假为真
        使用逻辑运算符连接的表达式称为布尔表达式
            public class Demo05 {
                public static void main(String[] args) {
                    boolean a = true;
                    boolean b = false;
                    System.out.println("a && b = " + (a&&b));
                    System.out.println("a || b = " + (a||b) );
                    System.out.println("!(a && b) = " + !(a && b));
                }
            }
    字符串判断内容是否相同
        1、字符串或字符串变量.equals(字符串或字符串变量)
        注意：引用数据类型使用==判断，只判断内存地址是否相同
    赋值运算符：
    =    简单的赋值运算符，将右操作数的值赋给左操作数
    +=    加和赋值操作数，它把左操作数和右操作数相加赋值给左操作数
    -=    减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数
    *=    乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数
    /=    除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数
    ＆=    按位与赋值运算符
    ^=    按位异或赋值操作符
    |=    按位或赋值操作符
    %=    取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数
        public class Demo03 {
            //赋值运算符
            public static void main(String[] args) {
                int a = 10;
                int b = 20;
                int c = 0;
                //赋值运算符：+
                c = a + b;
                System.out.println("c = a + b = " + c );
                //赋值运算符：+=
                c += a ;
                System.out.println("c += a  = " + c );
                //赋值运算符：-=
                c -= a ;
                System.out.println("c -= a = " + c );
                //赋值运算符：*=
                c *= a ;
                System.out.println("c *= a = " + c );
                a = 10;
                c = 15;
                //赋值运算符：/=
                c /= a ;
                System.out.println("c /= a = " + c );
                a = 10;
                c = 15;
                //赋值运算符：%=
                c %= a ;
                System.out.println("c %= a  = " + c );
                //赋值运算符：&=
                c &= a ;
                System.out.println("c &= a  = " + c );
                //赋值运算符：^=
                c ^= a ;
                System.out.println("c ^= a   = " + c );
                //赋值运算符：|=
                c |= a ;
                System.out.println("c |= a   = " + c );
            }
        }
    三目运算符（三元运算符）
        布尔表达式?值1:值2; 
        当布尔表达式值为true返回值1,否则返回值2
数据类型的强制转换：
    1、类型转换主要在在 赋值、方法调用、算术运算 三种情况下发生。
        a、赋值和方法调用 转换规则：从低位类型到高位类型自动转换；从高位类型到低位类型需要强制类型转换：
            （1）布尔型和其它基本数据类型之间不能相互转换； 
            （2）byte型可以转换为short、int、、long、float和double； 
            （3）short可转换为int、long、float和double； 
            （4）char可转换为int、long、float和double； 
            （5）int可转换为long、float和double； 
            （6）long可转换为float和double； 
            （7）float可转换为double； 
        b、算术运算 中的类型转换：
            1、基本就是先转换为高位数据类型，再参加运算，结果也是最高位的数据类型；
            2、byte short char运算会转换为Int；
                （1）如操作数之一为double，则另一个操作数先被转化为double，再参与算术运算。 
                （2）如两操作数均不为double，当操作数之一为float，则另一操作数先被转换为float，再参与运算。 
                （3）如两操作数均不为double或float，当操作数之一为long，、则另一操作数先被转换为long，再参与算术运算。 
                （4）如两操作数均不为double、float或long，则两操作数先被转换为int，再参与运算。
    特殊： 
        （1）如采用+=、*=等缩略形式的运算符，系统会自动强制将运算结果转换为目标变量的类型。
        （2）当运算符为自动递增运算符++或自动递减运算符--时，如果操作数为byte，short或char类型不发生改变；
        public class Demo06{
            public static void main(String[] args){
                //强制转换：double转int
                double m = 30.15;
                int h;
                h = (int)m;
                System.out.println(h);

                //强制转换：double转int
                double k = 18.99;
                int g = (int)k;
                System.out.println(g);
                
                //强制转换：int转double
                int x=80;
                double y = x;
                System.out.println(y);

                //强制转换：int转double
                int q = 63;
                double w = (double)q;
                System.out.println(w);
            }
        }
进制转换（扩展）
    十进制    
        00,01,02,03,04,05,06,07,08,09,10 
    二进制    
        0,1,10,11,100,101,110,111,1000 
    八进制    
        0,1,2,3,4,5,6,7,10,11,12,13,14,15,16,17,20 
    十六进制    
        0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,10    
    10进制转8进制:用10进制数除8,余数倒着读 
    10进制转16进制:用10进制数除16,余数倒着读 
    10进制转2进制:用10进制数除2,余数倒着读