Java入门--数据类型的转换及运算符的使用。

在等我打两行

已于 2022-04-06 17:13:52 修改

阅读量707

点赞数 4

文章标签： java

于 2022-04-06 11:10:10 首次发布

本文链接：https://blog.csdn.net/jaygegeg/article/details/123965178

版权

3.3自增和自减运算符（++i，i++，--i，i--）

6.2 完成猜数字游戏，系统随机生成一个数，用户输入一个数，二者比大小，大于输出大于，小于输出小于，等于的时候退出程序。

6.3 编写代码模拟三次密码输入的场景。最多能输入三次密码，密码正确，提示“登录成功”,密码错误，可以重新输入，最多输入三次。三次均错，则提示退出程序。

6.4 输出n*n

的乘法口诀表，n由用户输入。

1.数据类型的相互转换

1.1小类型转为大类型

小类型的变量赋值给大类型的变量时是自动提升的。小类型和大类型在数学运算时，首先将小类型提升为大类型然后在进行数学运算。（例：int + long = long + long）

public class Text {
    public static void main(String[] args) {
        int a = Integer.MAX_VALUE;
        long b = a + 1;
        System.out.println(b);
    }
}

运行结果：-2147483648

程序执行时都是从右往左执行，先进性的是a + 1，已经溢出了，把一个溢出的值让long接收了，并不是long放不下，而是储存了一个溢出值。

1.2大类型转为小类型

大类型转为小类型需要强制类型转换，可能会丢失精确度。（数据溢出或数据部分丢失）对于数值型和字符型来说，小于4字节的数据类型，在存储时会转换为4字节。（byte类型在保存时会转换为int类型，当把byte类型保存在区间之内的整数赋值给byte时，可以直接赋值，超出byte的范围时仍需要强制类型转换）

int和char之间的相互转换：计算机内部都是0和1，char字符会按照不同的编码规则转为int型，char转为int型，为自动提升。

public class Text {
    public static void main(String[] args) {
        char a = 'a' ;
        int b = a;
        System.out.println(b);
    }
}

输出结果：97

按照Unicode编码将‘a’转换为int型，所谓的编码，就是把不同的文字和符号按照一定的数字规则转换为数字。

char转为int型：需要强制转换。

public class Text {
    public static void main(String[] args) {
        int a = 97 ;
        char b = (char) a;
        System.out.println(b);
    }
}

运行结果：a

int和String的相互转换：int转为String，1.直接使用String对象+；2.使用String的ValueOf方法。String转为int，调用int包装类Integer.prselnt（）方法，当字符串包含非数字时，转换出错。

1.3布尔型（boolean）

布尔型类型不能和其他基本类型进行数据类型的转换，既不能进行类型的提升，也不能进行强制转换，否则编译器会报错。

2.常量（final）

在Java中，用关键字final来指示常量，关键字final表示这个变量只能被赋值一次。一旦被赋值之后，就不能在更改了。（习惯上常量名称使用全大写）。

在Java中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。可以使用关键字static final设置一个类常量。

3.运算符

3.1常用运算符（+，-，*，/，%）

在Java中，使用算术运算符+，-，*，/表示加，减，乘，除运算。当参与/运算的两个操作数都是整数时，表示整数除法；否则，表示浮点法。整数的求余操作（有时也称为取模）用%表示。

3.2结合赋值和运算符（+=）

可以在赋值中使用二元运算符，这是一种很方便的简写方式。例如，x += 5 等价于：x = x + 5（一般地，要把运算符放在=左边）

3.3自增和自减运算符（++i，i++，--i，i--）

i++：先取a的值在+1；++i：先+1再取值；自减同上。（只有在赋值过程中存在区别，其余情况没有区别）

3.4逻辑运算符（&&，||，！）

&&逻辑与，有一个fasle返回fasle；||逻辑或，有一个true返回true；！取反，把布尔值(boolean)取反。

括号与运算符级别：如果不使用圆括号，就按照给出的运算符优先级次序进行计算。同一个级别的运算符按照从左到右的次序进行计算。例如，由于&&的优先级比||的优先级高，所以表达式a&&b||c，等价于（a&&b）||c。又因为+=是右结合运算符，所以表达式a += b += c，等价于a += （b += c），也就是将b += c的结果（加上c之后的b）加到a上。（需要先运算的加个括号）

按位或|:两个二进制都是1返回1，都为0返回0；按位与&：如果两个二进制位都为1，返回1，否则返回0；按位取反：该位为0，转为1，该位为1，转为0;按位异或^;两个二进制相同返回0，不同取1；（快速找到出现一次的数字。）

3.5移位运算符（<<,>>）

<<(二进制数向左移动一个单位，相当原数字乘2)；>>（右移动一个单位，相当原数字除2）；

3.6条件运算符（唯一一个三目运算符）

表达式1？表达式2？表达式3（当表达式1为true时取表达式2的值，否则取表达式3的值）

4.语句结构

4.1顺序结构

public class Text {
    public static void main(String[] args){
        System.out.println("aaa");
        System.out.println("bbb");
        System.out.println("ccc");
    }
}

输出结果：aaa
bbb
ccc

顺序结构：就是将代码按照顺序一行一行的来执行，如果改变代码的书写顺序，则执行顺序也将发生改变。

4.2分支结构

4.2.1 if语句

1.只有if语句

if（布尔表达式）{

//满足该分支的代码块

}

2.if...else语句

if（布尔表达式）{

}else{

//条件不满足时执行的代码

}

3.if...else if ...else语句

if（布尔表达式）{

}else if(布尔表达式){

}else{

//上述都不满足时执行的代码

}

分支语句的嵌套问题：指的是在任意一个分支中，还可以嵌套分支。

分支语句的表达式不宜过多，最多写俩方便排查。

if...else和if...else if...else的区别：if（表达式1）{}

if（表达式2）{} 则表达式1和表达式2都可以满足。

if（表达式1）{}

else if（表达式2）{} 表达式1和表达式2互斥关系，一行代码只能走一个分支。

写一段程序，年龄小于18岁的为少年，青年（19~28），中年（29~55），老年为55岁以上。

public class Age {
    public static void main(String[] args) {
        int age = 56;
        if (age <= 18){
            System.out.println("少年");
    }else if(age <= 28 ){
            System.out.println("青年");
        }else if (age <= 55){
            System.out.println("中年");
        }else {
            System.out.println("老年");
        }

        }
}

输出结果：老年

此代码用的是if...else if...else语句，不满足上一表达式，直接跳转下一表达式，知道满足为止。

注意事项：Java分支中的规范书写。

public class Text {
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        if (a != 10){
            if (b == 20){
                System.out.println("aaa");
            }
        }else{
            System.out.println("bbb");
        }
    }
}

带{}，要是不带{}，则else就服从第二个if语句，程序开发中有一个就近匹配原则。

4.2.2 switch语句

jdk8表示多重选择，应用较为局限，不如if...else灵活。 switch（int，char，String，eunm枚举）其他类型都不允许使用switch分支。

switch（int，String，char，eunm）{

case 内容1：

满足内容1的语句；

【break；】

case 内容2：

满足内容2的语句：

【break；】

default：

上述所有分支都不满足的情况

【break；】

}

碰到break语句不往下执行，碰到continue跳过本次循环，继续下一次循环。

4.2.3 while循环

while（循环终止的条件）{

//循环代码

}

表达式为true时，循环体代码就会执行，知道表达式为false，循环体代码不在执行。

找出100~200之间是3 的倍数。

public class Text {
    public static void main(String[] args) {
        int num = 100;
        while (num <= 200){
            if (num % 3 != 0){
                num ++;
                continue;
            }
            System.out.println(num);
            num ++;
        }
    }
}

while{

while{

if（表达式）{

break；

}

}

}

break默认只能终止当前循环，若此时需要跳出本次循环的同时跳出外层循环，使用break label。

4.2.4 for循环

for（初始化条件；循环终止条件；更新循环变量）{

//循环体代码

}

for循环idea上的快捷键为“fori”，for循环顺序先是初始化条件，然后循环终止条件，然后循环体代码，然后是更新循环变量，直到结束。

找出0~1000之间的水仙花数（三位数字，切各个位数字的三次方之和等于之前的三位数）

public class guessNumber {
    public static void main(String[] args) {
        for (int i = 100; i < 999; i++) {
            int j = i / 100;
            int k = (i - j * 100) / 10;
            int l = (i - j * 100 - k * 10);
            if (j * j * j + k * k * k + l * l * l == i) {
                System.out.println(i + "是水仙花数");
            }
        }
    }
}

//运行结果

153是水仙花数
370是水仙花数
371是水仙花数
407是水仙花数

5.系统输入（scannner）

要使用Scanner类，必须要产生Scanner的对象Scanner in = new Scanner（System.in）；

import java.util.Scanner;

public class ScannerText {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //Scanner.java.util
        //从键盘获取字符串输入
        System.out.println("请输入你的名字");
        String name = scanner.nextLine();
        //nextLine表示从当前的键盘中获取一个数然后就换行了
    }
}

System.out.println（打印字符，并换行）
System.out.print(打印字符，不换行)
System.out.printf(格式化输出)

单行注释//（快捷键ctrl/）
多行注释/*...... */
文档注释/**........ */（一般用在方法和类的声明之前，快捷键Ctrl+d）

6.课后习题

6.1输入两个数，输出他们的最大公约数。

import java.util.Scanner;

public class Gongyueshu {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个数：");
        int a = sc.nextInt();
        int b = sc.nextInt();
        int num = 0;
        int temp = 0;
        if (a < b){
            temp = a;
        }else{
            temp = b;
        }
        for (int i = 2; i <= temp ; i++) {
             if (a % i == 0 && b % i == 0){
                 num = i;
                 }
             }
        if (num == 0){
                 System.out.println("没有最大公约数");
             }else{
                System.out.println("最大公约数"+num);
            }
    }
}

//运行结果

请输入两个数：
56
42
最大公约数14

6.2 完成猜数字游戏，系统随机生成一个数，用户输入一个数，二者比大小，大于输出大于，小于输出小于，等于的时候退出程序。

import java.util.Random;
import java.util.Scanner;

public class ScannerText {
    public static void main(String[] args) {
        Random random =  new Random();
        Scanner sc = new Scanner(System.in);
        //从键盘获取字符串输入
        int toGuess = random.nextInt(1000);
        while (true){
            System.out.println("请输入一个数字");
            int num = sc.nextInt();
            if (num < toGuess){
                System.out.println("小于");
            }else if (num > toGuess){
                System.out.println("大于");
            }else{
                System.out.println("等于");
                break;
            }
        }
        sc.close();
    }
}

系统所给的数字在0~1000之间。

6.3 编写代码模拟三次密码输入的场景。最多能输入三次密码，密码正确，提示“登录成功”,密码错误，可以重新输入，最多输入三次。三次均错，则提示退出程序。

import java.util.Scanner;

public class Password {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        for (int i = 2; i >= 0 ; i--) {
            int password = sc.nextInt();
            if (password == 123456) {
                System.out.println("密码正确");
                break;
            }else{
                System.out.println("你输入错误，还有"+i+"次机会");
            }if(i == 0){
                System.out.println("您的机会已用完");
            }
        }
    }
}

本段代码中所设置的密码为：123456

6.4 输出n*n

的乘法口诀表，n由用户输入。

import java.util.Scanner;

public class Chart {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i ; j++) {
                System.out.print(i + "*" + j + "=" + (i * j) + "\t");
            }
            System.out.println();
        }
    }
}

//运行结果

6
1*1=1
2*1=2   2*2=4
3*1=3   3*2=6   3*3=9
4*1=4   4*2=8   4*3=12   4*4=16
5*1=5   5*2=10   5*3=15   5*4=20   5*5=25
6*1=6   6*2=12   6*3=18   6*4=24   6*5=30   6*6=36

在等我打两行

关注

4
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java入门--数据类型的转换及运算符的使用。

目录1.数据类型的相互转换1.1小类型转为大类型1.2大类型转为小类型1.3布尔型（boolean）2.常量（final）3.运算符3.1常用运算符（+，-，*，/，%）3.2结合赋值和运算符（+=）3.3自增和自减运算符（++i，i++，--i，i--）3.4逻辑运算符（&&，||，！）3.5移位运算符（<<,>>）3.6条件运算符（唯一一个三目运算符）4.语句结构4.1顺序结构4.2分支结构4.2
复制链接

扫一扫