目录
一、变量和类型
变量: 程勋运行时可变的量 , 相当于开辟内存来存储数据
类型: 对变量种类进行划分, 不同类型的变量具有不同的特性
1 pb = 1024 tb = 1024 gb = 1024 mb = 1024 kb = 1024 byte = 8 bit
在Java中任何数值类型都是有取值范围的
Java中用 Unicode表示字符. 每个 Unicode占用 2 个字节, 每个字节是 8 bit位
包装类指的是，基本数据类型对应的类类型。因为基本数据类型无法进行对象化处理, 所以引入了包装类( 8中基本数据 byte, short, int, long, float, double, char,boolean, 除了int 对应的是Integer, char 对应的是Character, 其余都是首字母大写即可).
二、基本数据类型
1. 整型变量( int )☆☆☆☆☆
- int 是 4个字节: 充分说明: 可移植性强( 一次编译,到处运行: 跨平台性)
- java中的 int , 没有所谓的无符号类型, 统一都是有符号的
- 取值范围:-2147483648 ~ 214743647 ==> -2^31 ~ 2^31-1
- int的最大取值: System.out.println(Integer.MAX_VALUE ) ( Integer[ 包装类]: int的plus版本 )
- int的最小取值System.out.println(Integer.MIN_VALUE )
- 变量的命名: 小驼峰(第一个首字母小写,其他大写 [maxNum, max_num, max$num, max3_num ]) -> 数字 字母 下划线 美元符号 组成 ( 不能以数字开头 )
- 变量在使用前必须得初始化!!!! 如果不初始化就使用,编译器会报错
2.长整型变量(long)
- long 是 8 个字节 long a = 10L (定义long类型时,L最好是大写)
- 取值范围: -2^63 ~ 2^63 -1
- long的最大取值: System.out.println(Long.MAX_VALUE )
- long的最小取值System.out.println(Long.MIN_VALUE )
- Java中不存在 long long类型
3.双精度浮点型变量(double)
- double 是 8个字节
- 小数本身是没有一个精确地数字的, 只能精确到小数点后几位 float ->6
4.单精度浮点型变量(float)
- float 是 4 字节 float f = 12.5f (后面加 f 或 F 表明它是单精度浮点类型 )
5.字符类型变量(char)
- char 是 2 个字节 char ch = ‘特’ (C 中 char是一个字节)
- Java中使用 单引号( ‘ ‘ ) + 单个字母 的形式表示字符字面值
- 计算机中字符本质上是一个整数. C语言中使用 ASCII 表示字符, 而Java中用 Unicode表示字符. 因此,一个字符占用两个字节, 表示的字符种类更多, 包括中文
6.字节类型变量(byte)
- byte 是 1 个字节 byte b = 10 (数据类型不一样, 字节大小不一样)
- 取值范围: -128 ~ 127
7.短整型变量(short)
- short 是 2 个字节 short s = 10
- 取值范围: -32768 ~ 32767
8. 布尔类型变量(boolean)
- boolean 取值 为true 和 false, 不能有其他的值
- Java中 boolean 类型 和 int 不能相互转换,不存在 1 表示 true, 0 表示 false这样的用法
- boolean 类型有些jvm 的实现是占1 字节, 有些事占1 个比特位,没有明确规定
三、字符串数据类型
单引号 ‘a’ -> 字符
双引号 “若干字符 ” -> 字符串
1. 字符串拼接
public class TestDemo {
public static void main(String[] args) {
String str = "hello";
System.out.println(str);
//注意问题
System.out.println("hello" + "world"); //拼接
System.out.println("hello" + 10 + 20); //其它数据类型和字符串使用 + 拼接, 结果就是一个字符串
System.out.println("hello" + (10 + 20)); //hello30
// 计算机从左往右开始计算,先计算10 +20 得到整数30, 在进行字符串拼接
System.out.println(10 + 20 + "hello"); //30hello
System.out.println(10 + "" + 20 + "hello"); //1020hello
//a = 10, b = 20
System.out.println("a = " + 10 + ", b = " + 20);
}
}
2. 转义字符
字符串中的一些特定的不太方便直接表示的字符需要进行转义
\n : 回车 \t : 制表符
public class TestDemo {
public static void main(String[] args) {
String s1 = "\"bit\""; // "bit"
String s2 = "\\bit\\";// \bit\
String s3 = "\\\\bit\\\\"; // \\bit\\
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
}
}
四、变量的作用域
1.变量基本要领
①变量分为成员变量和局部变量;; 成员变量又分为普通成员变量( 定义在类的内部, 方法的外部 )和静态成员变量 [ Java中没有全局变量的概念 ]
②变量找作用域时, 找变量最近的花括号 {}
- 程序运行的时候可以改变的量;
- 在程序运行的时候再能知道里面的值是多少
2.变量的命名规则
①硬性指标
- 一个变量名只能包含字母, 数字, 下划线和美元符号($ 不建议);
- 数字不能开头;
- 有大小写区分
②软心指标
- 变量名具有描述性(见名知意);
- 变量名不宜使用拼音(不绝对);
- 变量名词性推荐名词;
- 命名推荐小驼峰命名法(当一个变量名有多个单词构成时,除了第一个单词之外,其余单词首字母都大写)
五、常量
- 在程序运行的过程中不可以修改;
- 在程序编译时,就已经确定其值是什么了(只能初始化一次)
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.final修饰的常量 ->常量
常量不能在程序中发生修改
public class TestDemo {
public static void main(String[] args) {
int a = 10;
System.out.println(a); //10
final int SIZE = 20;
//a = 20; //编译出错,提示 无法为最终变量a 分配值
System.out.println(SIZE); //20
}
}
六、类型转换
1. int 和 long/double 互相赋值
public class TestDemo {
public static void main(String[] args) {
int a = 10;
long b = a; //正确
long l = 12;
//int c = l; //报错
int c = (int)l; //只能强制类型转换: 有风险
int d = 10;
double e = 1.0;
//d = e; //编译出错
e = d; //正确
}
}- long 表示的范围更大, 可以将 int 赋值给 long, 但是不能将 long 赋值给 int.
- double 表示范围更大, 可以将 double 赋值给 long, 但是不能将 long 赋值给 double.
- 总之, 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型, 反之不行.
2. int 和boolean 相互赋值
public class TestDemo {
public static void main(String[] args) {
int a = 10;
// Boolean b = (boolean)a;
boolean c = true;
//int d = (boolean)c;
}
}int 和 boolean 是毫不相干的两种类型,不能互相赋值
3.int 字面值常量给 byte 赋值
将一个字面值常量进行赋值时,Java会自动针对数字范围进行检查
七、数值提升
1.int 和 long混合运算
public class TestDemo {
public static void main(String[] args) {
int i1 = 10;
long l1 = 20;
//int i2 = i1 + l1; //报错 会将int类型提升为long类型
int i2 = (int)(i1 + l1);
}
}当 int 和 long 混合运算时, int 会提升成 long, 得到的结果仍然是long类型, 需要 long 类型的变量接收结果. 如果非要用 int 来接收结果, 就需要强制类型转换.
2. byte 和 byte 的运算
public class TestDemo {
public static void main(String[] args) {
byte a = 1; // byte取值范围-128~127
byte b = 2;
//byte c = a + b; //报错
//原因:对于CPU来说, 小于4个字节运算时,会提升为int类型 (a+b)为int型,不能赋值给byte,只能强制类型转换
byte c = (byte)(a + b);
System.out.println(c);
byte c2 = 1 + 2; //不报错 1和2都是常量,在程序编译时, 这里已经被编译为3了(byte c2 = 3)
}
}由于CPU通常是按照4个字节为单位从内存中读写数据. 为了硬件上实现方便,诸如 byte 和 short 这4个字节的类型, 会先提升成 int , 在参与计算.
- 不同类型的数据混合运算, 范围小的会提升成范围大的
3.int 和 String 之间的相互转换
- int 转成 String
- String 转成 int
体现了包装类的作用, 八种基本数据类型都有包装类(int -> Integer, char -> Character, 其余首字母大写)
public class TestDemo {
public static void main(String[] args) {
int num = 10;
String ret = String.valueOf(num); //valueOf(int i): 返回int参数的字符串
System.out.println(num);
String str = "123";
int ret1 = Integer.valueOf(str); //将字符串类型返回成整型参数
System.out.println(ret1 +1); //124
}
}
八、运算符
1.算术运算符
①基本四则运算 + – * / %
- int / int , 需要用double输出结果
- 除数不能是0;
- %： 取余, 求模, 取模
public class TestDemo {
public static void main(String[] args) {
System.out.println(-10%3); //-1
System.out.println(10%-3); //1
System.out.println(-10%-3); //-1
}
}②增量赋值运算符 += -= *= /= %=
public class TestDemo {
public static void main(String[] args) {
int a = 10;
a += 1; //a = a + 1
System.out.println(a); //11
short s = 10;
s += 9; //自动进行强制类型转换
System.out.println(s);
}
}③自增/自减运算符 ++ —
public class TestDemo {
public static void main(String[] args) {
int a= 10;
a++;
System.out.println(a); //11
int b = 10;
++b; //前置++ 和 后置++ 这样写没有区别
System.out.println(b); //11
int c= 10;
int i1 = c++; //先赋值后++;
System.out.println(i1); //10
int d = 10;
int i2 = ++d; //先++后赋值 c = c + 1 i2 = c
System.out.println(i2); //11
}
}
2.关系运算符
== != < > <= >=
关系运算符的表达式返回值都是boolean类型
public class TestDemo {
public static void main(String[] args) {
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
}
}
3.逻辑运算符
&& || !
逻辑运算符的操作数和返回值都是boolean类型
- [表达式1 && 表达式2 ] 只要一个表达式为假, 整个表达式都为假 ( 短路: 如果表达式1为假,就不执行表达式2)
- [表达式1 || 表达式2 ] 只要一个表达式为真, 整个表达式都为真 ( 短路: 如果表达式1为真,就不执行表达式2)
- [ !表达式 ] 结果与表达式相反
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
System.out.println(a > b && b < c); //false : false && true b < c不执行
System.out.println(a < b || b > c); //true : true || false b > c不执行
System.out.println(!(a < b)); //false : !true
}
}
4.位运算符
& | ~ ^
- Java中对数据操作的最小单位是二进制位
- 位操作表示按二进制位运算.
① 按位与&: 如果两个二进制位对应位都是1, 则结果为1, 否则结果为0.
0000 1101
0010 1011 &
——————
0000 1001
②按位或 | : 如果两个二进制位对应位有1, 则结果为1, 否则结果为0.
0000 1101
0010 1011 |
——————
0010 1111
③按位异或 ^ : 如果两个二进制位对应位一样, 则结果为0,否则为1.(本质找不同)
0000 1101
0010 1011 ^
——————
0010 0110
④按位取反 ~ : 0变1, 1变0
0101 1011 ~
1010 0100
十进制 -> 二进制 -> 八进制 -> 十六进制
二进制(0000 1010 1011 0010)转八进制
000 000 101 010 110 010 ->
0 0 5 2 6 2
二进制(0000 1010 1011 0010)转十六进制
0000 1010 1011 0010 ->
0 a b 2
5.移位运算
<<(左移) >>(右移) >>>(无符号右移)
<<(左移)
0000 1011 << 1 -> 0001 0110 ==> 22 => 11*2^1
0000 1011 << 2 -> 0010 1100 ==> 44 => 11*2^2
>>(右移补符号位)
0000 1011 >> 1 -> 0000 0101 ==> 5 => 11/2^1
0000 1011 >> 2 -> 0000 0010 ==> 2 => 11/2^2
1111 1111 >> 1 -> 1111 1111
>>>(无符号右移): 不管符号位是啥, 左边统一补0 [ 没有无符号左移]
1111 1111 >>> 1 -> 0111 1111
6.条件运算符
表达式1 ?表达式2 : 表达式3 (表达式1 必须为布尔表达式)
public class TestDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println(max); //20
}
}
7.运算符的优先级
不需要特别记忆优先级的高度顺序, 只需要根据逻辑加括号就可以