文章目录
前言
什么是字节
为了防止一些小伙伴不清楚计算机存储单位, 我贴心的帮大家”科普”一下
如果知道的小伙伴, 可以直接去看数据类型
- 位(bit) : 是计算机内部数据储存的最小单位, 11001100是一个八位二进制数
- 字节(byte) : 是计算机中数据处理的基本单位, 习惯上用大写B来表示
- 字符: 是指计算机中使用的字母、数字、字和符号
- 1bit表示1位
- 1Byte表示一个字节, 1B = 8b
- 1024B = 1KB
- 1024KB = 1M
- 1024M = 1G
1.数据类型
语言分为: 强类型语言和弱类型语言, Java属于强类型语言
- 强类型语言: 要求变量的使用严格符合规定, 所有变量必须先定义后才能使用
- 弱类型语言: 也称为弱类型定义语言。与强类型定义相反。像vb,php等就属于弱类型语言
Java的数据类型分为两大类:
- 基本类型
- 引用类型
基本数据类型分为三大类:数值类型、字符类型、boolean类型
1.数值类型
数值类型又分为两类:整数类型和浮点类型
1.1整数类型
-
byte: 占1个字节, 范围:-128 -> 127
-
short: 占2个字节, 范围: -32768 -> 32767
-
int: 占4个字节, 范围: -2147483848 -> 2147483847
-
long: 占8个字节, 范围: -9223372036854775808 -> -9223372036854775807
byte num1 = 10; short num2 = 20; int num3 = 30; // int最常用 long num4 = 40L; // long类型需要在数字后面加上L便于区分
1.2浮点类型
-
float: 占4个字节
-
double: 占8个字节
float num5 = 40.1f;// float类型要在数字后面加上f double num6 = 3.1415926;
2.字符类型
-
char: 占2个字节
// char类型只能存放一个单独的字符 char name1 = 'A'; // 错误写法: char name1 = 'Aa'; char name2 = '陈'; // 错误写法: char name1 = '小陈';
3.boolean类型
-
boolean类型: 占1位, 且值只有true和false两个
// boolean类型只有两个值, 一个为true一个为false boolean flag1 = true; boolean flag2 = false;
总结: 共有八大基本数据类型, 4个整数类型+2个浮点类型+1个字符类型+1个boolean类型
(引用数据类型后面讲)
2.类型转换
2.1 类型转换介绍
由于Java是强类型语言,所以要进行有些运算的时候的,需要用到类型转换。
-
运算中,不同类型的数据先转化为同一类型,然后进行运算。
-
转换从低级到高级(根据容量来看, 且浮点型高于整型)
低 --------------------------------------------> 高 byte, short, char -> int -> long -> float -> double
类型转换分为:
- 自动类型转换: 从低级转到高级可以使用自动类型转换
- 强制类型转换: 从高级转到低级必须使用强制类型转换
2.2 自动类型转换
自动类型转换:容量小的数据类型可以自动转换为容量大的数据类型。
【比如】
- short数据类型的位数为16位,就可以自动转换位数为32的int类型;
- float数据类型的位数为32,可以自动转换为64位的double类型。
【演示】
char name = 'a';
int num1 = name;
System.out.println(num1); // 97
int num2 = 1024;
double num3 = num2;
System.out.println(num3); // 1024.0
【解析:由于小写字母a,查它对应的ASCII 码表可知对应的 int 类型值为 97,所以转换完成后是97】
2.3 强制类型转换
强制类型转换,又被称为造型,用于显式的转换一个数值的类型,容量大的类型转换容量小的类型,必须使用强制转换
- 在有可能丢失信息的情况下进行的转换是通过造型来完成的,但可能造成精度降低或溢出。
- 强制类型转换的语法格式: (type)var ,运算符“()”中的type表示将值var想要转换成的目标数据类型。 条件是转换的数据类型必须是兼容的。
【演示】
int num1 = 120;
byte num2 = (byte) num1;
System.out.println(num2); // 120
double num3 = 120.67;
float num4 = (float) num3;
System.out.println(num4); // 120.67
2.4 类型转换规则
数据类型转换必须满足如下规则:
-
不能对boolean类型进行类型转换。
-
不能把对象类型转换成不相关类的对象。
-
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
-
转换过程中可能导致溢出或损失精度,例如:
int a = 128; // 强制转换a为byte类型 byte b = (byte) a; System.out.println(a); // 128 System.out.println(b); // -128
因为 byte 类型是 8 位,最大值为127,所以当 int 类型强制转换为 byte 类型时,值 128 时候就会导致溢出, 从而导致结果出现错误。
-
浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入,例如:
float c = 23.9f; int d = (int) c; System.out.println(d); // 23
2.5 JKD7扩展
JDK7新特性:下划线分隔符
-
在实际开发和学习中,如果遇到特别长的数字,读懂它令人头疼!JDK7为我们提供了下划线分隔符,可以按照自己的习惯进行分割, 方便我们阅读。
// 随意按照自己的习惯分隔 int money1 = 100_000_000 int money2 = 1_0000_0000 // 对结果没有任何影响 System.out.println(money1); // 100000000 System.out.println(money2); // 100000000
JDK7新特性: 二进制整数
-
我们在开发中也经常使用二进制整数,因此JDK7为我们直接提供了二进制整数的类型, 我们只要以:0b开头即。
int num = 0b0101;
3.变量和常量
3.1 变量的介绍
变量是什么:就是可以变化的量!
我们通过变量来操纵存储空间中的数据,变量就是指代这个存储空间!空间位置是确定的,但是里面放置什么值不确定! 打个比方:
这就好像我们家里有一个大衣柜,里面有十分多的小格子,我们给格子上贴上标签,放衣服,放鞋子,放手表等等,此时我们知道了哪里该放什么,而这个标签就相当于我们的变量,我们给他起了个名字,但是里面要放什么需要我们自己去放。
Java是一种强类型语言,每个变量都必须声明其类型。
-
Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域。
-
变量在使用前必须对其声明, 只有在变量声明以后,才能为其分配相应长度的存储单元,声明格式为:
//数据类型 变量名 =值; 后面可以使用逗号隔开来声明多个同类型变量 type varName [=value] [{, varName [=value]}]
【注意事项】
- 每个变量都有类型,类型可以是基本类型,也可以是引用类型。
- 变量名必须是合法的标识符。
- 变量声明是一条完整的语句,因此每一个声明都必须以分号结束
【演示】
int a, b, c; // 同时声明三个int类型整数: a b c
// 声明完可以单独对变量进行赋值
a = 10;
b = 20;
c = 30;
byte d = 40, e = 50, f = 60; // 同时声明三个byte变量并赋值
System.out.println(a); // 10
System.out.println(b); // 20
System.out.println(c); // 30
System.out.println(d); // 40
System.out.println(e); // 50
System.out.println(f); // 60
【编码规范】
- 虽然可以在一行声明多个变量,但是不提倡这个风格,逐一声明每一个变量可以提高程序可读性。
3.2 变量作用域
变量根据作用域可划分为三种:
- 类变量(静态变量: static variable):独立于方法之外的变量,用 static 修饰。
- 实例变量(成员变量:member variable):独立于方法之外的变量,不过没有 static 修饰。
- 局部变量(lacal variable):类的方法中的变量。
【示例】: 看不懂没关系, 我们先了解一下类变量, 实例变量, 局部变量分别写在什么位置
public class Test {
// 类变量
static int num = 10;
// 实例变量
String str = "Hello World";
public void method() {
// 局部变量: 定义在方法中
String name = "小陈";
}
}
局部变量 :
- 方法或语句块内部定义的变量, 生命周期是从声明位置开始到”}”为止。
- 在使用前必须先声明并且初始化(赋初值)。
- 局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。
【示例】
public static void main(String[] args) {
int i = 10; // 错误写法: int i;
int j = i + 10;
System.out.println(j); // 20
}
实例变量 :
- 方法的外部、类的内部定义的变量。
- 从属于对象,生命周期伴随对象始终。
- 如果不自行初始化,他会自动初始化成该类型的默认初始值(数值型变量初始化成0或0.0,字符型变量的初始化值是16位的0,布尔型默认是false)
【示例】
public class Test {
// 实例变量: 定义在类的内部,方法的外部
int num = 100;
String str = "Hello World";
public static void main(String[] args) {
// 需要创建实例才能使用
Test test = new Test();
System.out.println(test.num); // 100
System.out.println(test.str); // Hello World
}
}
静态变量 :
- 使用static定义。
- 从属于类,生命周期伴随类始终,从类加载到卸载。(注:讲完内存分析后我们再深入!先放一放这个概念!)
- 如果不自行初始化,他会自动初始化成该类型的默认初始值(数值型变量初始化成0或0.0,字符型变量的初始化值是16位的0,布尔型默认是false)
【示例】
public class Test {
// 静态变量
static double money = 2000;
public static void main(String[] args) {
// 可以直接在方法中使用
System.out.println(money); // 2000.0
}
}
3.3 常量的介绍
常量(Constant):初始化(initialize)后不能再改变值!不会变动的值。
-
所谓常量可以理解成一种特殊的变量,它的值被设定后,在程序运行过程中就不允许再被改变。
-
语法如下
// final 数据类型 变量名 = 值; final double PI = 3.1415926; final String NAME = "小陈";
【注意事项】
- 常量名一般使用大写字符。
- 程序中使用常量可以提高代码的可维护性。
3.4 变量命名规范
- 所有变量、方法、类名:要做到见名知意
- 类成员变量:首字母小写和驼峰原则 : monthSalary
- 局部变量:首字母小写和驼峰原则 : monthSalary
- 常量:大写字母和下划线:MAX_VALUE
- 类名:首字母大写和驼峰原则: Man, GoodMan
- 方法名:首字母小写和驼峰原则: run(), runRun()
4.运算符
运算符operator
Java 语言支持如下运算符:
- 算术运算符: +,-,*,/,%,++,–
- 赋值运算符 =
- 关系运算符: >,<,>=,<=,==,!= instanceof
- 逻辑运算符: &&,||,!
- 位运算符: &,|,^,~ , >>,<<,>>> (了解!!!)
- 条件运算符 ?:
- 扩展赋值运算符:+=,-=,*=,/=
4.1 算术运算符
4.1.1 二元运算符
+、-、*、/
两个操作数,来看看我们小时候的数学运算, 其实都属于二元运算符;
public static void main(String[] args) {
int a = 20;
int b = 10;
System.out.println("a + b =" + (a + b)); // a + b =30
System.out.println("a - b =" + (a - b)); // a - b =10
System.out.println("a * b =" + (a * b)); // a * b =200
System.out.println("a / b =" + (a / b)); // a / b =2
}
整数运算 :
- 如果两个操作数有一个为Long, 则结果也为long
- 没有long时,结果为int。即使操作数全为shot,byte,结果也是int.
【示例】
public static void main(String[] args) {
int a = 10;
long b = 100L;
short c = 20;
byte d = 30;
// 运算有long类型, 运算结果就是long类型
System.out.println((a + b + c + d));
// 运算没有long类型, 那么就是int类型, 哪怕操作数中全是short和byte类型
System.out.println((a + c + d)); // int类型 + short类型 + byte类型 结果是 int类型
System.out.println((c + d)); // short类型 + byte类型 结果依然是 int类型
}
浮点运算 :
- 如果两个操作数有一个为double, 则结果为double.
- 只有两个操作数都是float, 则结果才为float.
【示例】
public static void main(String[] args) {
float a = 12.34F;
float b = 56.78F;
double c = 3.14159;
// 有一个为double, 结果为double类型
System.out.println((a + c)); // double类型
// 全为float才是float类型
System.out.println((a + b)); // float类型
}
4.1.2 取模运算
%
取模运算:
其实就是我们小学的取余运算, 得到余数
其操作数可以为浮点数,一般使用整数。如:5.9%3.9=2.000000004
要点:
- 负数%负数=负数;
- 负数%正数=负数;
- 正数%负数=正数;
public static void main(String[] args) {
System.out.println((9 % 2)); // 1
System.out.println((-9 % -2)); // -1
System.out.println((-9 % 2)); // -1
System.out.println((9 % -2)); // 1
}
【注:一般都是正整数运算,进行结果的判断!】
4.1.3 一元运算符
++、--
自增(++)自减(–)运算符是一种特殊的算术运算符,在算术运算符中需要两个操作数来进行运算,
- 比如: a++, 其实相当于 a = a + 1
- 比如: a–, 就相当于 a = a – 1
【示例】
public static void main(String[] args) {
int a = 1;
a++;
System.out.println(a); // 2
++a;
System.out.println(a); // 3
a--;
System.out.println(a); // 2
--a;
System.out.println(a); // 1
}
而自增自减运算符是一个操作数,分为前缀和后缀两种。
- a++, 是先参加运算, 再自增,
- ++a, 是先自增, 再参加运算
【示例】
public static void main(String[] args) {
int a = 1;
int b = a++;
int c = ++a;
int d = a--;
int e = --a;
System.out.println(b); // 执行结果: 1; a先赋值给b, 然后自增加1, 此时a = 2
System.out.println(c); // 执行结果: 3; a先自增加1, 然后赋值给b, 此时a = 3
System.out.println(d); // 执行结果: 3; a先赋值给d, 然后自身减1, 此时a = 2
System.out.println(e); // 执行结果: 1; a先自身减1, 然后赋值给b, 此时a = 1
}
java中的乘幂的处理: 需要使用Math类, Math类提供了很多科学和工程计算需要的方法和常数。特殊的运算都需要运用到方法!
public static void main(String[] args) {
double a = Math.pow(3, 2); // 错误写法: int a = 3 ^ 2;
System.out.println(a); // 9.0
}
4.2 赋值运算符
=
赋值运算符顾名思义是用来给变量赋值的, 将=右边的值赋值给=左边的变量
public static void main(String[] args) {
// 将80赋值给num这个变量
int num = 80;
// 将"小陈"赋值给name
String name = "小陈";
System.out.println(num); // 80
System.out.println(name); // 小陈
}
4.3 关系运算符
>、>=、<、<=、==、!=
关系运算符返回一个布尔值(boolean)
运算符 | 描述 | 例子 |
---|---|---|
== | 检查两个操作数是否相等, 如果相等则条件为真, 返回true, 反之返回false | (10 == 20) false |
!= | 检查两个操作数是否不相等, 如果不相等则条件为真, 返回true, 反之返回false | (10 == 20) true |
> | 检查左操作数是否大于右操作数, 如果大于则条件为真, 返回true, 反之返回false | (10 > 20) false |
< | 检查左操作数是否小于右操作数, 如果小于则条件为真, 返回true, 反之返回false | (10 < 20) true |
>= | 检查左操作数是否大于等于右操作数, 如果大于等于则条件为真, 返回true, 反之false | (10 >= 20) false |
<= | 检查左操作数是否小于等于右操作数, 如果小于等于则条件为真, 返回true, 反之false | (10 <= 20) true |
【示例】
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println((10 == 20)); // false
System.out.println((10 != 20)); // true
System.out.println((10 > 20)); // false
System.out.println((10 < 20)); // true
System.out.println((10 >= 20)); // false
System.out.println((10 <= 20)); // true
}
4.4 逻辑运算符
&&、||、!
逻辑运算符: 包含逻辑与, 逻辑或, 逻辑非
操作符 | 描述 | 例子 |
---|---|---|
| | | 称为逻辑或运算符, 如果操作数有一个为真, 那么条件为真, 返回true | (1 == 2 || 3 == 3), 为真 |
&& | 称为逻辑与运算符, 只有操作数全为真的时候, 条件才为真, 返回true | (1 == 2 && 3 == 3), 为假 |
! | 称为逻辑非运算符, 用来反转操作数的逻辑状态 | !(1 == 2 && 3 == 3), 为真 |
逻辑与和逻辑或采用短路的方式。从左到右计算,如果确定值则不会再计算下去。
- 逻辑与只要有一个为false, 则直接返回false.
- 逻辑或只要有一个为true, 则直接返回true;
【示例】
public static void main(String[] args) {
boolean a = false;
boolean b = true;
System.out.println((a || b)); // 执行结果: true; 逻辑或运算符, 一个为真则为真
System.out.println((a && b)); // 执行结果: false; 逻辑与运算符, 一个为假则为假
System.out.println(!a); // 执行结果: true; 逻辑非运算符取反, 对a取反为true
System.out.println(!b); // 执行结果: false; 逻辑非运算符取反, 对b取反为false
}
4.5 位运算符
Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),和字节型
(byte)等类型。位运算符作用在所有的位上,并且按位运算。
操作符 | 描述 |
---|---|
& | 如果相对应位都是1, 则结果为1, 否则为0 |
| | 如果相对应位都是0, 则结果为0, 否则为1 |
^ | 如果相对应位的值相同, 则结果为0, 否则为1 |
~ | 按位取反, 反转操作数的每一位, 即0变成1, 1变成0 |
<< | 按位左移运算符, 左操作数按位左移右操作数指定的位数 |
>> | 按位右移运算符, 右操作数按位右移左操作数指定的位数 |
【示例】
/*
int num1 = 00111100;
int num2 = 00001101;
num1 & num2 = 00001100
num1 | num2 = 00111101
num1 ^ num2 = 00110001
~num1 = 11000011
*/
public static void main(String[] args) {
int num1 = 2;
// 左移 相当于乘2; 左移几位, 就乘几个2
System.out.println(num1 << 2); // 8; 相当于2 * 2 * 2
int num2 = 16;
// 右移 相当于除2; 右移几位, 就除几个2
System.out.println(num2 >> 3); // 2; 相当于16 / 2 / 2 / 2
}
4.6 三目条件运算符
? :
三目条件运算符,语法格式:
x ? y : z
- 其中x为结果是boolean类型表达式,先计算x的值
- 若x的值为true,则整个三目运算的结果为表达式y的值
- 若x的值为false, 则整个运算结果为表达式z的值
【演示】
public static void main(String[] args) {
int score1 = 80;
int score2 = 52;
String result1 = score1 >= 60 ? "及格了" : "不及格";
String result2 = score2 >= 60 ? "及格了" : "不及格";
System.out.println(result1); // 及格了
System.out.println(result2); // 不及格
}
三元运算符在真实开发中十分的常见,大家可以多练习使用,之后我们会讲解分支语句,可以利用三元
运算符做到更加精简代码!便于理解!
4.7 字符串连接符
+
加号还有一个作用就是连接字符串
- “+” 运算符两侧的操作数中只要有一个是字符串(String)类型,系统会自动将另一个操作数转换为字符串然后再进行连接。
【示例】
public static void main(String[] args) {
String str = "Hello Java";
int num = 100;
// 会自动将num转为字符串类型再进行拼接
System.out.println((str + num)); // Hello Java100
}
4.8 扩展赋值运算符
运算符 | 用法举例 | 等效表达式 |
---|---|---|
+= | a += b | a = a + b |
-= | a -= b | a = a – b |
*= | a *= b | a = a * b |
/= | a /= b | a = a / b |
%= | a %= b | a = a % b |
以上运算符就相当于是一种简写的方式, 这种写法非常常用
【示例】
public static void main(String[] args) {
int a = 10;
int b = 3;
System.out.println((a += b)); // 13; 等效于 a = 10 + 3
System.out.println((a -= b)); // 10; 等效于 a = 13 -10
System.out.println((a *= b)); // 30; 等效于 a = 10 * 3
System.out.println((a /= b)); // 10; 等效于 a = 30 / 3
System.out.println((a %= b)); // 1; 等效于 a = 10 % 3
}
4.9 运算符的优先级
我们小学都学过:先加减,后乘除,所以优先级这个概念我们并不陌生。
当多个运算符出现在一个表达式中,谁先谁后呢?这就涉及到运算符的优先级别的问题。
在一个多运算符的表达式中,运算符优先级不同会导致最后得出的结果差别甚大。
下表中具有最高优先级的运算符在的表的最上面,最低优先级的在表的底部
类别 | 操作符 | 关联性 |
---|---|---|
后缀 | ()、[]、. | 左到右 |
一元 | + – ! ~ | 从右到左 |
乘性 | *、/、% | 左到右 |
加性 | +、- | 左到右 |
移位 | >>、>>>、<< | 左到右 |
关系 | >、>=、<、<= | 左到右 |
相等 | ==、!= | 左到右 |
按位与 | & | 左到右 |
按位异或 | ^ | 左到右 |
按位或 | | | 左到右 |
逻辑与 | && | 左到右 |
逻辑或 | || | 左到右 |
添加 | ? : | 从右到左 |
赋值 | =、+=、-+、*=、/=、%= | 从右到左 |
大家不需要去刻意的记住,表达式里面优先使用小括号来组织!!方便理解和使用,不建议写非常冗余
的代码运算!
表的底部**
类别 | 操作符 | 关联性 |
---|---|---|
后缀 | ()、[]、. | 左到右 |
一元 | + – ! ~ | 从右到左 |
乘性 | *、/、% | 左到右 |
加性 | +、- | 左到右 |
移位 | >>、>>>、<< | 左到右 |
关系 | >、>=、<、<= | 左到右 |
相等 | ==、!= | 左到右 |
按位与 | & | 左到右 |
按位异或 | ^ | 左到右 |
按位或 | | | 左到右 |
逻辑与 | && | 左到右 |
逻辑或 | || | 左到右 |
添加 | ? : | 从右到左 |
赋值 | =、+=、-+、*=、/=、%= | 从右到左 |
大家不需要去刻意的记住,表达式里面优先使用小括号来组织!!方便理解和使用,不建议写非常冗余
的代码运算!
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
文章由极客之音整理,本文链接:https://www.bmabk.com/index.php/post/120116.html