java基础语法学习（复习）day2

今日学习总结

1、Scanner类的使用
2、Random随机数类的使用
3、if语句和三元运算符的互换
4、while循环
5、for循环
6、do_while循环
7、break和continue
8、switch语句
9、数组的定义
10、数组的内存分配
11、数组的静态初始化
12、数组常见问题
13、方法
14、方法的重载

ps：并不是从零自学，本身有一定的基础，仅是系统的复习一遍知识点并简单记录
因此本文仅包含本人认为容易遗忘的知识点或有注意事项的知识点，并不涵盖所有知识点

1、Scanner类的使用

* A: Scanner类的使用
	* a: 导包import java.util.Scanner;
	* b：创建键盘录入对象 Scanner sc = new Scanner(System.in);
	* c: 读取键盘录入的一个整数
		* int enterNumber = sc.nextInt();
	* d: 读取键盘录入的字符串
		* String enterString = sc.next();
* B: 案例代码
	import java.util.Scanner;
	public class Demo05Scanner{
		public static void main(String[] args) 
		{
			Scanner sc = new Scanner(System.in);

			int enterNumber = sc.nextInt();
			System.out.println("用户输入的整数为"+enterNumber);

			String enterString = sc.next();
			System.out.println("用户输入的字符串为"+enterString);
		}
	}

2、Random随机数类的使用

* A: Random随机数类的使用
	* a: 功能
		* 生成随机数需要使用到引用类型随机数Random类
	* b: 使用方式
		* import导包：所属包java.util. Random
		* 创建实例格式：Random  random = new Random ();
		* 调用方法
			* nextInt(int maxValue)	产生[0,maxValue)范围的随机数,包含0不包含maxValue
			* nextDouble()  产生[0,1)范围的随机数
			如：
				Random  random = new Random ();
				int  myNumber = random.nextInt(100);//结果为0-99的一个数
	* c: 调用方法
		* nextDouble()  产生[0,1)范围的随机数
		如：
			Random  random = new Random ();
			int  myNumber = random.nextDouble();//结果为0.0-1.0之间的数(包括0.0不包括1.0)
* B: 案例代码
	import java.util.Random;
	public class RandomDemo{
		public static void main(String[] args){
		   Random ran = new Random();
		   // Random类中的,产生随机数的功能
		   int i = ran.nextInt(100);
		   System.out.println(i);
		   
		   //问题? 产生随机数,范围 1-100之间
		   // nextInt(100) 0-99 + 1
		}
	}

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

* A: 三元运算符
	* a: 概念
		* 用来完成简单的选择逻辑，即根据条件判断，从两个选择中选择一种执行
	* b: 使用格式
		* (条件表达式)？表达式1：表达式2；
	* c: 运算规则
		* 1: 判断条件表达式，结果为一个布尔值
		* 2: true，运算结果为表达式1
		* 3: false，运算结果为表达式2
* B: 案例代码
	public class IfElseDemo_1{
		public static void main(String[] args){
			int j = 6;
			int i = 15;
			//使用if语句,判断出最大值
			if(i>j){
			int j = 6;
				System.out.println(i+" 是最大值");
			}else{
				System.out.println(j+" 是最大值");
			}
			
			//使用三元运算实现
			int k = i>j ? i : j;
			System.out.println(k+" 是最大值");
		}
	}
* C: 使用if语句还是三元表达式
	* 判断条件多,使用if
 	* 三元,必须有结果的, if 可以没有结果的

4、while循环

* A: while循环结构
	* a: 使用格式
		初始化表达式；
		while(条件){
			循环体
		}
	* b: 执行顺序
		  当条件是true,就执行循环体,执行完循环体后
		  程序再次执行while中的条件,如果条件还是true,继续执行循环体
		  直到条件是false的时候,循环就结束

5、for循环

* A: for循环
	* a: 使用格式
		 for(初始化变量 ; 条件 ; 增量){
			 循环体;
		 }
	* b: 各模块解释
		初始化变量: 定义变量,作用是用来控制循环的次数
	    条件: 当条件是true,执行循环体,条件是false,结束循环
	    增量: 变量自增情况 

6、do_while循环

* A: do_while循环
	* a: 使用格式
		do{
		   循环体;
	    }while(条件);
	* b: 执行顺序
		先执行一次循环体，然后再判断条件，如果条件为true，继续执行循环体，
		如果条件为false，循环结束。
	* c: 特点
		* 无条件先执行一次
* B: 案例代码
	public class DoWhileDemo{
		public static void main(String[] args){
			int i = 0; 
			do{
				System.out.println(i);
				i++;
			}while( i <  5);
		}
	}

7、break和continue

* A: break语句
	* a: 作用
		* 跳出所在的循环体
	* b: 书写位置
		* 必须出现在循环或选择结构内
	* c: 举例
		for(int i=0; i<10; i++) {
			if(i>5) {
			break;
		}
			System.out.println(“我爱Java”+i);
		}
		//会从0-5输出6次“我爱Java”
		
* B: continue语句
	* a: 作用
		* 提前结束本次循环，继续进行下次循环
	* b: 使用方式
		* 无法单独使用，必须将continue关键字置于循环语句中
	* c：运行规律
		* 不需要判断任何条件，只要遇到continue变直接跳出本轮循环进行下次循环
	* d：案例代码
		public class ContinueDemo{
			public static void main(String[] args){
				for(int i = 0 ; i < 10 ; i++){
					if(i%2==0){
						continue;
					}
					System.out.println(i);
				}
			}
		}
		//会把0-9之间所有的奇数打印到控制台上

8、switch语句

​* A:switch语句解构
	*a: switch只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。
	*b: 格式如下:
  	      swtich(表达式){
  			  case 常量1 :
  			    要执行的语句;
  			  break;
  			  
  			  case 常量2 :
  			    要执行的语句;
  			  break;
  
  			  default:
  			    要执行的语句;
  			  break;
  		  }
  	* c: 执行流程:  表达式,和case后面的常量进行比较和哪个case后的常量相同,就执行哪个case后面的程序,遇到break,就全结束
 
​* B:case穿透​			
	* a: 在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式。

9、数组的定义

​	* A：数组的定义
​	* b:格式:
		 数据类型[] 数组名 = new 数据类型[元素个数或数组长度];
	* c:举例:
		 int[] x = new int[100];

10、数组的内存分配

例：int[] arr = new int[3]
分配过程：
	首先执行右边的new int[3],在堆内存中分配内存如堆内存图，左边为索引，右边为值，001为地址
	然后再执行int[] arr,将栈内存的arr指向堆内存中的001地址

11、数组静态初始化

12、数组常见问题

1.	索引越界     //.ArrayIndexOutOfBoundsException
		int[] arr = new int[3];
		System.out.println(arr[3]);
2.	空指针异常   //NullPointerException
		int[] arr = new int[3];
		arr= null;//地址指向为null

13、方法

* A: 方法的格式
* 
		修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
			方法体语句;
			return 返回值; 
		} 
* B:案例： 定义方法计算面积
	public class MethodDemo{

		public static void main(String[] args){
			 //调用方法, 方法执行起来
			 // 在方法main中,调用方法 getArea
	
			 int area = getArea(5,6);
			 System.out.println("面积是: "+area);
			
		}
		/*
		   要求: 计算一个长方形的面积
		   定义方法解决这个要求
		   分析方法定义过程:
		      1.明确方法计算后的结果的数据类型 int  定义格式对应的就是返回值类型
			  2.方法计算过程中,有没有未知的数据, 宽和长, 未知数据的数据类型 int
			      未知数的变量,定义在方法的小括号内
		*/
		public static int  getArea(int w, int h){
			//实现方法的功能主体
			//int area = w * h;
			return w * h;
		}
	}
* C: 方法的定义和使用的注意事项
	* a: 方法不能定义在另一个方法的里面
 	* b: 写错方法名字
	* c: 写错了参数列表
	* d: 方法返回值是void,方法中可以省略return 不写
	     return 下面不能有代码
	* e 方法返回值类型,和return 后面数据类型必须匹配
	* f: 方法重复定义问题
	* g: 调用方法的时候,返回值是void, 不能写在输出语句中

14、方法的重载

* A: 方法的重载
	* 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。

	* 参数列表不同：
		* A:参数个数不同
		* B:参数类型不同
		* C:参数的顺序不同(算重载,但是在开发中不用)

* B: 案例代码
	public static int getSum(int a,int b){
		System.out.println("两个int参数");
		return a+b;
	}
	public static int getSum(int a,int b,int c){
		System.out.println("三个int参数");
		return a+b+c;
	}
	public static double getSum(double a,double b){
		System.out.println("两个double参数");
		return a+b;
	}
* C: 方法重载注意事项
	* a: 参数列表必须不同
	* b: 重载和参数变量名无关
	* c: 重载和返回值类型无关
	* d: 重载和修饰符无关
    * e: 技巧: 重载看方法名和参数列表
* D: 方法参数是基本数据类型
	* a: 方法参数是基本类型时，传递的是值。
* E: 方法参数是引用数据类型
	* a: 方法参数是引用类型时，传递的是内存地址值。

方法重载示例：