2021-07-07

java入门学习day02

昨日复习:
1.JDK (jre + tools)
2.变量 先声明后使用
3.类型: 基本数据类型 + 引用数据类型
4.基本数据类型:
byte -> short(char) -> int -> long -> float -> double
5.运算符:
&& &
>> >>>
? : -> if - else

---

逻辑控制语句

1.顺序结构
2.条件分支结构
如果xxx,就xxx -> if()
如果xxx,就xxx,否则xxx -> if() - else
如果xxx,就xxx,否则 如果xxx,就xxx
-> if -else if - else

public class Demo01 {

	public static void main(String[] args) {
		/*
		 * 	需求: 如果你们考了满分,那就奖励遥控汽车
		 */
		
		//JDK - 类 Ctrl + Shift + O
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入分数:");
		int score = sc.nextInt();
		
		//int score = 20;
		if(score == 100) {
			//符合if条件后,执行的语句
			System.out.println("买一辆遥控汽车");
			System.out.println("买电池");
		}else {
			System.out.println("买一堆试题!!!");
		}
	}

}

switch - case :
(1)只只适用于判断值是否相等
(2)switch(条件) -> 要判断的条件
条件: byte/short/int/char/String
(3)case:
a.case后面接的是要对比的值
b.case具有穿透性的,遇到break结束
c.defalut(默认情况):相当于if-else if () - else情况中的 else

public class Test {
	//switch后跟的是要判断的变量
	//要判断的变量 : 可以放能自动转换成int 的值
	//case:具有穿透性的
   public static void main(String args[]){
      int i = 5;
      switch(i){
         case 0:
            System.out.println("0");
            break;//如果没有break；则会持续运行下去
         case 1:
            System.out.println("1");
            break;
         case 2:
            System.out.println("2");
            break;
         default:
            System.out.println("default");
      }
   }
}

3.循环结构
for:有规律可循,知道次数使用for循环
执行顺序:
1. int i = 0; 进入循环的初始值
2. i < 100; 进入循环的条件
3. 循环体内容;
4. i++ ; 步长,i的变化规律

/*
 * 	For循环
 */
public class Demo01 {
	public static void main(String[] args) {
		// 1 ~ 100的和
		//int i = 0 -> 循环的初始值
		//i <= 100 -> 判断是否进入循环
		//i++ -> 步长,i的变化值
		int sum = 0;
		int i = 1;
		for (/* int i = 1 */; i <= 100; i++) {
			//for循环体
			sum += i;

		}
		System.out.println("i:" + i);
		System.out.println("sum:" + sum);
	}

}

while:没有规律,不知道次数的时候使用while循环

do-while: 先执行一次,再循环

while和do-while不能进行随意切换的情况:
在第一次进入循环是就不符合条件

public class Demo03 {
	public static void main(String[] args) {
		// 求 1 ~ 100的和
		int sum = 0;
		for (int i = 1 ; i <= 100; i++) {
			//for循环体
			sum += i;
		}
		//while
		int i = 1 ;
		while(i <= 100) {
			sum += i;
			i++;
		}
		// 从1开始求和,直到超过500为止
		while(sum <= 500) {
			sum += i;
			i++;
		}
		//死循环
		while(true) {
			
		}	
	}
}

---

数组: 批量定义变量

1.声明(定义)
int[] arr;
char[] c;
double[] d;
byte[] b;

2.初始化
a.静态赋值
特点:只能在声明的同时初始化
int[] arr = {1,2,3,4};

b.静态赋值
特点:可以进行重复赋值
int[] arr = new int[]{1,3,4,5}

静态赋值特点:
都是在声明的时候就已经确定了数组的长度和数组的元素

c.动态赋值
特点:在定义数组是只确定了数组的长度
所以有默认初始值:
int -> 0
double -> 0.0
char -> ‘\u0000’
String -> null
boolean -> false

3.修改(获取)数组的元素
通过下标获取(修改),下标都是从0开始的
数组下标的范围:0 ~ length-1

4.数组的属性 length
数组的长度 = 数组的元素个数

5.数组的遍历/迭代
依次获取数组中的元素

package c_arr;

import java.util.Arrays;

/*
 * 	数组的使用:
 * 		批量定义变量
 *   int a = 10;
 */
public class Demo01 {

	public static void main(String[] args) {
		//数组的定义:
		// 静态赋值
		//int[] arr 声明数组变量
		//特点: 只能在声明的时候初始化
		int[] arr = {1,2,3,4};// 0 ~ 3(4-1)   0 ~ length-1
		
		//arr = {1,2,3,4}; 编译错误,整体赋值方式不允许
		
		//静态赋值:可以重复赋值
		int[] arr2 = new int[] {2,3,4,5};
		arr2 = new int[] {2,3,5};//重复赋值
	
		//静态赋值: 在定义时就已经确定了数组的元素
		
		
		//动态赋值
		// [5] -> 5代表数组的长度 
		int[] arr3 = new int[5];//{0,0,0,0,0}
		
		//想要获取arr数组中的元素 2
		//可以通过下标获取: 数组存在下标 -> 下标从0开始
		System.out.println(arr[1]);
		
		//给arr3中的元素赋值
		arr3[0] = 2;//0
		arr3[1] = 3;//1
		arr3[2] = 3;//2
		arr3[3] = 3;//3
		arr3[4] = 3;//4
		System.out.println(arr3[4]);
		
		//ArrayIndexOutOfBoundsException:数组下标越界异常

		//数组中的属性 length 长度  = 个数
		System.out.println(arr3.length);
		
		//数组的循环/遍历 - 挨个获取数组中的元素
		for(int i = 0; i < arr3.length; i++) {
			System.out.println(arr3[i]);
		}
		
		
		//打印所有的数组元素 [2, 3, 3, 3, 3]
		System.out.println(Arrays.toString(arr3));//[I@532760d8
	
		//java.lang.NullPointerException ->空指针异常
		arr3 = null;
		System.out.println(arr3[0]);
		
	}

}

package c_arr;
/*
 * 有一对兔子，从出生后第3个月起每个月都生一对兔子，
 * 小兔子长到第三个月后每个月又生一对兔子，
      假如兔子都不死，问第二十个月的兔子对数为多少？
   [使用:数组方式完成]
 */
public class Demo02_Work {
	public static void main(String[] args) {
		int[] arr = new int[20];
		
		//第一个月
		arr[0] = 1;//0
		//第二个月
		arr[1] = 1;//1
		/*
		 * 	arr[2] = arr[0] + arr[1]
		 *  arr[3] = arr[2] + arr[1]
		 *  arr[4] = arr[3] + arr[2]
		 */
		
		//数组的遍历
		for(int i = 2; i < arr.length; i++) {
			arr[i] = arr[i-2] + arr[i -1];
		}

	}

}