数据类型

在定义变量时我们是要声明数据类型的，这里的数据类型是用来规定变量存储什么类型的数据。

Java的数据类型整体上来说分为两大类： 基本数据类型、引用数据类型。

基本数据类型

整型
浮点型
字符型
布尔型


public class TypeDemo {

    public static void main(String[] args) {

        // 整型

        // 注意：随便写一个整型字面量，默认是int类型的，73642422442424虽然没有超过long的范围，但是它超过了本身int的范围了。

        // 如果希望随便写一个整型字面量是long类型的，需要在其后面加上L/l

        byte number = 98;

        short number2 = 9000;

        int number3 = 12323232; // 默认

        long number4 = 73642422442424L;



        // 浮点型

        // 注意：随便写一个小数字面量，默认当成double类型对待的

        // 如果希望这个小数是float类型的，需要在后面加上：F/f

        float score1 = 99.5F;

        double score2 = 99.8; // 默认定义方案



        // 字符型

        char ch1 = 'a';

        char ch2 = '中';



        // 布尔型

        boolean b1 = true;

        boolean b2 = false;



        // 引用数据类型：String.

        // String代表的是字符串类型，定义的变量可以用来记住字符串。

        String name = "hello world";

    }

}

数据类型转换

类型转换的形式总体分为2种，一种是自动类型转换，一种是强制类型转换。

自动类型转换

自动类型转换：数据范围小的变量可以直接赋值给数据范围大的变量


public class TypeDemo {

    public static void main(String[] args) {

        byte a = 12;

        int b = a; // 自动类型转换(把byte类型转换int类型)

    }

}

自动类型转换的原理是怎样的？

自动类型转换其本质就是在较小数据类型数据前面，补了若干个字节


public class TypeConversionDemo {

    public static void main(String[] args) {

        byte a = 12;

        int b = a; // 自动类型转换



        int c = 100; // 4字节

        double d = c;// 8字节 自动类型转换



        char ch = 'a'; // 'a' 97 => 00000000 01100001

        int i = ch; // 自动类型转换 =>  00000000 00000000  00000000 01100001

        System.out.println(i);

    }

}

表达式的自动类型转换

自动类型转换还有另外一种形式，就是表达式的自动类型转换。所谓表达式指的是几个变量或者几个数据一起参与运算的式子。

如果同一个表达式中，出现不同类型的变量或者数据一起运算，这种情况下运算结果是一个什么数据类型呢？需要遵守下面的两条运算规则：

多种数据类型参与运算，其结果以大的数据类型为准
byte,short,char 三种类型数据在和其他类型数据运算时，都会转换为int类型再运算


public class TypeConversionDemo {

    public static void main(String[] args) {

        byte a = 10;

        int b = 20;

        long c = 30;

        long rs = a + b + c; // 转换为int再运算

        double rs2 = a + b + 1.0;



        byte i = 10;

        short j = 30;

        int rs3 = i + j;



        // 即使两个byte运算，结果也会提升为int

        byte b1 = 110;

        byte b2 = 80;

        int b3 = b1 + b2;

    }

}

强制类型转换

什么是强制类型转换

强行将范围大的数据，赋值给范围小的变量也是可以的，这里就需要用到强制类型转换。
数据范围大的数据，赋值给数据范围小的变量，它有可能装不下。会发生转换化数据异常。

目标数据类型变量名=(目标数据类型)被转换的数据;


public class TypeConversionDemo {

    public static void main(String[] args) {

        int a = 20;

        byte b = (byte) a;  // 强制类型转换



        int i = 1500;

        byte j = (byte) i;



        double d = 99.5;

        int m = (int) d; // 强制类型转换

        System.out.println(m); // 丢掉小数部分，保留整数部分

    }

}

强制类型转换的原理

强制类型转换的原理，其实就是强行把前面几个字节砍掉，有数据丢失的风险。

四、运算符

运算符就是参与运算的符号。Java提供的运算符有很多种，可以分为下面几种

基本算术运算符
自增自减运算符
赋值运算符
关系运算符
逻辑运算符
三元运算符

3.1 算术运算符

先从最基本的算术运算符开始学习，算术运算符有 + - * / % ，其中*表示乘法，/表示除法，%表示取余数

需要我们注意以下几点


/:两个整数相除，结果也是一个整数

        %:表示两个数相除，取余数

需要我们注意的是：+符号除了用于加法运算，还可以作为连接符。**+符号与字符串运算的时候是用作连接符的，其结果依然是一个字符串

**。


public class OperatorDemo1 {

    public static void main(String[] args) {

        // 目标：掌握基本的算术运算符的使用。

        int a = 10;

        int b = 2;

        System.out.println(a + b);

        System.out.println(a - b);

        System.out.println(a * b); // 20

        System.out.println(a / b); // 5

        System.out.println(5 / 2); // 2.5 ==> 2

        System.out.println(5.0 / 2); // 2.5

        int i = 5;

        int j = 2;

        System.out.println(1.0 * i / j); // 2.5



        System.out.println(a % b); // 0

        System.out.println(3 % 2); // 1



        System.out.println("---------------------------------------");



        // 目标2：掌握使用+符号做连接符的情况。

        int a2 = 5;

        System.out.println("abc" + a2); // "abc5"

        System.out.println(a2 + 5); //  10

        System.out.println("itheima" + a2 + 'a'); // "itheima5a"

        System.out.println(a2 + 'a' + "itheima"); // 102itheima

    }

}

3. 2 自增自减运算符

++读作自增，--读作自减；


1.单独使用：++或者--放在变量前面没有区别

        int a=10;

        a++;  //11

        --a;  //10

        System.out.println(a); //10



        2.混合使用：++或者--放在变量或者前面运算规则稍有不通过

        //++在后：先做其他事情，再做自增和自减

        int a=10;

        int b=a++; //等价于 int b = a; a++; 



        //++在前：先自增或者自减，再做其他运输

        int x=10;

        int y=--x; //等价于x--; int y = x;


public class OperatorDemo2 {

    public static void main(String[] args) {

        // 目标：掌握自增自减运算符的使用。

        int a = 10;

        // a++; // a = a + 1

        ++a;

        System.out.println(a);



        // a--; // a = a - 1

        --a;

        System.out.println(a);



        // 自增自减只能操作变量不能操作字面量的，会报错！

        //System.out.println(2++);



        System.out.println("--------------------------------------");



        int i = 10;

        int rs = ++i; // 先加后用

        System.out.println(rs);

        System.out.println(i);



        int j = 10;

        int rs2 = j++; // 先用后加

        System.out.println(rs2);

        System.out.println(j);

    }

}

3.3 赋值运算符

基本的赋值运算符其实就是=号，意思就是把右边的数据赋值给左边的变量。


int a=10; //将数据10赋值给左边的变量a

除了基本的赋值运算符，扩展的赋值运算符有+= -= *= /= %=


int a=10;

//+=解析：在a原来记录值10的基础上累加5，将结果重新赋值给a; 

        a+=5;

//最终打印a的值为15

        System.out.println(a);


public class OperatorDemo3 {

    public static void main(String[] args) {

        // 目标：掌握扩展赋值运算符的使用。

        // +=

        // 需求：收红包

        double a = 9.5;

        double b = 520;

        a += b;  // a = (double)(a + b);

        System.out.println(a);



        // -= 需求：发红包

        double i = 600;

        double j = 520;

        i -= j;  // i = (double)(i - j);

        System.out.println(i);



        int m = 10;

        int n = 5;

        // m *= n; // 等价形式： m = (int)(m * n)

        // m /= n; // 等价形式： m = (int)(m / n)

        m %= n;    // 等价形式： m = (int)(m % n)

        System.out.println(m);

    }

}


问题1：下面的代码否有问题？

        byte x=10;

        byte y=30;

        x=x+y;  //这句代码有问题，因为两个byte类型数据相加，会提升为int类型;



        问题2：下面的代码是否有问题？

        byte x=10;

        byte y=30;

        x+=3; //这句代码没有问题，因为这里有隐含的强制类型转换

//x+=3; 等价于 byte x = (byte)(x+y);


1.基本赋值运算符：

        =符号含义： 把右边的值赋值给左边的变量



        2.扩展赋值运算符：

        +=-=*=/=%=符号含义：将右边的数据和左边的变量相加、相减、相乘、相除、取余数后，将结果重新赋值给左边的变量。

3.4 关系运算符


public class OperatorDemo4 {

    public static void main(String[] args) {

        // 目标：掌握关系运算符的基本使用。

        int a = 10;

        int b = 5;

        boolean rs = a > b;

        System.out.println(rs);



        System.out.println(a >= b); // 要么a大于b,或者a等于b

        System.out.println(2 >= 2); // true

        System.out.println(a < b);

        System.out.println(a <= b); // false

        System.out.println(2 <= 2); // true

        System.out.println(a == b); // false

        System.out.println(5 == 5); // true



        // 注意了：判断是否相等一定是用 == ，=是用来赋值的。

        // System.out.println(a = b); 

        System.out.println(a != b); // true

        System.out.println(10 != 10); // false



        System.out.println(false ^ true ^ false);

    }

}

关系运算符在程序中常用于条件判断，根据条件判断的结果是true还是false，来决定后续该执行哪些操作。

3.5 逻辑运算符

逻辑运算符是用来将多个条件放在一起运算，最终结果是true或者false


//需求1：要求手机必须满足尺寸大于等于6.95，且内存必须大于等于8.

//需求2：要求手机要么满足尺寸大于等于6.95，要么内存必须大于等于8.


public class OperatorDemo5 {

    public static void main(String[] args) {

        // 目标：掌握逻辑运算符的使用。

        // 需求：要求手机必须满足尺寸大于等于6.95，且内存必须大于等于8.

        double size = 6.8;

        int storage = 16;

        // 1、& 前后的条件的结果必须都是true ,结果才是true.

        boolean rs = size >= 6.95 & storage >= 8;

        System.out.println(rs);



        // 需求2：要求手机要么满足尺寸大于等于6.95，要么内存必须大于等于8.

        // 2、| 只要多个条件中有一个是true,结果就是true.

        boolean rs2 = size >= 6.95 | storage >= 8;

        System.out.println(rs2);



        // 3、!取反的意思

        System.out.println(!true); // false

        System.out.println(!false); // true

        System.out.println(!(2 > 1)); // false



        // 4、^ 前后条件的结果相同时返回false，不同时返回true.

        System.out.println(true ^ true); // false

        System.out.println(false ^ false); // false

        System.out.println(true ^ false); // true

        System.out.println(false ^ true); // true



        // 5、&& 左边为false，右边不执行。

        int i = 10;

        int j = 20;

        // System.out.println(i > 100 && ++j > 99);

        System.out.println(i > 100 & ++j > 99);

        System.out.println(j);



        // 6、|| 左边是true ，右边就不执行。

        int m = 10;

        int n = 30;

        // System.out.println(m > 3 || ++n > 40);

        System.out.println(m > 3 | ++n > 40);

        System.out.println(n);

    }

}

3.6 三元运算符


关系表达式?值1:值2;

三元运算的执行流程：首先计算关系表达式的值，如果关系表达式的值为true，则返回值1；如果关系表达式的值为false, 则返回值2；


public class OperatorDemo6 {

    public static void main(String[] args) {

        // 目标：掌握三元运算符的基本使用。

        double score = 58.5;

        String rs = score >= 60 ? "成绩及格" : "成绩不及格";

        System.out.println(rs);



        // 需求2：找出2个整数中的较大值，并输出。

        int a = 99;

        int b = 69;

        int max = a > b ? a : b;

        System.out.println(max);



        // 需求3：找3个整数中的较大值。

        int i = 10;

        int j = 45;

        int k = 34;



        // 找出2个整数中的较大值。

        int temp = i > j ? i : j;

        // 找出temp与k中的较大值。

        int max2 = temp > k ? temp : k;

        System.out.println(max2);

    }

}

3.7 运算优先级

&&运算比||运算的优先级高，所以&&和||同时存在时，是先算&&再算||；


//这里&&先算 相当于 true || false 结果为true

System.out.println(10>3||10>3&&10< 3); // true

在实际开发中，其实我们很少考虑运算优先级，因为如果你想让某些数据先运算，其实加()就可以了，这样阅读性更高。


//有括号先算 相当于 true && false 结果为false

System.out.println((10>3||10>3)&&10< 3); //false

五、案例技术：获取用户键盘输入的数据


public class ScannerDemo1 {

    public static void main(String[] args) {

        // 1、导包:一般不需要我们自己做，idea工具会自动帮助我们 导包的。

        // 2、抄写代码：得到一个键盘扫描器对象（东西）

        Scanner sc = new Scanner(System.in);



        // 3、开始 调用sc的功能，来接收用户键盘输入的数据。

        System.out.println("请您输入您的年龄：");

        int age = sc.nextInt(); // 执行到这儿，会开始等待用户输入一个整数，直到用户按了回车键，才会拿到数据。  如果输入的不是数字，会报输入错误。

        System.out.println("您的年龄是：" + age);



        System.out.println("请您输入您的名字：");

        String name = sc.next(); // 执行到这儿，会开始等待用户输入一个字符串，直到用户按了回车键，才会拿到数据。

        System.out.println(name + "欢迎您进入系统~~");

    }

}

数据类型

#数据类型

#基本数据类型

#数据类型转换

#自动类型转换

#强制类型转换

#四、运算符

#3.1 算术运算符

#3. 2 自增自减运算符

#3.3 赋值运算符

#3.4 关系运算符

#3.5 逻辑运算符

#3.6 三元运算符

#3.7 运算优先级

#五、案例技术：获取用户键盘输入的数据

数据类型

基本数据类型

数据类型转换

自动类型转换

强制类型转换

四、运算符

3.1 算术运算符

3. 2 自增自减运算符

3.3 赋值运算符

3.4 关系运算符

3.5 逻辑运算符

3.6 三元运算符

3.7 运算优先级

五、案例技术：获取用户键盘输入的数据