1.前置内容
-
什么是内存？
内存即是一块瞬时状态的存储空间，有一定的容量。
-
内存与硬盘的区别？
内存造价较高，在计算机硬件资源中比较稀缺。（内存需要省着点用）
工业上的瓶颈，多数大容量的内存都是由多个内存条组成的。
-
计算机给Java程序多大的内存空间？
Java虚拟机（Java程序），默认分配的物理内存容量是计算机内存的 1/8。(省着用)
-
计算机存储容量的基本单位
bit(位) * 8 == 1 Byte(1字节)
Byte - KB - MB - GB - TB - PB - EB - ZB - YB - BB - NB - DB - CB - XB (1024进位)
2.变量
-
概念：计算机内存中的一块存储空间，是存储数据的基本单元。
eg：酒店（内存）中有很多房间（变量），房间类型（变量的数据类型）有单人、双人等，独立不重复的门牌号（变量名/内存地址），每个房间的房客（变量存储的值）也不同。
组成：数据类型、变量名、值
-
定义：声明和赋值
1）声明：数据类型 变量名; int money; //开辟整数变量空间 ①先声明再赋值 ②声明并赋值【常用】 2）赋值：变量名 = 值; money = 100; //将整数值赋给变量 注意：Java是强类型语言，变量的类型与值的类型必须一致。
3.数据类型
- 基本数据类型（整型、浮点型、布尔型、字符型）
整数
Java中任何一个整数，默认的类型为int，如果整数超过int取值范围，则均报错为过大的整数。
long类型的赋值整数如果超过了int类型取值范围，则需要在数字后加 "L" 以标记为long类型。
public class TestType {
public static void main(String[] args) {
// 创建一个bute类型的变量，测试取值范围
byte b = -128; // 取值范围 -128~127 共计256个数字
System.out.println(b);
// 创建一个short类型的变量，测试取值范围
short s = -32768; // 取值范围 -32768~32767 共计65536个数字
System.out.println(s);
int i = -2147483648; // 取值范围 -2147483648~2147483647
System.out.println(i);
System.out.println(Long.MAX_VALUE);// long类型的最大正整数值 9223372036854775807
long l1 = 9223372036854775807L;
long l2 = 2147483648L;
System.out.println(l2); //2147483648
System.out.println(l1 + l2); // 数据溢出，变成负数
}
}
输出：
-128
-32768
-2147483648
9223372036854775807
2147483648
-9223372034707292161
小数
Java中任意一个小数默认类型为双精度类型double。
如果使用单精度float类型，则需要在数字后面加"F"表示单精度值。
public class TestFloatAndDouble {
public static void main(String[] args) {
// 单精度浮点数
float f = 1.2F; // 追加F表示float类型,不可省略
System.out.println(f);
// 双进度浮点数
double d = 1.3;
System.out.println(d);
// 双精度多种赋值方式
double d2 = 2000;
System.out.println(d2);
double d3 = 2000.0;
System.out.println(d3);
double d4 = 2000D; // 追加D表示double类型,可省略
System.out.println(d4);
// 科学计数法赋值
double d5 = 1.7E308; // 1.7 * 10^308 ---> Double.MAX_VALUE
System.out.println(d5);
System.out.println(Double.MIN_VALUE);
System.out.println(Double.MAX_VALUE);
}
}
输出：
1.2
1.3
2000.0
2000.0
2000.0
1.7E308
4.9E-324
1.7976931348623157E308
布尔
可直接赋值 true/false
也可赋值一个结果为 true/false 的表达式
注意：Java中的boolean类型变量不能参与算术运算！
字符
char每一个字符在计算机中都会有一个二进制数字对应
char类型支持转义字符 \ 可转义的有：' " \ \n \t
char类型字符是单引号包裹的单个字符
char类型多种赋值方式：
public class TestChar {
public static void main(String[] args) {
char c = 'A'; // 字符：通过字符直接赋值【常用】
System.out.println(c); // A
char c2 = 66; // 整数：通过10进制数66在字符集中对应的字符赋值
System.out.println(c2); // B
char c3 = '\u0043'; // 整数：通过16进制43在字符集中对应的字符赋值
System.out.println(c3); // C
// 中文
char c4 = '你';
System.out.println(c4);
System.out.println((int)c4); // 将c4的中文强转为整数类型
char c5 = 20320; // char 0~65535
System.out.println(c5);
System.out.println((int)'我'); // (char)25105
System.out.println((int)'爱'); // (char)29233
System.out.println((int)'你'); // (char)20320
System.out.println((char)25105); // 我
System.out.println((char)29233); // 爱
System.out.println((char)20320); // 你
// short 整数2个字节 ---- char 整数2个字节
short s1 = 20320; // -32768~32767, 有符号数，首位为符号位；当首位为1时，此整数为负数
char c7 = 20320; // 0~65535, 无符号数
// 2个字节 16位
// short的最大整数： 0111 1111 1111 1111 == 32767 首位符号位必须是0
// char 的最大整数： 1111 1111 1111 1111 == 65535
// char c8 = -1; // error, char为无符号数
char c9 = 65; // OK
short s2 = 65;
//char c10 = s2; // error 不可以，short的取值范围中涵盖负数，编译器无法保证s2中一定是个正整数，报检查的错误
//System.out.prinln(c10);
}
}
- 引用数据类型 （字符串、数组、对象）
字符串
- 任何""之间的内容都是字符串，包括空格。
4.类型转换
- 自动类型转换
1）两种类型互相兼容
2）目标类型大于源类型
- 强制类型转换
1）两种类型互相兼容
2）目标类型小于源类型
3）强转规则：
* 整数长度足够，数据完整
* 整数长度不够，数据截断
* 小数强转整数，数据截断
* 字符整数互转，数据完整
* boolean类型不能与其他类型进行转换
public class TestConvert {
public static void main(String[] args) {
/* 自动类型转换 */
short s = 123;
int i = s; //OK
System.out.println(i);
float f = 3.5F;
double d = f; //OK
System.out.println(d);
byte b = 10;
double d2 = b;//OK
System.out.println(d2);
float d3 = 100.0F;
//long l = d3; // ERROR：不兼容的类型，整数无法保留小数的精度
//System.out.println(l);
System.out.println("------------------------------");
/* 强制类型转换 */
short s1 = 123;
byte b1 = (byte)s1;
System.out.println(b1);//123
float d4 = 100.9F;
long ll = (long)d4;
System.out.println(ll);//100
}
}
public class TestConvert2 {
public static void main(String[] args) {
short s = 257;
byte b = (byte)s;
System.out.println(b); // 强转 256->0 257->1
// short 2个字节 16位
// 257: 0000 0001 0000 0001 --> short
// 257: ---- ---- 0000 0001 --> byte
short s2 = 128;
byte b2 = (byte)s2;
System.out.println(b2); // 强转 128-> -128
}
}
5.运算符
算术运算符：加+ 减- 乘* 除/ 模%
-
一元运算符：自增++ 自减--
* 前自增/减：先运算，再取值； * 后自增/减：先取值，再运算； 赋值运算符：赋值= 求和赋+= 求差赋-= 求积赋*= 求商赋/= 求余赋%=
关系运算符：大于> 小于< 大于等于>= 小于等于<= 等于== 不等于!=
逻辑运算符：与&& 或|| 非!
三元运算符：布尔表达式 ? 结果1 : 结果2
布尔表达式为真，取值结果1；为假，取值结果2
public class TestOperation {
public static void main(String[] args) {
double score = 100.0;
//1\. 逻辑判断
System.out.println(score == 100.0 ? "真棒！" : "加油！");
//2\. 作为变量赋值的表达式
String result = score == 100.0 ? "真棒！！" : "加油！！";
System.out.println(result);
//3\. 赋值，判断
int i = score == 100.0 ? 1 : 2;
System.out.println(i);
}
}
|| 在线思维导图工具：www.processon.com
|| 免费版可以创建9个
6.自动类型提升
自动类型提升优先级：double >> float >> long >> int << short/byte
两个操作数中有一个为优先级中的类型，计算结果提升为优先级中对应类型
【特殊】任何类型与String相加(+)时，实为拼接，结果自动提升为String
public class TestTypeUp {
public static void main(String[] args) {
int num1 = 123;
int num2 = 567;
String str = "abc";
// 【坑】两个操作数为数值时，相加；两个操作数中有一个为String时，拼接。
String newStr = num1 + num2 + str;
System.out.println(newStr);
}
}
输出：
690abc
7.控制台输入
- 导入：java.util.Scanner
导包语法：import 包名.类名;
功能：将外部class文件功能引入到自身文件中
位置：jdk1.8.0_121\jre\lib\rt.jar 压缩包中
声明：Scanner 类型的变量
-
接收：（输入类型）
.nextInt(); // 获得整数 .nextDouble(); // 获得小数 .next(); // 获得字符串 .next().charAt(0); // 获得字符串的第一个字符【注意】如果输入了不匹配的数据，则会产生 java.util.InputMismatchException 异常。
// package xxx.xxx; 包的声明，要求写在源文件的首行
// import 关键字的引入，写在package之后
// 1.引入JDK提供的一个扫描仪的工具
import java.util.Scanner;
public class TestScanner {
public static void main(String[] args) {
// 2\. 声明 Scanner
Scanner input = new Scanner(System.in); // 引用数据类型的声明方式
System.out.print("请输入一个值：");
// 3\. 使用：基于Scanner类型的变量名 .nextInt();
// 可以在控制台接收一个整数的值，并保存在变量中
int i = input.nextInt();
System.out.println("您输入的值为：" + i);
}
}
