Java基础语法

• 自动类型转换（隐式）
  1. 特点：代码不需要进行特殊处理，自动完成。
  2. 规则：数据范围从小到大。

• 强制类型转换（显式）

  强制类型转换
   	1. 特点：代码需要进行特殊的格式处理，不能自动完成。
      2. 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
  
  注意事项：
   	1. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
   	2. byte/short/char这三种类型都可以发生数学运算，例如加法“+”.
   	3. byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。
   	4. boolean类型不能发生数据类型转换
  复制

数字和字符的对照关系表（编码表）：

• ASCII码表：American Standard Code for Information Interchange，美国信息交换标准代码。
• Unicode码表：万国码。也是数字和符号的对照关系，开头0-127部分和ASCII完全一样，但是从128开始包含有更多字符

  	48 - '0'
  	65 - 'A'
  	97 - 'a'
  	/*大写字母和小写字母相差32,例如：*/
  	char zifu3 = 'c';
  	// 左侧是int类型，右边是char类型，
  	// char --> int，确实是从小到大
  	// 发生了自动类型转换
  复制

运算符：进行特定操作的符号。例如：+
表达式：用运算符连起来的式子叫做表达式。例如：20 + 5。又例如：a + b

• 单if

  if(关系表达式)｛
  	语句体;
  ｝
  复制

  

• 标准的if-else语句

  if(关系表达式) {
  	语句体1;
  	}else {
  	语句体2;
  }
  复制

  

• if..else if...else

// x和y的关系满足如下：
// 如果x >= 3，那么y = 2x + 1;
// 如果-1 < x < 3，那么y = 2x;
// 如果x <= -1，那么y = 2x – 1;
public class Demo04IfElseExt {
	public static void main(String[] args) {
		int x = -10;
		int y;
		if (x >= 3) {
			y = 2 * x + 1;
		} else if (-1 < x && x < 3) {
			y = 2 * x;
		} else {
			y = 2 * x - 1;
		}
		System.out.println("结果是：" + y);
	}
}
复制

• if语句和三元运算符的互换

// 题目：使用三元运算符和标准的if-else语句分别实现：取两个数字当中的最大值
public class Demo06Max {
	public static void main(String[] args) {
		int a = 105;
		int b = 20;
		
		// 首先使用三元运算符
		// int max = a > b ? a : b;
		
		// 使用今天的if语句
		int max;
		if (a > b) {
			max = a;
		} else {
			max = b;
		}
		
		System.out.println("最大值：" + max);
	}
}
复制

public class Demo07Switch {
	public static void main(String[] args) {
		int num = 10;
		
		switch (num) {
			case 1:
				System.out.println("星期一");
				break;
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期日");
				break;
			default:
				System.out.println("数据不合理");
				break; // 最后一个break语句可以省略，但是强烈推荐不要省略
		}
	}
}
复制

switch语句使用的注意事项：

1. 多个case后面的数值不可以重复。

2. switch后面小括号当中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举

3. switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略。
“匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。”【case的穿透性】
复制

循环结构的基本组成部分，一般可以分成四部分：

1. 初始化语句：在循环开始最初执行，而且只做唯一一次。
2. 条件判断：如果成立，则循环继续；如果不成立，则循环退出。
3. 循环体：重复要做的事情内容，若干行语句。
4. 步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。

• for

  for(初始化表达式①; 布尔表达式②; 步进表达式④){
  		循环体③
  }
  复制

• while

  /*
  初始化语句;
  while (条件判断) {
  	循环体;
  	步进语句;
  }
  */
  public class Demo10While {
  	public static void main(String[] args) {
  		for (int i = 1; i <= 10; i++) {
  			System.out.println("我错啦！" + i);
  		}
  		System.out.println("=================");
  		
  		int i = 1; // 1. 初始化语句
  		while (i <= 10) { // 2. 条件判断
  			System.out.println("我错啦！" + i); // 3. 循环体
  			i++; // 4. 步进语句
  		}
  	}
  }
  复制

• do-while

  /*
  初始化语句
  do {
  	循环体
  	步进语句
  } while (条件判断);
  */
  public class Demo11DoWhile {
  	public static void main(String[] args) {
  		for (int i = 1; i <= 10; i++) {
  			System.out.println("原谅你啦！起来吧！地上怪凉！" + i);
  		}
  		System.out.println("===============");
  		
  		int i = 1; // 1. 初始化语句
  		do {
  			System.out.println("原谅你啦！起来吧！地上怪凉！" + i); // 3. 循环体
  			i++; // 4. 步进语句
  		} while (i <= 10); // 2. 条件判断
  	}
  }
  复制

  三种循环的区别。

  1. 如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。
  2. for循环的变量在小括号当中定义，只有循环内部才可以使用。while循环和do-while循环初始化语句本来就在外面，所以出来循环之后还可以继续使用

• break

  /*
  break关键字的用法有常见的两种：
  
  1. 可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
  2. 还可以用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环。
  
  关于循环的选择，有一个小建议：
  凡是次数确定的场景多用for循环；否则多用while循环。
  */
  public class Demo14Break {
  	public static void main(String[] args) {
  		for (int i = 1; i <= 10; i++) {
  			// 如果希望从第4次开始，后续全都不要了，就要打断循环
  			if (i == 4) { // 如果当前是第4次
  				break; // 那么就打断整个循环
  			}
  			System.out.println("Hello" + i);
  		}
  	}
  }
  复制

• continue

  /*
  另一种循环控制语句是continue关键字。
  一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环。
  */
  public class Demo15Continue {
  	public static void main(String[] args) {
  		for (int i = 1; i <= 10; i++) {
  			if (i == 4) { // 如果当前是第4层
  				continue; // 那么跳过当前次循环，马上开始下一次（第5层）
  			}
  			System.out.println(i + "层到了。");
  		}
  	}
  }
  复制

/*
永远停不下来的循环，叫做死循环。

死循环的标准格式：
while (true) {
	循环体
}
*/
public class Demo16DeadLoop {
	public static void main(String[] args) {
		while (true) {
			System.out.println("I Love Java!");
		}
		
		// System.out.println("Hello");
	}
}
复制

public class Demo17LoopHourAndMinute {
	public static void main(String[] args) {
		for (int hour = 0; hour < 24; hour++) { // 外层控制小时

			for (int minute = 0; minute < 60; minute++) { // 内层控制小时之内的分钟
				System.out.println(hour + "点" + minute + "分");
			}

		}
	}
}
复制

数组的概念：是一种容器，可以同时存放多个数据值。

数组的特点：

1. 数组是一种引用数据类型
2. 数组当中的多个数据，类型必须统一
3. 数组的长度在程序运行期间不可改变

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
两种常见的初始化方式：

1. 动态初始化（指定长度）

   	数据类型[] 数组名称 = new 数据类型[数组长度];
   复制

2. 静态初始化（指定内容）

   标准格式：
   数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };
   
   省略格式：
   数据类型[] 数组名称 = { 元素1, 元素2, ... };
   复制

​如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

​使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下：

如果是整数类型，那么默认为0；

如果是浮点类型，那么默认为0.0；

如果是字符类型，那么默认 为'\u0000'【不可见字符】'；

如果是布尔类型，那么默认为false；

如果是引用类型，那么默认为null。

注意事项：静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。

直接打印数组名称，得到的是数组对应的：内存地址哈希值。【16进制】

访问数组元素的格式：数组名称[索引值]
【注意】索引值从0开始，一直到“数组的长度-1”【数组名.length-1】为止。

改变数组当中元素的内容：

array[1] = 10;
复制

更改数组地址：

// 将arrayA数组的地址值，赋值给arrayB数组
int[] arrayB = arrayA;
System.out.println(arrayB); // 地址值
复制

遍历数组：

 
//1、普通for循环
 for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
//2、增强for循环
for(int i:array){
	Syoutem.out.println(i);
}
复制

数组反转：

  /*
        初始化语句：int min = 0, max = array.length - 1
        条件判断：min < max
        步进表达式：min++, max--
        循环体：用第三个变量倒手
         */
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
复制

图例

首先int[][] arr 压栈，然后在堆内存中分配一个二维数组的地址，引用给arr声明，注意，这里的地址其实是一个一维数组，一维数组中存放的都是地址值，然后遍历arr[],再次分配几个一维数组堆内存，将它们在堆中的地址值存储在arr[]中，这样一个二维数组就完成了，注意，新分配的这几个一维数组内存储的就都是正儿八经的数据。

eg：foreach遍历一个二维数组

在java中是没有真正的二维数组的。所以在外层循环中定义了一个字符串数组类型的变量，而内层是真正定义了一个字符串类型。

 String name[][] = { { "张三", "李四", "王五" }, { "张六", "李七", "王八" },
				{ "张九", "李十", "王十一" } };
		for (String[] str1 : name) {
			for (String str2 : str1) {
				System.out.println(str2);
			}
复制

定义格式：

修饰符 返回值类型 方法名称(参数类型 参数名称, ...) {
    方法体
    return 返回值;
}
三要素
返回值类型、方法名称、参数列表
复制

3种调用方法：

1. 单独调用：方法名称(参数);
2. 打印调用：System.out.println(方法名称(参数));
3. 赋值调用：数据类型 变量名称 = 方法名称(参数);
复制

return两个作用：第一停止当前方法，第二将后面的返回值还给调用处

注意事项：对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。
复制

• 方法重载与下列因素相关：

  1. 参数个数不同
  2. 参数类型不同
  3. 参数的多类型顺序不同
• 方法重载与下列因素无关：

  1. 与参数的名称无关
  2. 与方法的返回值类型无关