JAVA的入门学习2_int long double混合运算-CSDN博客

本文链接：https://blog.csdn.net/GO20201205/article/details/121175856

数据类型

快捷键

psvm ->public static void main

sout-> System.out.println

布尔类型变量

定义：

boolean value = true;

System.out.println(value);

注意事项 :

1. boolean 类型的变量只有两种取值 , true 表示真 , false 表示假 .

2. Java 的 boolean 类型和 int 不能相互转换 , 不存在 1 表示 true, 0 表示 false 这样的用法 .

3. boolean 类型有些 JVM 的实现是占 1 个字节 , 有些是占 1 个比特位 , 这个没有明确规定 .

+号拼接

其他数据类型与字符串使用+号拼接时，结果就是一个字符串

public class Test {
    public static void main(String[] args) {
        String str="hello";
        System.out.println(str);  //输出的是hello
        System.out.println("hello"+"world");//拼接   此处输出的是helloworld
        System.out.println("hello"+2+3);  //输出的是hello23
        System.out.println(2+3+"hello");  //输出的是5hello
        System.out.println("hello"+(2+3));//输出的是hello5
        System.out.println(2+""+3+"hello");//输出的是23hello
    }
}

常用的转义字符

\n 换行

\t 水平制表符

\' 单引号

\" 双引号

\\ 反斜杠

变量的作用域

也就是该变量能生效的范围 , 一般是变量定义所在的代码块 ( 大括号 )

示例：

class Test {
    public static void main(String[] args) {
        {
            int x = 10;
            System.out.println(x); // 编译通过; 
        }
        System.out.println(x); // 编译失败, 找不到变量 x. 
    }
}

变量的命名规则

硬性指标:

1. 一个变量名只能包含数字 , 字母 , 下划线

2. 数字不能开头 .

3. 变量名是大小写敏感的 . 即 num 和 Num 是两个不同的变量 .

注意 : 虽然语法上也允许使用中文 / 美元符 ($) 命名变量 , 但是强烈不推荐这样做 .

软性指标:

1. 变量命名要具有描述性 , 见名知意 .

2. 变量名不宜使用拼音 ( 但是不绝对 ).

3. 变量名的词性推荐使用名词 .

4. 变量命名推荐 小驼峰命名法 , 当一个变量名由多个单词构成的时候 , 除了第一个单词之外 , 其他单词首字母都大写.

小驼峰命名示例 :

int maxValue = 100;

String studentName = " 张三";

常量

1. 字面值常量

10 // int 字面值常量 ( 十进制 )

010 // int 字面值常量 ( 八进制 ) 由数字 0 开头 . 010 也就是十进制的 8

0x10 // int 字面值常量 ( 十六进制 ) 由数字 0x 开头 . 0x10 也就是十进制的 16

10L // long 字面值常量 . 也可以写作 10l ( 小写的 L)

1.0 // double 字面值常量 . 也可以写作 1.0d 或者 1.0D

1.5e2 // double 字面值常量 . 科学计数法表示 . 相当于 1.5 * 10^2

1.0f // float 字面值常量 , 也可以写作 1.0F

true // boolen 字面值常量 , 同样的还有 false

'a' // char 字面值常量 , 单引号中只能有一个字符

"abc" // String 字面值常量 , 双引号中可以有多个字符 .

2. fifinal 关键字修饰的常量

final int a = 10;

a = 20; // 编译出错 . 提示无法为最终变量 a 分配值

注意：常量不能在程序运行过程中发生修改 .

类型转换

int 和 long/double 相互赋值

int a = 10;

long b = 20;

a = b; // 编译出错 , 提示可能会损失精度 .

b = a; // 编译通过 .

int a = 10;

double b = 1.0;

a = b; // 编译出错 , 提示可能会损失精度 .

b = a; // 编译通过 .

long 表示的范围更大 , 可以将 int 赋值给 long, 但是不能将 long 赋值给 int.

double 表示的范围更大 , 可以将 int 赋值给 double, 但是不能将 double 赋值给 int.

结论 : 不同数字类型的变量之间赋值 , 表示范围更小的类型能隐式转换成范围较大的类型 , 反之则不行 .

int 和 boolean 相互赋值

int a = 10;

boolean b = true;

b = a; // 编译出错 , 提示不兼容的类型

a = b; // 编译出错 , 提示不兼容的类型

结论 : int 和 boolean 是毫不相干的两种类型 , 不能相互赋值 .

int字面值常量给 byte 赋值

byte a = 100; // 编译通过

byte b = 256; // 编译报错 , 提示从 int 转换到 byte 可能会有损失

注意 : byte 表示的数据范围是 -128 -> +127, 256 已经超过范围 , 而 100 还在范围之内 .

结论 : 使用字面值常量赋值的时候 , Java 会自动进行一些检查校验 , 判定赋值是否合理

使用强制类型转换

int a = 0;

double b = 10.5;

a = (int)b;

int a = 10;

boolean b = false;

b = (boolean)a; // 编译出错 , 提示不兼容的类型 .

结论 : 使用 ( 类型 ) 的方式可以将 double 类型强制转成 int. 但是

1. 强制类型转换可能会导致精度丢失 . 如刚才的例子中 , 赋值之后 , 10.5 就变成 10 了 , 小数点后面的部分被忽略 .

2. 强制类型转换不是一定能成功 , 互不相干的类型之间无法强转 .

数值提升

int 和 long 混合运算

int a = 10;

long b = 20;

int c = a + b; // 编译出错 , 提示将 long 转成 int 会丢失精度

long d = a + b; // 编译通过 .

结论 : 当 int 和 long 混合运算的时候 , int 会提升成 long , 得到的结果仍然是 long 类型 , 需要使用 long 类型的变量来

接收结果 . 如果非要用 int 来接收结果 , 就需要使用强制类型转换 .

byte 和 byte 的运算

byte a = 10;

byte b = 20;

byte c = a + b;

System.out.println(c);

// 编译报错

Test.java:5: 错误 : 不兼容的类型 : 从 int 转换到 byte 可能会有损失

结论 : byte 和 byte 都是相同类型 , 但是出现编译报错 . 原因是 , 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算 , 得到的结果也是 int, 这是赋给 c, 就会出现上述错误 .

由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据 . 为了硬件上实现方便 , 诸如 byte 和 short 这种低于 4 个字节的类型 , 会先提升成 int, 再参与计算 .

正确的写法 :

byte a = 10;

byte b = 20;

byte c = (byte)(a + b);

System.out.println(c);

int 和 String 之间的相互转换

int 转成 String

int num = 10;

// 方法 1

String str1 = num + "";

// 方法 2

String str2 = String.valueOf(num);

String 转成 int

String str = "100";

int num = Integer.parseInt(str);

运算符

算术运算符

基本四则运算符 + - * / %

举例：

System.out.println(10%3);   //1
System.out.println(-10%3);  //-1
System.out.println(10%-3);  //1
System.out.println(-10%-3); //-1

自增/自减运算符 ++ --

举例：

关系运算符int a=10;
int j=a++;
System.out.println(a);//11
System.out.println(j);//10
int b=10;
int i=++b;
System.out.println(b);//11
System.out.println(i);//11

关系运算符

关系运算符主要有六个 : == != < > <= >=

使用关系运算符的结果为布尔值

int a = 10;
int b = 20;
System.out.println(a == b);//false
System.out.println(a != b);//true
System.out.println(a < b);//true
System.out.println(a > b);//false
System.out.println(a <= b);//true
System.out.println(a >= b);//false