数据类型

数据类型：

为什么要引入数据类型：

1.为了限制当前变量当中所存储的数据（变量当中的数据必须是可兼容的）

2.为了限制当前变量空间的大小

分类：

1.基本数据类型

整数：

byte：1字节 2^8=256 数据可用 -2^7~2^7-1 -128~127

short：2字节 -2^15~2^15-1 -32768~32767

int：4字节 -2^31~2^31-1 整数常量默认是int类型

long：8字节 -2^63~2^63-1

为什么分四类：数字的取值范围不同

class Test01{
    public static void main(String[] args){
        byte b1=100;
        /*
        默认是int类型的4字节的100的二进制为：只有后七位为有效位，所以能放进1字节的byte中
        00000000 00000000 00000000 01100100?
                                   01100100
        向下自动类型转换（从大字节到小字节的自动转换）int->byte 
        */
        System.out.println(b1);


        //不兼容的类型: 从int转换到byte可能会有损失
        byte b2=(byte)300;
        /*
        默认是int类型的四字节的300的二进制为：后九位为有效位，所以放不进1字节的byte中
        00000000 00000000 00000001 00101100
                                   00101100
        先去尝试着去向下自动类型转换
        如果你想强行的将300放到byte中-强制类型转换
        强转一定是从大到小的！
        此时b2为00101100为44
        */
        System.out.println(b2);

        byte b3=100;
        byte b4=100;
        //b5不能确定 b3 b4变量的值（可能会超范围）
        //对于整数之间进行加法运算的时候 得到的值是int值
        //不兼容的类型: 从int转换到byte可能会有损失

        byte b5=(byte)(b3+b4);
        // 00000000 00000000 00000000 11001000
        //                            11001000
        //最前面一位为符号位 0为正，1为负
        //11001000 -1 
        //11000111 取反 
        //00111000 56  -56
        //byte b6=b3+300;
        System.out.println(b5);


        long l1=300;
        long l2=300;
        long l3=l1+l2;
        System.out.println(l3);
        // 过大的整数: 123456789123123
        // 整数常量默认int 此时已经超了int的值了
        // 整数常量后面+ l或者L -> long常量
        // 再大就超出了long的范围了
        // 所以对于超级大的数字 long不够用了
        // 如何解决呢？BigInteger BigDecimal两个去解决
        long l4=123456789123123123123123123123123L;
        System.out.println(l4);
    }
}

浮点数：

float：4字节

double：8字节

浮点型常量默认是double类型

class Test02{
    public static void main(String[] args){
        float f=3.14F;
        //浮点型常量默认是double
        //从double转换到float可能会有损失
        //float类型的常量后面+F
        System.out.println(f);
        double d=10;
        System.out.println(d);
        double d1=3.14;
        double d2=3.14;
        double d3=d1+d2;
        System.out.println(d3);
        /*
        byte->short->int->long->float->double
        在整数/浮点数变量之间进行运算的时候
        谁是最大的 那么结果就是谁
        小字节+大字节=大字节
        */
        System.out.println(3+390L+3.14F+9.0);
    }
}

字符：

char：2字节（0~65535）（指的是字符的编号）

在计算机中储存字符的方法：

class Test03{
    public static void main(String[] args){
        /*
        c1=a
        将一个字符编号给字符变量
        那么在打印这字符变量的时候 
        先去码表中找到编号相对应的字符
        然后再打印
        */
        char c1=97;
        System.out.println(c1);
        
        /*
        将一个字符常量给字符变量的时候
        那么在打印这个字符变量时 直接打印
        c2=A
        无论如何赋值 一旦打印的是字符变量 结果一定是字符
        */
        char c2='A';
        System.out.println(c2);

        /*
        必须要记住的几个字符编号
        'a' 97
        'A' 65
        '0' 48
        */
        char c3='a';
        //字符变量在参与运算时 是以编号身份参加
        System.out.println(c3+1);//98 c3后一个字符的编码
        System.out.println(c3-1);//98 c3前一个字符的编码
        //如何查看'我'这个字符的编码呢？
        System.out.println('我'+0);
        //'我'后面的字符是啥？
        System.out.println((char)('我'+1));
        System.out.println((char)('我'+2));
        //如何判断一个字符是小写字母嘞？97~97+25（26个字母）
        //大写字母？65~65+25
        //数字？48~48+9（10个数字）
        System.out.println((char)8888888);
        //Unicode码表 \\u 指定编码集Unicode
        System.out.println('\u0033');
        //为什么有时候显示是 '?'当前编码表中没有这个东西
        //我们一般用GBK码表或Unicode码表编程
        //但是我们的CMD控制台用的是微软的码表 ANSI
        //相同位置的字符 前两个表中有 ANSI中就不一定有了
        //但是 不管是哪个码表 前面的内容基本是一致的
        boolean b1=true;
        boolean b2=false;
        String s1="哈哈";
        String s2="啦啦";
    }
}

布尔：

boolean：true/false

在Java当中并没有给boolean一个明确的大小，主要和底层虚拟机相关
    如果boolean是一个变量的话 1字节
    如果boolean是一个数组的话 每个空间是4个字节

2.引用数据类型

字符串：

String 也不存在具体的大小，它的大小是根据字符串的内容而决定的

目前而言，可以像用基本类型一样去使用String类型数据

String其实是java中自带的一个类

null

数组

对象

 

如何定义变量：

数据类型 变量名=常量；

数据类型 变量;

变量=常量；

2.6 运算符

1.算术运算符：

+ 加法运算：如果+号的两边都是数字的话表示是数学上的加法

如果+号的两边，只有有一个字符串，那么这个+表示的是字符串连接符

class Test04{
    public static void main(String[] args){
        System.out.println(2+3);
        System.out.println("哈哈"+"啦啦");//"哈哈啦啦"
        System.out.println(1+2+3+"456");//"6456"
        System.out.println("123"+4+5+6);
        //"123"+4="1234"+5="12345"+6="123456"（从左向右先算的字符串）
        System.out.println("123"+(4+5+6));//12315
        System.out.println(3/10);
        System.out.println(3.0/10);
        System.out.println(10/3);// 3
        System.out.println(10%3);// 1
        
    }
}

- 减法运算

* 乘法运算

/ 除法运算：如果两边都是整数 结果就是整数（整除），如果两边至少存在一个小数 那结果就是小数

% 取余运算：相当于是整除运算，但是得到的结果会是余数

++ 自加运算：前++ ++i（i直接+1再参与运算），后++ i++（i先参与运算再本身+1）

i++

1.先开辟一个临时存储区

2.将i的值复制到存储区

3.i自身+1

4.临时存储区的值等待被调用

class Test05{
    public static void main(String[] args){
        /* 
        i++
        1.先开辟一个临时存储区
        2.将i的值复制到存储区
        3.i自身+1
        4.临时存储区的值等待被调用(参与运算，输出，赋值)
        */
        int i=3;
        i++;
        System.out.println(i);  //4
        System.out.println(i++);//4等待被调用 5在储存区中
        int j=i++;//5等待被调用 6在储存区中
        System.out.println(j);  //5
        System.out.println(i);  //6
        i=i++;//6等待被调用 i=7在储存区中 i又被6赋值
        System.out.println(i);  //6
        i=i++;//6等待被调用 i=7在储存区中 i又被6赋值
        System.out.println(i);  //6
        
        i=1;
        j= i++ + ++i + ++i + i++;
        // 1     3     4    4
        System.out.println(j); 
        System.out.println(i); 
        int a=3;
        a=a+3;
        a+=3;
        a=a+1;
        a+=1;
        ++a;
        a++;
        short s=3;
        //不兼容的类型: 从int转换到short可能会有损失
        //s=s+3;
        s+=3;
        System.out.println(s);
        a=1;
        System.out.println(a++==1);
        
        int m=7;
        int n=11;
        System.out.println(m&n);    //3
        /*
            0111
            1011
           &0011 3（取相同位）
        */
        System.out.println(m|n);    //15
        /*
            0111
            1011
           |1111 15（取相交位）
        */
        System.out.println(m^n);    //12
        /*异或：不同为真 相同为假
            0111
            1011
           ^1100 12（取不同位）
        */
        System.out.println(m>>2);   //1
        /*
            0111
              01 11（右移两位 1）
        */
        System.out.println(m<<2);   //28
        /*
            0111
          011100（左移两位 28）
        */
        System.out.println(0b10010101>>3);
        //10010
        System.out.println(0b10010101<<3);
        //10010101000
        //x>>y x/2^y
        //x<<y x*2^y  
    }
}

-- 自减运算

赋值运算符（+=，-=，*=，/=，%=，=）

+=：a=a+3；相当于a+=1；

比较运算符

逻辑运算符

位运算符：指的就是二进制之间的运算（&，|，^，>>,<<)

三目运算符