目录
一、数据类型
1.变量和类型
2.整型类型int
3.长整型long
4.双精度浮点型变量double
5.单精度浮点型变量float
6.字符类型变量char
7.字节类型变量byte
8.短整型变量short
9.布尔类型变量boolean
10.字符串类型变量
11.变量的作用域
12.变量的命名规则
13.常量
14.类型转换
15.数值提升
16.int和string的相互转换
总结:
二、运算符
1.算术运算符
2.关系运算符
3.逻辑运算符
4.位运算符
5.移位运算符
6.条件运算符
7.运算符的优先级
三、注释
(1)基本语法形式:int 变量名 = 初始值;
(2)没有所谓的无符号类型,统一都是有符号的,一个 int 变量占 4 个字节,和操作系统没有直接关系。第一位为符号位,其余31位为数值位,所以int的大小范围:-2^31 -> 2^31-1,即-2147483648~2147483647。如果运算的结果超出了 int 的最大范围, 就会出现溢出的情况。
public class DataTyprs{
public static void main(String[] args){
int maxValue = Integer.MAX_VALUE;
int minValue = Integer.MIN_VALUE;
System.out.println(maxValue);
System.out.println(maxValue+1);
System.out.println(minValue);
System.out.println(minValue);
}
}
编译运行该代码,输出如下:
(1)基本语法形式:long 变量名 = 初始值;建议初值加一个后缀L或l,如:10L或10l
(2)long 类型占 8 个字节. 表示的数据范围 -2^63 -> 2^63-1
public class TestData{
public static void main(String[] args){
System.out.println(Long.MAX_VALUE);//9223372036854775807
System.out.println(Long.MIN_VALUE);//-9223372036854775808
}
}
public class TestData{
public static void main(String[] args){
double num = 1.1;
System.out.println(num*num);
}
}
编译运行该代码,输出如下:
1.2100000000000002
(1)基本语法形式:double 变量名 = 初始值;建议初值加一个后缀F或f,如:10.1F或10.1f
(1)基本语法形式:char 变量名 = 初始值;
(2)Java 中使用 单引号 + 单个字母 的形式表示字符字面值.
(3)计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一 个字符占用两个字节, 表示的字符种类更多, 包括中文.使用一个字符表示一个汉字,如:char ch = '呵';
(1)基本语法格式: byte 变量名 = 初始值;
(2)short 占用 2 个字节, 表示的数据范围是 -32768 -> +32767。这个表示范围比较小, 一般不推荐使用。
(1)基本语法格式: boolean 变量名 = 初始值;
(2)boolean 类型的变量只有两种取值, true 表示真, false 表示假
(3)Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法
public class TestData{
public static void main (String[] args){
boolean value = true;
System.out.println(value+1);
}
}
编译运行该代码,会发现编译错误。value的类型是boolean,1的类型是int。
(4)boolean 类型有些 JVM 的实现是占 1 个字节, 有些是占 1 个比特位, 这个没有明确规定。假设有一条4选1的选择题题,这时要去看其他3项有无明显错误
转义字符 | 解释 |
\n | 换行 |
\t | 水平制表符 |
\' | 单引号 |
\" | 双引号 |
\\ | 反斜杠 |
(5)字符串使用“+”表示字符串的拼接(当一个 + 表达式中存在字符串的时候, 都是执行字符串拼接行为)
System.out.println("hello"+"world");//helloworld
字符串和其他数据类型使用“+“拼接,结果就是一个字符串,如:
System.out.println("hello"+10+20);//hello1020
但是也有一些特例:
System.out.println(10+20+"hello");//30hello 这是因为括号里的式子从左往右计算,所以会先加起来等于30再与hello拼接为30hello
那么如何才能打印出hello30和1020hello呢?
System.out.println("hello"+(10+20));//hello30 加一个括号,就会先进行加法,再进行拼接啦
System.out.println(10+""+20+"hello");//1020hello ""是一个空字符串,10+""就拼接为一个字符串"10","10"再和20拼接为字符串"1020",最后"1020"与"hello"拼接为“1020hello”
public class TestData{
public static void main(String[] args) {
{
int x = 10;
System.out.println(x); // 编译通过;
}
System.out.println(x); // 编译失败, 找不到变量 x.
}
}
常量指的是运行时类型不能发生改变。常量主要有以下两种表现形式:
(1)字面值常量
不能在程序运行过程中发生修改.
public class TestData{
public static void main(String[] args){
final int a = 10;
a = 20;
}
}
public class TestData{
public static void main(String[] args){
int a = 10;
long b = 20;
double c = 30.0;
a = b; // 编译出错, 提示可能会损失精度,也许我们会想int还放不下一个小小的20吗?这是因为b是一个变量,程序运行时才知道b的值,所以在编译时不知道b的值,所以编译出错
b = a;//编译通过
a = c; // 编译出错, 提示可能会损失精度
c = a;//编译通过
}
}
(2)int 和 boolean 相互赋值
public class TestData{
public static void main(String[] args){
int a = 10;
boolean b = true;
b = a; // 编译出错, 提示不兼容的类型
a = b; // 编译出错, 提示不兼容的类型
}
}
public class TestData{
public static void main(String[] args){
byte a = 100; // 编译通过
byte b = 256; // 编译报错, 提示 从int转换到byte可能会有损失 byte 表示的数据范围是 -128 -> +127
}
}
public class TestData{
public static void main(String[] args){
int a = 0;
double b = 10.5;
a = (int)b; //精度丢失,10.5会变成10
int c = 10;
boolean d = false;
d = (boolean)c;// 编译出错,提示不兼容类型
}
}
(1)int和long的混合运算
public class TestData{
public static void main(String[] args){
int a = 10;
long b = 20;
int c = a + b; // 编译出错, 提示将 long 转成 int 会丢失精度
long d = a + b; // 编译通过
}
}
CPU在进行>4byte的数据的运算时,会将范围小的数据提升为范围大的数据,如上面的代码,当 int 和 long 混合运算的时候, int 会提升成 long, 得到的结果仍然是 long 类型, 需要使用 long 类型的变量来接收结果. 如果非要用 int 来接收结果, 就需要使用强制类型转换
(2)byte和byte的运算
public class TestData{
public static void main(String[] args){
byte a = 1;
byte b = 2;
byte c = a + b;
byte d = 1 + 2;
System.out.println(c);//编译报错,原因:不兼容的类型: 从int转换到byte可能会有损失
System.out.println(d);//3 1和2都是字面值常量,在程序编译时,已经被编译为3了
}
}
由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于4个字节的类型, 会先提升成 int, 再参与计算
可以修改为byte c = (byte)(a+b);
int---->String
valueOf() 方法用于返回给定参数的原生 Number 对象值,参数可以是原生数据类型, String等
public class TestData{
public static void main(String[] args){
int num = 10;
//方法一:
String ret = String.valueOf(num);
//方法二:
String str = num + "";
System.out.println(ret);
System.out.println(str);
}
}
编译运行该代码,输出如下:
10
10
String------>int
public class TestData{
public static void main(String[] args){
String str = "100";
int num = Integer.parseInt(str);
System.out.println(num);
}
}
编译运行该代码,输出如下:
100
(1)基本运算符 + - * / %
这里值得注意的是/和%:
对于/:int/int=int,诸如1/2这样的计算要用double;0不能作除数,否则会抛出异常,后面的代码都不会执行
对于%:不仅仅可以对 int 求模, 也能对 double 来求模。注意以下3个式子:
-10%3 10%-3 -10%-3,没错它们的答案分别是-1,1,-1
(2)增量赋值运算符 += -= *= /= %=
public class TestData{
public static void main(String[] args){
short s = 10;
s = (short)(s+9);
y += 9;
System.out.println(s);
System.out.println(y);
}
}
编译并运行该代码,输出如下:
19
19
可以看到增量赋值运算符会完成自动类型转换
(3)自增/自减运算符 ++/ --
关系运算符主要有:== != < > <= >=
public class TestData{
public static void main(String[] args){
System.out.println(10 > 20);
}
}
编译运行该代码,输出如下:
false
移位运算符有3个:>> << >>> 都是按照二进制位来运算
运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可。如:
System.out.println(10 < 20 && 20 < 30);
注释是为了让代码更容易被读懂而附加的描述信息. 不参与编译运行, 但是却非常重要