[java入门到精通] 01 类型转换、常用运算符

本文链接：https://blog.csdn.net/2301_76721962/article/details/130590049

本文介绍了Java中的类型转换，包括隐式转换和强制转换，并展示了各种运算符的用法，如算术、赋值、自增自减、关系和逻辑运算符。此外，还讨论了如何使用三元运算符找到三个整数中的最大值以及如何从键盘接收输入并判断是否为水仙花数。

摘要由CSDN通过智能技术生成

类型转换、常用运算符

1类型转换
2.运算符
3.键盘录入

1类型转换

1.1隐式类型转换

定义：小的数据类型向大的数据类型转换，也叫自动类型转换
  
byte -- short 
  				--> int --> long --> float --> double
  		char
byte 和 short 不能直接转成 char 类型
byte short char 在参与运算的时候 自动转成 int 类型的数据 参与运算

public class Demo01自动类型转换 {
    public static void main(String[] args) {
        byte a = 10;
        int b = a;
        System.out.println(a);
        System.out.println(b);
        //byte 和 short 不能直接转成 char 类型
        //char c = a;
        
        double d = a;
        System.out.println(d); 
    }
}

1.2强制类型转换

定义：大的数据类型向小的数据类型转换，有可能造成数据精度丢失
  
格式：
  	目标数据类型 变量名 = (目标数据类型)变量名或值;

/*
定义：大的数据类型向小的数据类型转换，有可能造成数据精度丢失
如果大的数据类型数值在小的数据类型的取值范围内，就不会造成数据精度丢失
如果大的数据类的数值超出了小的数据类型的取值范围，就会造成数据精度丢失

格式：
目标数据类型变量名 = (目标数据类型)变量名或值;
*/

public class Demo02强制类型转换 {
    public static void main(String[] args) {
        //如果大的数据类型数值在小的数据类型的取值范围内，就不会造成数据精度丢失
        int a = 10;
        byte b = (byte) a;
        System.out.println(a);
        //如果大的数据类的数值超出了小的数据类型的取值范围，就会造成数据精度丢失
        int c = 130;
        byte d = (byte) c;
        System.out.println(c);
        System.out.println(d);

    }
}

1.3 总结

在这里插入图片描述

2.运算符

2.1算术运算符

/*
    算术运算符:
        +: 数学的加
        -: 数学的减
        *: 数学的乘
        /: 数学的除 求商
        %: 数学的除 求余数
 */
public class Demo01算术运算符 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);

        System.out.println(a/b);//求商
        System.out.println(a%b);//求余数

    }
}

2.2赋值运算符

/*
    赋值运算符：
        = ：把右边的值或者变量赋值给左边的变量

        +=:把左边变量和右边变量或值相加再赋值给左边变量
        -=:把左边变量和右边变量或值相减再赋值给左边变量
        *=:把左边变量和右边变量或值相乘再赋值给左边变量
        /=:把左边变量和右边变量或值相除的商再赋值给左边变量
        %=:把左边变量和右边变量或值相除的余数再赋值给左边变量
 */
public class Demo02赋值运算符 {
    public static void main(String[] args) {
        // = ：把右边的值或者变量赋值给左边的变量
        int a = 10;
        int b = a;
        //+=:把左边变量和右边变量或值相加再赋值给左边变量
        int c = 20;
        c += 10; // c = c + 10;
        System.out.println(c);
        //-=:把左边变量和右边变量或值相减再赋值给左边变量
        c -= 15;
        System.out.println(c);

        //*=:把左边变量和右边变量或值相乘再赋值给左边变量
        c*=2;
        System.out.println(c);

        //=:把左边变量和右边变量或值相除的商再赋值给左边变量
        c/=5;
        System.out.println(c);

        //%=:把左边变量和右边变量或值相除的余数再赋值给左边变量
        c%=10;
        System.out.println(c);

        //复合赋值运算符，隐含了一个强制类型转换
        short s = 4;
        s+=5; // s = (short) (s+5);
        System.out.println(s);
   }
}

2.3自增自减运算符

/*
    自增运算符：
    ++:
        对变量自增一
        单独使用：
            ++在变量的前面或者后，都是对变量自增一
        参与运算：
            ++在变量后先参与操作，后自增一
            ++在变量的前面，先自增一，后参与操作

    自减运算符：
    --:
        对变量自减一
        单独使用：
            --在变量的前面或者后，都是对变量自减一
        参与运算：
            --在变量后先参与操作，后自减一
            --在变量前先自减一，后参与操作，
 */
public class Demo03自增自减运算符 {
    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);
    }
}

2.4字符的加操作

/*
    字符的加操作：
        1.先把字符转成对应的ASCII码
        2.参与运算
 */
public class Demo04字符的加操作 {
    public static void main(String[] args) {
        System.out.println('a'+1); // 'a' =97
        System.out.println('A'+1); // 'A' =65
        System.out.println('0'+1); // '0' =48
    }
}

2.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
        a = 20;
        System.out.println(a == b);//true
        System.out.println(a != b);//false
        System.out.println(a>=b);//true
        System.out.println(a<=b);//true

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

    }
}

2.7逻辑运算符

/*
逻辑运算符: 两边只能放关系表达式，值应该是true或false
& : 见false则false
| : 见true则true
^ : 相同false 不同true
! : 取反

public class Demo07逻辑运算符 {
    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 < c & b > c); // true  & false ==> false
        System.out.println(a > c & b < c); // false & true  ==> false
        System.out.println(a < c & b < c); // true  & true  ==> true
        System.out.println("========================");
        System.out.println(a > c | b > c); // false | false ==> false
        System.out.println(a < c | b > c); // true  | false ==> true
        System.out.println(a > c | b < c); // false | true  ==> true
        System.out.println(a < c | b < c); // true  | true  ==> true
        System.out.println("========================");
        System.out.println(a > c ^ b > c); // false ^ false ==> false
        System.out.println(a < c ^ b > c); // true  ^ false ==> true
        System.out.println(a > c ^ b < c); // false ^ true  ==> true
        System.out.println(a < c ^ b < c); // true  ^ true  ==> false
        System.out.println("========================");
        System.out.println(a > c );     //false
        System.out.println(!(a > c) );  //true
        System.out.println(!!(a > c) ); //false
        System.out.println(!!!(a > c) );//true
  }
}

2.8三元运算符

/*
    三元运算符：
        格式：关系表达式 ? 表达式1:表达式2
        运算规则：
            1.先判断关系表达式的值
            2.如果关系表达式的值为true,取表达式1的值
            3.如果关系表达式的值为false，去表达式2的值
 */
public class Demo09三元运算符 {
    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?a:b;
        int min = a>b?b:a;
        System.out.println(min);
    }
}

2.9 求三个整数的最大值

/*
    使用三元运算符，求三个整数的最大值:
        165 210 175
    1.先求前两个最大值，临时最大值
    2.使用临时最大值和第三个数字比较获取最大值
 */
public class Demo11求三个整数的最大值 {
    public static void main(String[] args) {
        int a = 165;
        int b = 210;
        int c = 175;
        //临时最大值
        int tempMax = a>b?a:b;
        //求最大值
        int max = tempMax>c?tempMax:c;
        System.out.println(max);
    }
}

3.键盘录入

3.1键盘录入入门

/*
1.导包
import java.util.Scanner
2.创建对象
Scanner sc = new Scanner(System.in);
3.接收数据 int
int num = sc.nextInt();
*/


//导包
import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //接收数据
        System.out.println("请输入一个整数：");
        int num = sc.nextInt();
        System.out.println("键盘录入的数据是："+num);
    }
}

3.2键盘录入三个数字，求最大值

import java.util.Scanner;

/*
    键盘录入三个数字，求最大值
    分析：
        1.键盘录入
            导包
            创建对象
            接收数据
        2.求最大值
            2.1 先求两个数临时最大值
            2.2 在使用临时最大值和第三个数字比较 获取最大值
 */
public class Demo02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("键盘输入第一个数字");
        int num = sc.nextInt();
        System.out.println("键盘输入第二个数字");
        int num1 = sc.nextInt();
        System.out.println("键盘输入第三个数字");
        int num2 = sc.nextInt();

        int temMax = num > num1 ? num : num1;
        int max = temMax > num2 ? temMax : num2;
        System.out.println(max);
    }
}

3.3 判断是否是水仙花数

/*
    键盘录入一个数字判断是否是水仙花数 153 370 371 407
    水仙花数：
        首先是一个三位
        其次各个位上的立方和等于数字本身  153 = 1*1*1 + 5*5*5 + 3*3*3
    思路：
        1.键盘录入
            导包
            创建对象
            接收数据
        2.求三位数各个位上数字
        3.求各个位上数字的立方和
        4.判断
 */
public class Demo05 {
    public static void main(String[] args) {
        //1.键盘录入
        //创建对象
        Scanner sc = new Scanner(System.in);
        //接收数据
        System.out.println("输入三位数");
        int i = sc.nextInt();
        //2.求三位数各个位上数字
        int sum, ge, shi, bai;
        ge = i % 10;
        shi = i / 10 % 10;
        bai = i / 100 % 10;
        //3.求各个位上数字的立方和
        sum = ge * ge * ge + shi * shi * shi + bai * bai * bai;
        boolean flag = sum == i ? true : false;
        /*if (sum == i) {
            System.out.println("是");
        } else {
            System.out.println("不是");
        }*/
        System.out.println(flag);
    }

}