day02

学习目标：

  • 类型转换

    • 自动类型转换/隐式类型转换

    • 强制类型转换

  • 键盘录入

    • 导包 import java.util.Scanner

    • 创建对象 Scanner sc = new Scanner(System.in);

    • 接收键盘录入的数据 int num = sc.nextInt();

  • 运算符

    • 算术运算符

      • +

      • -

      • *

      • /

      • %

    • 关系运算符

      • '>

      • '>=

      • <

      • <=

      • ==

      • !=

    • 逻辑运算符

      • &

      • |

      • ！

      • ^

    • 短路的逻辑运算符

      • &&

      • ||

    • 赋值运算符

      • =

      • +=

      • -=

      • *=

      • /=

      • %=

    • 自增自减运算符

      • ++

      • --

    • 三元运算符

      • 格式： 关系表达式 ？表达式1：表达式2

  • 流程控制语句

    • 分类

      • 顺序结构

      • 选择结构/分支结构

      • 循环结构

 

1.类型转换

1.1自动类型转换

/*
    自动类型转换 小的数据类型向大的数据类型转换，不会造成数据精度丢失
​
    转换格式：
        byte --> short
                        -->int --> long --> float -->double
                   char
    byte和short不能直接转换成char
    在参与运算的时候，如果有高类型的数据参与运算，所有数据自动转换成高类型的数据
 */
public class Demo01 {
    public static void main(String[] args) {
        char c = 'a';
        System.out.println(c);
        int i = c;
        System.out.println(i);
​
        int x = 100;
        long y = x;
        System.out.println(x);
        System.out.println(y);
        System.out.println(Float.MIN_VALUE);
        System.out.println(Float.MAX_EXPONENT);
​
        //byte和short不能直接转换成char
        /*byte b = 10;
        short e = 10;
        char d = b;
        char h = e;
*/
        //在参与运算的时候，如果有高类型的数据参与运算，所有数据自动转换成高类型的数据
        float f1 = 3.14F;
        int f2 = 314;
        double f4 = 5.12;
        double f3 = f1+f2+f4;
​
​
    }
}
​
基本数据类型，字节数，位数，最大值和最小值。
​
1、
基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768 （-2的15此方）
最大值：Short.MAX_VALUE=32767 （2的15次方-1）
2、
基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE= -2147483648 （-2的31次方）
最大值：Integer.MAX_VALUE= 2147483647 （2的31次方-1）
3、
基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808 （-2的63次方）
最大值：Long.MAX_VALUE=9223372036854775807 （2的63次方-1）
4、
基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45 （2的-149次方）
最大值：Float.MAX_VALUE=3.4028235E38 （2的128次方-1）
5、
基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324 （2的-1074次方）
最大值：Double.MAX_VALUE=1.7976931348623157E308 （2的1024次方-1）

1.2强制类型转换

/*
    大的数据类型，向小的数据类型转换，
    有可能造成数据精度丢失,
        1.如果大的数据类型存储数值，在小的数据类型的取值范围内，就不会造成数据精度的丢失
        2.如果大的数据类型存储数值,超出了小的数据类型的取值范围，就会造成数据精度丢失
​
    格式：
        目标数据类型 变量名 = (目标数据类型)变量名或值;
​
 */
public class Demo02强制类型转换 {
    public static void main(String[] args) {
        int a = 10;
        a = 130;
        byte b = (byte) a;
        System.out.println(a);
        System.out.println(b);
    }
}

2.键盘录入 Scanner

步骤：
    1.导包
    import java.util.Scanner
    2.创建对象
    Scanner sc = new Scanner(System.in);
    3.接收数据
    int num = sc.nextInt();
//  1.导包
import java.util.Scanner;
/*
    步骤：
    1.导包
    import java.util.Scanner
    2.创建对象
    Scanner sc = new Scanner(System.in);
    3.接收数据
    int num = sc.nextInt();
 */
public class Demo01 {
    public static void main(String[] args) {
        //2.创建对象
        Scanner sc = new Scanner(System.in);
        //3.接收数据
        System.out.println("请输入一个整数：");
        int num = sc.nextInt();
        System.out.println("键盘录入的数据是："+num);
        //byte b = sc.nextByte();//补全代码 alt+回车
        System.out.println("请输入一个字符串：");
        String s = sc.next();
        System.out.println(s);
       /* System.out.println("请输入一行字符串：");
        String s1 = sc.nextLine();
        System.out.println(s1);*/
    }
}

3.运算符

3.1算术运算符

/*
    算术运算符:
        +:求和
        -：求差
        *：求积
        /：求商
        %：求余
​
        数学：5÷3 = 1......2
        java：
            1.求商
                5/3 = 1
                3/5 = 0
            2.求余
                5%3 = 2
                3%5 = 3
 */
public class Demo01算术运算符 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //+:求和
        int c = a + b;
        System.out.println(c);
        //-：求差
        int d = a - b;
        System.out.println(d);
        // *：求积
        int e = a * b;
        System.out.println(e);
        //：求商
        int f = b / a;
        System.out.println(f);
        int g = a / b;
        System.out.println(g);
​
        //%：求余
        int h = b % a;
        System.out.println(h);
        int i = a % b;
        System.out.println(i);
        //如果有浮点型数据参与运算，获取的结果是浮点型的
        double x = 3.0;
        double y = 6.0;
        System.out.println(x / y);
​
    }
}

3.2练习

import java.util.Scanner;
​
/*
    键盘录入一个求各个位上数字
    分析：
        1.键盘录入
            导包 import java.util.Scanner
            创建对象
                Scanner sc = new Scanner(System.in);
            接收数据
                int num = sc.nextInt();
         2.获取这个四位数各个位上数字
            2.1 个位   num%10   1234%10==4
            2.2 十位   num/10%10   1234/10 ==123  123%10 ==3
            2.3 百位   num/100%10     1234/100==12   12%10 ==2
            2.4 千位   num/1000%10
​
​
 */
public class Demo02练习 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个四位数：");
        int num = scanner.nextInt();
        // 2.获取这个四位数各个位上数字
        int ge = num%10;
        int shi = num/10%10;
        int bai = num/100%10;
        int qian = num/1000%10;
        System.out.println("个位："+ge);
        System.out.println("十位："+shi);
        System.out.println("百位："+bai);
        System.out.println("千位："+qian);
    }
}

3.3字符的加操作

/*
    字符的加操作,先把字符转成int类型的ASCII码值，在参与运算，结果是int类型的
​
    byte short char 三种数据类型的数据在参与运算的时候，首先要转成int类型的值，在参与运算，结果是int类型的，
    如果有高类型的参与运算结果是高类型的数据
 */
public class Demo03 {
    public static void main(String[] args) {
        char c = 'a';
        int i = c;
        System.out.println(i);
        int j = 'A';
        System.out.println(j);
        int x = '0';
        System.out.println(x);
        int y = '0'+1;
        System.out.println(y);
​
        char d = 'A';
        int e = d+c;
        System.out.println(e);
​
        byte f = 10;
        byte g = 20;
        int s = g + f;
        System.out.println(s);
​
        short s1 = 30;
        short s2 = 40;
        int s3 = s1 + s2;
        System.out.println(s3);
​
    }
}
​

3.4 字符串的加操作

/*
    字符串的加：
        字符串的连接

 */
public class Demo04字符串的加 {
    public static void main(String[] args) {
        System.out.println(1+2+3+4+"hello"+5+6+7+8+9);//10hello56789
        System.out.println(1+2+3+4+"hello"+(5+6+7+8+9));//10hello35
    }
}

3.5 自增自减运算符 

/*
    自增自减运算符:
        对变量自增一或者对边自减一
        ++:
        --:
 */
public class Demo05自增自减运算符 {
    public static void main(String[] args) {
        // ++:
        // 在单独使用的使用，无论放在变量前面还是后面都是对变量自增一,
        // 在参与运算的时候，如果++在变量的后面，先参与运算，后对变量自增一
        // 在参与运算的时候，如果++在变量的前面，先对变量自增一，后参与运算
        int a = 10;
//        a++;
//        ++a;
//        int b = a++;
        int b = ++a;
        System.out.println(a);
        System.out.println(b);
        //--:
        //在单独使用的使用，无论放在变量前面还是后面都是对变量自减一
        // 在参与运算的时候，如果--在变量的后面，先参与运算，后对变量自减一
        // 在参与运算的时候，如果--在变量的前面，先对变量自减一，后参与运算
        int c = 20;
//        c--;
//        --c;
//        int d = c--;
        int d = --c;
        System.out.println(c);
        System.out.println(d);
    }
}

3.6关系运算符

/*
    关系运算符：
        >
        >=
        <
        <=
        ==
        !=
    关系表达式结果是布尔类型的值 true false
 */
public class Demo06关系运算符 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a>b);//false
        System.out.println(a<b);//true
        b = 10;
        System.out.println(a>=b);//true
        System.out.println(a<=b);//true
        System.out.println(a == b); //true
        b = 30;
        System.out.println(a == b); //false
        System.out.println(a != b); //true
    }
}

3.7逻辑运算符

/*
    逻辑运算符: 逻辑运算符两边放的是关系表达式，结果是布尔类型的值 true或false
        &  :
        |  :
        !  :
        ^  :
 */
public class Demo07逻辑运算符 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
//        &  :  见false 则false
        System.out.println((a>b) & (a>c)); //false & false ==> false
        System.out.println((a<b) & (a>c)); //true  & false ==> false
        System.out.println((a>b) & (a<c)); //false & true  ==> false
        System.out.println((a<b) & (a<c)); //true  & true  ==> true
        System.out.println("------------------------");
//          |  : 见true 则true
        System.out.println((a>b) | (a>c)); //false | false ==> false
        System.out.println((a<b) | (a>c)); //true  | false ==> true
        System.out.println((a>b) | (a<c)); //false | true  ==> true
        System.out.println((a<b) | (a<c)); //true  | true  ==> true
        System.out.println("------------------------");
//         ^  :  相同为false 不同true
        System.out.println((a>b) ^ (a>c)); //false ^ false ==> false
        System.out.println((a<b) ^ (a>c)); //true  ^ false ==> true
        System.out.println((a>b) ^ (a<c)); //false ^ true  ==> true
        System.out.println((a<b) ^ (a<c)); //true  ^ true  ==> false
        System.out.println("------------------------");
//        !  :
        System.out.println((a<b));   //true
        System.out.println(!(a<b));  //false
        System.out.println(!!(a<b));  //true
        System.out.println(!!!(a<b));  //false
    }
}

3.8短路运算符

/*
    短路运算符:
        &&: 见false 则false ，左边为false 右边不参与运算
        ||：见true 则true ，左边为true 右边就不运算
 */
public class Demo08短路运算符 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
       /* System.out.println((a++>c) && (b++>c)); //false && false ==> false
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);*/
        System.out.println((a++<c) || (b++>c++)); //true || false ==>true
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

3.9赋值运算符

/*
    赋值运算符:
        = :就是把右边的值赋值给左边变量

复合的赋值运算符 ，隐含了强制类型转换
        += : 变左边变量中的值和右边值相加 把和赋值给左边变量
        -= ：
        *=
        /=
        %=
 */
public class Demo09赋值运算符 {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a);
        a = 20;
        System.out.println(a);
//         +=
        int b = 30;
        b+=10; //b = b+10;
        System.out.println(b);

        short c = 40;
        c+=40;// c = (short) (c+40);
        System.out.println(c);

        int d = 50;
        d-=10;
        System.out.println(d); //40
        d*=10;
        System.out.println(d); //400
        d/=20;
        System.out.println(d); //20
        d%=3;
        System.out.println(d); //2

    }
}

3.10三元运算符

/*
    三元运算符:
        格式：
        关系表达式？表达式1：表达式2
        运算规则：
            先计算关系表达式的值，如果为true，取表达式1的值，如果为false，取表达式2的值
 */
public class Demo10三元运算符 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //求两个数的最大值
        int max = a > b ? a : b;
        System.out.println(max);
        //求两个数的最小值
//        int min = a > b ? b : a;
        int min = a < b ? a : b;
        System.out.println(min);
    }
}

3.11练习

/*
    键盘录入两个数字，求最大值 求最小值
    分析：
        1.键盘录入
        2.使用三元运算符求结果
 */
public class Demo11练习 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num1 = sc.nextInt();
        System.out.println("请输入一个整数：");
        int num2 = sc.nextInt();
        //2.使用三元运算符求结果
        int max = num1>num2?num1:num2;
        System.out.println("最大值："+max);

        int min = num1<num2?num1:num2;
        System.out.println("最小值："+min);

    }
}

3.12练习

import java.util.Scanner;

/*
    键盘录入三个数字，求最大值
 */
public class Demo12练习 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//扫描键盘，等待录入
        System.out.println("请输入第一个数字：");
        int num1 = sc.nextInt();//接收键盘录入的第一个数字
        System.out.println("请输入第二个数字：");
        int num2 = sc.nextInt();
        System.out.println("请输入第三个数字：");
        int num3 = sc.nextInt();

        //1.求前两个数的最大值，当成临时最大值
        int tempMax = num1>num2?num1:num2;
        //2.使用临时的最大值和第三个数字比较，求出最终的最大值
        int max = tempMax>num3?tempMax:num3;
        System.out.println(max);

    }
}

3.13 练习

/*
    键盘录入一个三位数字，判断这是数字是否是水仙花数，三元运算符 如果是返回true 不是返回false

    水仙花：
        1.三位数
        2.算法：各个位数数字的立方和等于数字本身
        3.举栗子：153 = 1*1*1 + 5*5*5 + 3*3*3
 */
public class Demo13练习 {
    public static void main(String[] args) {
        //1.键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位数：");
        int num = sc.nextInt();

        //2.求三位数各个位上数字 153 370 371 407
        int ge = num%10;
        int shi = num/10%10;
        int bai = num/100%10;
        //3.求各个位上数字的立方和
        int sum = ge*ge*ge + shi*shi*shi +bai*bai*bai;
        //4.使用三元运算符 将立方和和数字本身比较 如果相等 就是水仙花数 返回true 否则是false
        boolean flag = sum == num ? true : false;
        System.out.println(num+"是水仙花数："+flag);

    }
}
 

 

 

 

 

 

 

 

 

 

 

 

 

posted @ 2023-02-12 20:09  忘了鱼尾纱的猫  阅读(15)  评论(0)    收藏  举报