0. 变量说明
变量是组成程序的基本单位，它是内存中某个存储空间的表示
变量三要素： 类型+名称+值
变量使用步骤： 声明，赋值，使用
变量在同一个作用域内不能重名
如下图，java的数据类型大致分为：
其中八大基本类型，包括byte, short, int, long, float, double, char, boolean是前期学习的基础，要熟练掌握。
1. 整数型
Java整数类型有固定的范围和字段长度，不受操作系统影响，保证java程序的可移植性
声明long型常量需要后加L或l
byte a = 1;
short b = -2;
int c = 3 ;
long d = 4L;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
2. 浮点型
Java浮点类型有固定的范围和字段长度，不受操作系统影响，保证java程序的可移植性
Java浮点类型中，double可直接声明， float在声明时要后加f或F
浮点数在表示时有两种形式，一种是十进制形式例如 5.12 5.12f .512 另一种是科学计数法，例如5.12e2 5.12E-2
double e = 0.125;
floatt f = 1.99765f;
double g = 3.1415926E2;
floatt h = 31.415E-2f;
System.out.println(e);
System.out.println(f);
System.out.println(g);
System.out.println(h);
浮点数使用陷阱：由于java中小数在进行存放时是会先转成2进制做一个近似处理，所以在判断两个浮点数的相等时要格外注意，慎用！
double num1 = 2.7;
double num2 = 8.1/3;
System.out.println(num1);
System.out.println(num2);
System.out.println(Math.abs(num1 - num2));
3.字符型
字符型char只能存放单个字符，英文字符、转义字符、中文字符都可，用单引号括起来。
char型的存储过程为：字符–>unicode码值–>二进制值–>存储空间
char型的读取过程为：二进制值–> unicode码值–>字符显示
由于char型是以整数形式进行存储的，因此可以进行运算。
char char1 = 'a';
char char2 = '\t';
char char3 = '韩';
System.out.println((int)char3); //输出3889
System.out.println('a'+1); //输出98
常见的几种编码方式：ASCII码，固定1个字节表示，因此2^8= 256（如下图1），字符量较少；Unicode码，固定2个字节，内含2^16=65536个字符，引入了中文等各国语言字符对应编码，将世界上所有符号都纳入其中，不会乱码，缺点是浪费存储空间；UTF-8码，大小可变的编码，字母使用1个字节，汉字2个字节，互联网上使用最广Unicode的改进版本；gbk码，字母1个字节，汉字2个字节。
快速查询unicode码的网址： https://tool.chinaz.com/Tools/unicode.aspx
4. 布尔型
布尔型boolean只有true和false两种取值，无null；布尔型常用于逻辑运算
不可以用0代替false，或非0代表true，这与其他语言不同。
boolean pass = true;
if(pass){
System.out.println("通过！");
}else{
System.out.println("未通过");
}
5. 数组
知识点概述：
1. 数组相当于是一个集合，里面可以存放多个同一类型的数据
2. 数组的初始化。数组有两种初始化方式，分别如下：
数组初始化方式1： 静态初始化
静态初始化就是在定义数组时，直接指定数组元素，让编译器来计算数组长度。静态初始化有两种形式：一种是不带new关键字，一种带有new关键字，两种方法的语法格式具体为：
数组初始化方式2： 动态初始化
动态初始化就是在定义数组时，只指定数组的长度，而后在使用时逐个给数组赋初值, 其语法格式为：
// 1-1 静态初始化
double hens[] = {1.1, 2, 3.45, 7.8, 6.20}; //不带new的静态初始化
int arr[] = new int[]{1,2,3}; // 带new的静态初始化(注意new int[], []不能带数字)
// 1-2 动态初始化
// 例1-->通过语句动态赋值
int a[] = new int[7];
a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4; a[4] = 5; a[5] = 6; a[6] = 7;
// 例2-->通过键盘输入动态赋值
// 程序功能： 从键盘输入5个学生的成绩，保存到数组中并输出
double scores[] = new double[5];
Scanner myScanner = new Scanner(System.in);
for(int i = 0 ; i < 5 ; i++){
System.out.println("请输入第" + (i+1) + "个学生的成绩");
scores[i] = myScanner.nextDouble();
}
for(int i = 0 ; i < 5 ; i++){
System.out.println("第" + (i+1) + "个学生的成绩为：" + scores[i]);
}
3. 数组的复制。java中若要将数组arr1中的元素复制到arr2中，有两种实现方式。一种是通过数组名进行地址传递（引用传递），地址传递的本质是让两个数组指向同一片内存，改变其中一个数组元素时对应的另一个数组也会发生相应改变；另一种是用new开辟一块新的内存空间，将arr1的元素值一个个地赋给arr2，这种操作的本质是在进行值传递，改变其中一个数组元素时对应的另一个数组并不会改变。
// 2-1 通过数组名进行引用传递
int[] arr1 = {1,2,3,4,5};
int[] arr2 = arr1; // 将数组1的地址赋给数组2
for(int i = 0 ; i < 5 ; i++){
System.out.print(arr2[i]+" ");
}
arr1[0] = 100;
System.out.println(arr2[0]); // 输出100，说明地址传递时改变一个数组另一个会跟着变
// 2-2 通过new开辟新空间挨个进行复制，值传递
int[] arr1 = {1,2,3,4,5};
int[] arr2 = new int[arr1.length];
for(int i = 0 ; i < 5 ; i++){
arr2[i] = arr1[i]; // 挨个赋值
System.out.print(arr2[i]+" ");
}
arr1[0] = 100;
System.out.println(arr2[0]); // 输出1，说明值传递时改变一个数组另一个不会跟着变
4. 数组的扩容。扩容的核心思路就是定义一个临时数组来存放扩容后的所有元素值，随后将原数组的地址指向这个临时数组，那么原数组就会销毁且完成内容的更新
// 程序要求： 1. 原始数组使用静态初始化完成定义，随后在数组的末尾添加一个元素进行扩容
// 2. 设置一个用户选择按钮y/n，来决定是否继续扩容
// 思路分析： 扩容思路--> 定义一个临时数组arr_temp来存放扩容后的所有元素值，随后将arr的地址指向arr_temp，那么原来的arr就会销毁且完成arr的更新
// 用户选择思路--> 通过while循环，不断从键盘上读入最新的用户输入，检测到特定内容时break
Scanner myScanner = new Scanner(System.in);;
int arr[] = {1 , 2 , 3};
do{
System.out.print("您是否想对数组进行扩容？");
char key = myScanner.next().charAt(0);
if(key == 'y'){ // if分支内存放扩容操作
int arr_temp[] = new int[arr.length + 1]; // 开辟一块新内存
System.out.print("请输入您想扩展的数组元素：");
int element_new = myScanner.nextInt() ;
for(int i = 0 ; i < (arr.length + 1) ; i++){
if(i < arr.length){
arr_temp[i] = arr[i];
}else{
arr_temp[i] = element_new;
}
}
arr = arr_temp;
for(int j = 0 ; j < arr.length ; j++){
System.out.print(arr[j] + " ");
}
}else{
break;
}
}while(true);
5. 二维数组。二维数组相当于是一个元素为一维数组的数组。二维数组在初始化和输出时与一维数组类似，二维数组中每个元素存放的不是值，而是一维数组的地址，具体的值是存放在一维数组对应的地址中。这里对相关语法不再赘述，具体参考下面的例子。
// 5-1 二维数组的始化
// 类型1-->不带new的静态初始化
int arr[][] = { {0,0},{0,0,1,},{0,2,0,3},{0,0,0,0,0} }; // 二维数组中不需要每个元素的长度都相等,[][]内未固定数字时，系统会自动识别长度
// 类型2-->带new的静态初始化;
int brr[][] = new int [][]{ {0,0,0,0,0},{0,0,1,0,0},{0,2,0,3,0},{0,0,0,0,0} };
// 类型3-->直接赋值的动态初始化;
int crr[][] = new int [2][3];
crr[0] = new int[]{1,2,3}; crr[1] = new int[]{4,5,6}; // 注意这里必须要带new int[]，否则会报错
// 类型4-->利用循环逐个赋值的动态初始化
int[][] drr = new int [3][5];
for(int i = 0 ; i < drr.length ; i++){
for(int j = 0 ; j < drr[i].length ; j++){
drr[i][j] = i * j ;
}
}
// 类型5-->列数不确定的动态初始化
// 程序要求：创建一个二维数组，存放以下数字
// 1
// 2 2
// 3 3 3
int [][] err = new int[3][];
for(int i = 0 ; i < err.length ; i++ ){
err[i] = new int[i+1]; // 为每个一维数组开辟相应的空间
for(int j = 0 ; j < err[i].length ; j++){
err[i][j] = i + 1;
}
}
for(int i = 0 ; i < err.length ; i++ ){
for(int j = 0 ; j < err[i].length ; j++){
System.out.print(err[i][j]+"\t");
}
System.out.println();
}
// 5-2 二维数组的输出
// 说明： 在输出二维数组时，由于二维数组的每个元素又是一个数组，因此只能利用循环逐个进行输出
// 程序要求：定义一个数组，存放一下数字矩阵
// 0 0 0 0 0
// 0 0 1 0 0
// 0 2 0 3 0
// 0 0 0 0 0
int arr[][] = { {0,0,0,0,0},{0,0,1,0,0},{0,2,0,3,0},{0,0,0,0,0} };
for(int i = 0 ; i < arr.length ; i++){
for(int j = 0 ; j < arr[i].length ; j++){
System.out.print(arr[i][j]+"\t"); // 逐个输出
}
System.out.println();
}
// 扩展：三维数组
int arrr[][][] = { {{1,2},{1,2}},{{1,3},{3,4}},{{4,5},{5,6}} };
for(int i = 0 ; i < arrr.length ; i++){
for(int j = 0 ; j < arrr[i].length ; j++){
for(int k = 0 ; k < arrr[i][j].length ; k++ ){
System.out.print(arrr[i][j][k]+"\t");
}
}
}
使用细节：
1. 数组中必须存放相同的数据类型，否则会报错；
2. 数组中的元素可以是任意类型，既可以是基本类型，也可以是引用类型；
3. 数组在创建后，若没有赋值会有默认值，int --> 0 , short -->0 , byte -->0 , long–> 0 , float–>0.0 , double–>0.0 , char --> u\0000 , boolean --> false , String --> null ;
4. 使用数组的步骤有3步，第一步是声明数组并为其开创空间，第二步是给数组的各个元素赋初值，第三步是使用数组；
5. 数组的下标从0开始，且下标必须在指定范围内使用（0到数组长度-1），若越界会报错；
6. 数组属于引用类型，数组型数据是对象。
课堂练习：
// 程序1功能： 创造一个char类型的数组，存放26个字母'A'-'Z'，使用for循环打印出来所有的元素并打印出来
char arphabet[] = new char[26];
for(int i = 0 ; i < 26 ; i++){
arphabet[i] = (char) ('A' + i); // 这里精度高转精度低，一定要强制转换
}
for(int j = 0 ; j < 26 ; j++){
System.out.println(arphabet[j]) ;
}
// 程序2功能： 求出数组{4,-1,9,10,23}的最大值，并输出对应的角标
int num[] = {4,-1,9,10,23};
int max = num[0]; // max存放最大值
int index = 0; // index存放角标
for(int i = 1 ; i < 5 ; i++){
if(max < num[i])
{
max = num[i];
index = i;
}
}
System.out.println("最大值为： " + max + " 对应的数组角标为： " + index);
// 程序3功能：打印一个10行的杨辉三角
// 1
// 1 1
// 1 2 1
// 1 3 3 1
// 1 4 6 4 1
// 1 5 10 10 5 1
int rows = 10;
int[][] yangTriangle = new int[rows][];
for(int i = 0 ; i < rows ; i++){
yangTriangle[i] = new int[i+1];
if(i == 0){
yangTriangle[i][0] = 1 ; // 第一行人工初始化
}else if(i == 1){
yangTriangle[i][0] = 1 ;
yangTriangle[i][1] = 1 ; // 第二行仍然人工初始化
}else{
for(int j = 0 ; j < yangTriangle[i].length ; j++){
if(j == 0 || j == (yangTriangle[i].length - 1) ){
yangTriangle[i][j] = 1;
}
else{
yangTriangle[i][j] = yangTriangle[i-1][j-1] + yangTriangle[i-1][j] ;
}
}
}
}
for(int i = 0 ; i < yangTriangle.length ; i++){
for(int j = 0 ; j < yangTriangle[i].length ; j++){
System.out.print(yangTriangle[i][j]+"\t"); // 逐个输出
}
System.out.println();
}
6. 变量类型转换
6.1 自动类型转换
（1）在赋值时，精度小的数据赋给精度大的变量时，会进行自动类型转换；但精度大的数据赋给精度小的变量时，会报错。
（2）在运算时，精度小的类型会自动转换成精度大的数据类型（自动提升）；
（3）byte, short 与char之间不会进行自动类型转换；
（4）boolean不参与转换
（5）byte, short, char在进行计算时，自动转为int类型；
// 1.赋值时的自动类型转换
int num1 = 'a'; // 97
double num2 = 1; // 1.0
num1 = 1.0; // 报错
// 2.运算时的自动类型转换
num2 = num1 + num2; // 98.0
// 3.char,byte,short之间不会自动转换
char char1 = 'a';
byte b1 = 1;
b1 = char1; // 报错
// 4.boolean 不参与自动类型转换
boolean bool = true;
int num3 = 1 + bool; // 报错
// 5.byte ,short ,char运算时自动转int
byte b1 = 1;
short b2 = 2;
int b3 = b1 + b2; // 3
6.2 强制类型转换
（1）当需要将数据类型由高精度转为低精度时，用强制类型转换，使用格式为： (关键字)(操作对象)，例如(int)(7.85+5.671)；
（2）强制类型转换只针对最近的操作数，因此使用时要带括号来让运算逻辑清晰；
（3）char型变量可以直接赋值整形数字，但是不能直接给赋int型变量值（需要强转）;
// 1. 强制转换格式
int x =(int)(10*3.5+1.5*6);
System.out.println(x); // 44
// 2. char能直接赋int常量值，但不能赋int变量
char char1 = 97;
System.out.println(char1); // 赋int常量值没问题，正常输出a
int num = 'b';
char1 = num; // 赋int变量后报错
char1 = (char)num;
System.out.println(char1); // 强制转换后正常输出b
6.3 关于String类型的转换
（1）基本类型转String
实现方式：基本类型+“”
int a1 = 100;
boolean b1 = true;
float c1 = 1.1f;
double d1 = 4.5;
String s1 = a1 + "";
String s2 = b1 + "";
String s3 = c1 + "";
String s4 = d1 + "";
System.out.println(s1 + " " + s2 + " " + s3 + " " + s4);
（2）String转基本类型
语法：调用基本数据类型的包装类对应方法
String s5 = "123";
int num1 = Integer.parseInt("hello");
double num2 = Double.parseDouble(s5);
float num3 = Float.parseFloat(s5);
long num4 = Long.parseLong(s5);
short num5 = Short.parseShort(s5);
byte num6 = Byte.parseByte(s5);
boolean num7 = Boolean.parseBoolean("true"); // 字符串s5是123,123不是布尔型内容，所以自己设置一个布尔型内容ture或false
char num8 = s5.charAt(0); // 将字符串s5中的第一个字符取出
System.out.println("=================");
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
System.out.println(num5);
System.out.println(num6);
System.out.println(num7);
System.out.println(num8);
注意事项：进行格式转换时要确保格式正确，例如字符串“123”可以转成整 数，但是字符串“hello”不能转成整数。字符串“true”可以转成布尔型，但是字符串“123”不能转成布尔型。当转换格式不正确时，会抛出
70
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
