一, Java 数据类型
1, 基础数据类型(8 种)
1, 整数类型 (4 种)
byte 1 个字节 8 位,-2^8--2^8-1 范围是 - 128 到 127
short 2 个字节 16 位,-32768-32767
int 4 个字节 32 位,-2147483648-2147483647 常用
long 8 个字节 64 位,-9223372036854775808-9223372036854775807
注意: 给 long 赋值时, 因为整数默认是 int 类型, 要转换为 long 类型的值, 后面加上 l 或 L, 一般用 L,l 容易与 1 混淆.
2, 浮点类型(2 种)
float 单精度 4 个字节 32 位, 直接赋值时必须在数字后加上 f 或 F
double 双精度 8 个字节 64 位 常用
注意: 浮点运算很少是精确的, 只要是超过精度能表示的范围就会产生误差. 往往产生误差不是 因为数的大小, 而是因为数的精度. 因此, 产生的结果接近但不等于想要的结果. 尤其在使用 float 和 double 作精确运算的时候要特别小心.
商业中精准计算使用 java.math 包中提供的 API 类 BigDecimal.
3, 字符类型(1 种)
char 2 个字节 16 位, 字符常量使用单引号 ''包裹起来. char c = 65;// 表示'A' 这个字符, 使用一个数字表示, 对应有一个 ASCII 码表.
4, 布尔类型(1 种)
boolean 两个值 true 和 false
2, 引用数据类型
类, 数组, 接口, 枚举...
3, 数据类型转换
下面这 7 种数据类型, 它们之间都可以进行转换, 但是可能会存在精度损失或者其他一些变化:
byte --》 short ,char --》 int --》 long --》 float --》 double
如果从小转换到大,(除了 byte 不能自动转换 char , 以及 char 不能自动转换 short)可以自动完成转换. 而从大到小, 必须强制转换 (强制转换前必须知道被转换的值在要转换的类型范围内).
规律: 有包含关系的可以由低精度赋值给高精度. 高转低会导致精度丢失, 不同类型的强制转换, 可能会导致精度的下降.
问: 为什么
float
在
long
后面? 因为
小数
(
浮点数
)
的存储方式, 结构和整数不一样.
public class TypeCast {
@Test
public void testIntToDouble(){
int num = 10;
double d = 10.1;
double c = d + num;
System.out.println(c);
}
@Test
public void testShortToInt(){
short s = 10;
int num = 20;
int n = num + s;
System.out.println(n);
}
/**
* 从大到小, 必须强制转换
*/
@Test
public void testByteToInt(){
byte b=3;
b=(byte)(b*3);// 必须声明 byte.
System.out.println(b);
}
/**
* char 类型向更高长度类型 (例如整型) 转换时, 会转换为对应的 ASCII 码值, 再做其他类型的自动转换
*/
@Test
public void testCharToInt(){
char c = 'A';
int num = 10;
int a = c + num;
System.out.println(a);
}
}
注意: char 型具有两个字节, 其数值范围是 0 ~ 2^16-1, 这直接导致 byte 型不能自动类型提升到 char,char 和 short 直接也不会发生自动类型提升(因为值范围问题), 同时, byte 当然可以直接提升到 short 型. 所以, char 不能和 byte short 相互自动转换
小结: 在 Java 的领域里, 基本数据类型变量存的是数据本身, 而引用类型变量存的是保存数据的内存空间地址. 基本数据类型变量里存储的是直接放在抽屉里的东西, 而引用数据类型变量里存储的是 这个抽屉的钥匙, 钥匙和抽屉一一对应.
二, 常量
1. 常量介绍
Java
中的常量, 常量就是一个固定不变的量(或者值). 例如
123,45,1.2
,
false
等.
常见的分类
① 整数常量 例如: 123 ,250,666
② 小数常量 例如: 1.2,3.14
③ 字符串常量 例如:"12345"
④ 字符常量 例如: '2','B'
⑤ 布尔常量 例如: true ,false
上面的 5 种表示形式的常量都可以直接放在打印语句中打印.
2. 常见转义字符
①\n 表示换行;
②
\t
表示制表符, 相当于
Table
键;
③
\b
表示退格键, 相当于
Back Space
键;
④\'表示单引号;
⑤\''表示双引号;
⑥\\ 表示一个斜杠 \
三, 变量
1, 变量的语法
1, 先声明再赋值
int a;
a = 1;
2, 声明时同时赋值
int a = 1;
2, 变量的分类
1, 成员变量
1, 直接声明在类中的变量.(类中成员)
2, 如果成员变量没有赋值, 系统会分配默认值
3, 作用域范围, 整个类的范围
2, 局部变量
1, 直接声明在方法内部, 比如 main 方法的形参 或者 大括号中
2, 作用域范围, 只能在方法内使用, 局部变量, 必须放在使用的功能语句前面
3, 表达式
由一系列的
常量,
变量
,
运算符, 括号
()
组成的一个算式, 为了按照一定的运算规则计算出结果值
.
四, 运算符
1, 算数运算符
加 (+) 减(-)乘 (*) 除(/)取模(%)
public class Modulo {
/**
* 取模, 对整数取余 2, 结果为 0 是偶数, 为 1 是奇数
*/
@Test
public void modulo() {
System.out.println(6 % 2); // 余数是 0
System.out.println(7 % 2); // 余数是 1
}
}
一些常量表示符: NaN,Infinity 表示无穷大
2, 自增自减
++(自增) --(自减)
自增自减只能够用于
变量
, 不能用于常量
,
自增自减运算的优先级,
比
算术运算符
高
public class AutoAdding {
/**
* 自增
*/
@Test
public void autoAdding1() {
int i = 3; // 表示把 3 赋值给变量 i
i++; // 表示变量 i 的值加 1,i 的值变成 4
System.out.println(i);
++i; // 表示变量 i 的值加 1,i 的值变成 5
System.out.println(i);
}
/**
* 变量名在前 i++, 先赋值再自增
*/
@Test
public void autoAdding2() {
int i = 3;
int j = i++;
System.out.println(j); //3
System.out.println(i); //4
}
/**
* 变量名在前 ++i, 先自增再赋值
*/
@Test
public void autoAdding3() {
int i = 3;
int j = ++i;
System.out.println(j); //4
System.out.println(i); //4
}
@Test
public void autoAdding4() {
int i = 3;
int a = i++ + i++ + i++; //3(4) 4(5) 5(6)
int b = ++i + ++i + ++i; //7 8 9
System.out.println(a); //12
System.out.println(b); //24
System.out.println(i); //9
}
@Test
public void autoAdding5() {
int i = 5;
i++;
System.out.println("i=" + i);//6
++i;
System.out.println("i=" + i);//7
int a = ++i;
System.out.println("a=" + a);//8 i=8
a = a++;
System.out.println("a=" + a);//8
a = ++a;
System.out.println("a=" + a);//9
}
}
3, 赋值运算
= += -= *= /= %=
从右到左, 把符号右边的值赋值到左边的变量中
public class AssignmentOperator {
/**
* 赋值运算
*/
@Test
public void test1() {
int i = 3;
i += 2;// 表示把 2 累加到变量 i 中
System.out.println(i); //5
i -= 1;
System.out.println(i); //4
i *= 3;
System.out.println(i); //12
i /= 3;
System.out.println(i); //4
i %= 3;
System.out.println(i); //1
}
}
4, 比较运算符
== != > < >= <= instanceof
1, 比较运算的结果是一个布尔类型的值(
true
或
false
)
2,instanceof 是判断一个对象是否属于某种类型
public class ComparisonOperator {
@Test
public void test(){
int a = 3;
System.out.println(1 == 1); //true
System.out.println(a != 2); //true
System.out.println(a > 2); //true
System.out.println(a < 5); //true
int b = 5;
System.out.println(a >= b); //false
System.out.println(b <= 6); //true
System.out.println("hello" instanceof String); //true
}
}
5, 逻辑运算符
& | && || ^ !
1, 应用于多个条件的组合判断.
2, 逻辑运算符两边结果值的都必须是布尔类型.
&
: 两边都为
true
, 结果为
true
|
:
只要有一边为
true
, 结果为
true
&&
:
两边都为
true
, 结果为
true
|| :
只要有一边为
true
, 结果为
true
^ :
两边不一样, 结果为
true
, 否则为
false
!
:
逻辑非
3,&& || 和 & | 区别?
1) & | 既可以充当逻辑运算, 也可以是位运算符.
根据表达式的结果是否为布尔类型来判断
2) 双与 , 双或具有短路行为
如果逻辑运算左边的值能够确定整个逻辑运算表达式的值, 那么右边就
不执行了
, 短路了
.
&& 短路, 左边表达式结果为 false
|| 短路 , 左边表达式结果为 true
public class Demo {
/**
* 要判断 1 / 0 == 0 出现异常
*/
@Test
public void test1() {
System.out.println(1 < 0 & 1 / 0 == 0); //java.lang.ArithmeticException: / by zero
}
/**
* 短路, 不判断 1 / 0 == 0, 返回 false
*/
@Test
public void test2() {
System.out.println(1 < 0 && 1 / 0 == 0); //false
}
/**
* 要判断 1 / 0 == 0 出现异常
*/
@Test
public void test3() {
System.out.println(1 > 0 | 1 / 0 == 0); //java.lang.ArithmeticException: / by zero
}
/**
* 短路, 不判断 1 / 0 == 0, 返回 true
*/
@Test
public void test4() {
System.out.println(1 > 0 || 1 / 0 == 0); //true
}
}
4, 常见错误:
例如: 判断一个整数的变量
a
里面的数据 在
0-100
之间
正确写法: a>0 && a<100
错误写法: 0<a < 100 (java 没有这种语法, 不支持)
6, 位运算
& | ^ ~ <<>> >>>
1, 可以把
1
看成是
true,
把
0
看成是
false
2, 位运算就是二进制的位进行运算
& :
与 位运算, 两边为
1
, 结果为
1
| :
或 位运算, 有一个为
1
, 结果为
1
^ :
异或, 两边不一样, 就为
1
, 否则为
0
~ :
取反,
1
变成
0 ,0
变成
1
<< : 向左位移动, 例如 1<<3
>> : 向右位移动, 例如 8>>2
>>>: 无符号向右移动
public class BitOperation {
@Test
public void test() {
/* 与
* 00000011
* 00000100
* 00000000
* */
System.out.println(3 & 4); //0
/* 或
* 00000011
* 00000100
* 00000111
* */
System.out.println(3 | 4); //7
/* 向左位移动
* 00000001
* 00001000
*/
System.out.println(1 << 3); //8
/*~ 取反
* 原码: 1000 0000 0000 0101
* 反码: 1111 1111 1111 1010 符号位不变, 其他位取反
* 补码: 1111 1111 1111 1011 反码 + 1
* 补码再取反
* 0000 0000 0000 0100 --》 4
*/
System.out.println(~(-5)); //4
}
}
注意: 正数的补码, 反码, 原码都一样;
负数的反码: 符号为不变, 其他位取反;
负数的补码: 它的反码 + 1;
7, 三目运算符
语法格式: X ? Y : Z
1) 上面的三目运算整体看成是一个表达式, 应该有一个结果值
2) X 布尔类型的值或者结果为布尔类型的表达式
3) Y Z 一般来说数据类型相同的值或者表达式
4) 运算的规则
X
为
true
, 就是
Y
的结果值
(
冒号前面的表达式的值
)
X
为
false
, 就是
Z
的结果值
(
冒号后面的表达式的值
)
注意
:
不要受
?
和
:
的干扰, 它们只是一个固定语法格式
public class TernaryOperator {
/**
* 三目运算
*/
@Test
public void test() {
int num = 5;
System.out.println(num % 2 == 0 ? "偶数" : "奇数"); // 输出奇数
}
}
来源: http://www.bubuko.com/infodetail-2484025.html