Java基础02

三、控制语句

一、 条件语句

a) if语句

	i.	常见的结构
	if(表达式){
		}
	if（表达式1）{
	}else {
		}
	if（表达式1）{
		}else if（表达式2）{
		}else if（表达式3）{
	}else{
		}
	ii.	使用场景：一般取值区间判断
		if（score > 90）{
		System.out.println(“A”);
		}

b) switch语句

	i.	语法格式
	switch（表达式）{
	case 1：
	break；
           case 2：
	break；
	default：
	break；
	}
	break和default关键字可以没有
	ii.	使用场景：==判断的时候
	iii.	表达式可以是什么？
	整型、字符、字符串（jdk7之后支持）、枚举
	iv.	  Case 下坠现象
	描述：如果case中没有break语句，则继续执行下面的代码，直到遇到break或者			     switch语句结束

二、循环语句

a) for循环

语法结构：for(表达式1，表达式2，表达式3){
			循环体；
}
	i.	其中表达式1如果有一般是初始化迭代变量表达式；（int i = 0;）
	表达式2如果有，一般是循环判断条件；(i<5;)
	表达式3如果有，一般是迭代变量自增语句(i++);
	ii.	 ()中有且只有两个分号，可以有多个逗号。
	例：     for(int I = 0, j =5;i<4&&j>0;i++,j--){
			循环体
		}
	iii.	表达式执行顺序

	表达式1（只执行一次）表达式2循环体表达式表达式2（满足条件）循环体表达式3……表达式2（不满足）循环体
	iv.	Java中for循环的特点
	迭代变量的类型可以在表达式1其中出现。此时该变量是该次for循环体的局部变量，	即其作用域只是这个for的{}。
	v.	死循环
	for(;;){
	}
	如果表达式2永远为true，也会造成死循环，这种情况是我们不愿看到的情况。
	死循环的使用场景：服务器后台程序一般就是一个死循环，经常用的是		while（true）。
	vi.	使用场景：循环次数已知

b) whlie循环

	语法结构：while（表达式1）{
				循环体；
	变量自增；
	}
	例：
	int i= 0；
	while（i<5）{
	System.out.println(“*”);
	i++;
	}
	死循环：whlie（true） 一定不能是while（1）
	使用场景：事先不知道循环多少次
	
	常见面试题：		
	int i = 0, j = 8;
	while (i++ < 6) {
	j--;
	}
	System.out.println(i + " " + j);    7,2
	c)	do…while循环
	i.	do{
	}
	while(表达式)；
	ii.	使用场景：至少执行一次循环体
	iii.	注意事项：添加“；”
	常见面试题：while循环和do..while的区别？
	int i = 0, j = 8;
	do {
		j--;
		} while (i++ <= 6); 
	System.out.println(i + " " + j);  8,0

三、 条件控制语句

a) break

	使用场景：循环体和switch语句
	作用：跳出循环结构，或者switch语句
	例子：int i = 0, j = 5;
		while (i < 5) {
				while (j > 3) {
					j--;
				if (j == 4) {
						break;
					}
				}
					i++;
		}
	System.out.println(i + " " + j);

b) continue

	使用场景：循环结构
	作用：跳过本次循环，但不跳出循环体
	例子：
	int i = 0, j = 5;
	while (i++ < 5) {
		while (j-- > 3) {
			if (j == 4) {
				continue;
			}
			i++;
		}
	}
	System.out.println(i + " " + j);

c) return

	使用场景：一般防盗方法返回值处

四、 获取控制台输入

	a)	导包：import java.util.*
	b)	创建Scanner对象：Scanner
	c)	获取控制台输入：
	int num= input.nextInt();
	d)	释放资源inpit.close（）；
	e)	注意事项：
		i.	不能直接把next（）当做String对象直接用
		例：input.next().trim()   工程中多次调用会有缓存
		解决方法：先给临时变量，在使用临时变量
		例：String temp = inmput.next();
		Temp.trim()；
		ii.	一般情况下，一个类只写一个成员的Scanner对象；如多每个方法中都创建		一个新的Scanner对象，一定要在使用完后释放资源。
	例：//当成成员变量使用
	 public class Example1{
		Scanner sc = new Scanner(System.in);
		public void func1(){
	String str = sc.next();
}
}
	//当成局部变量使用
	public class Exp2{
	public void func1{
	Scanner sc = new Scanner(System.in);
	String str = sc.next();
	…
	//释放资源
	sc.close();
	sc = null;
	}
	}
	iii.	不能直接把next（）当成实参传递,多次使用会报错
	例：pinfo.setAge(sc.nextInt());
	解决方法：先赋予临时变量，在使用临时变量
	int temp = sc.nextInt();
	pInfo.setAge(temp);
	iv.	  nextInt、next（）和nextLine()	区别
	nextint()和next()不取换行符,nextLine()取换行符。next()遇到空格就结束取值

五、 方法

1.定义：完成特定功能的代码块

2.格式：修饰符 返回值类型 方法名（参数类型1 参数1，参数类型2 参数 2，…）{函数体；

	return返回值；
}

3.例子：

   public static int add (int num1,int num2){
int sum = num1+num2;
return sum;
}
参数列表中的变量（形参）是局部变量。

4.注意事项：

a.方法没有返回值，返回值类型为void

public static void myPrint(int a，int b){
	
	for(int i= 0;i<a;i++ ){
		for(int j = 0;j<b;j++){
			System.out.print("*");
		}
	}	System.out.println();
}	 
b.方法不调用，不会运行。调用方法时，参数类型不用写。

	public static void main（String[]args）{
	
		myPrint(3,4);
	}
c.方法里边不能再定义方法

5、方法重载

定义：同一个类中出现了重名的现象，但是参数列表不同（参数个数，类型不同），与返回值类型无关。具体调用的是哪个方法有jvm根据参数列表来决定。

好处：实际工程中，如果不使用方法重载的办法，程序员需要记忆很多相同功能的方法名；而重载了之后，相同功能的方法只需要记忆一个名字即可。

6、递归方法

方法中出现了调用该方法本身的现象。
7、传值和传引用

六、数组

1、定义：存储同一种数据类型的元素集合。 基本数据类型 引用数据类型

2、定义格式：

	数据类型[]数组名；
	数据类型 数组名[]；

3、初始化：

	数组初始化需要用到new关键字
	a.静态初始化
	int [ ]ages = new int [ ]{1,2,3,4};
int[] ages ={1,2,3,4};
	b.动态初始化
	int [ ]ages = new int[4];
	ages[0]=1;
	ages[1]=2;
	ages[2]=3;
	ages[3]=4;

4、内存空间

	分类：栈空间、堆空间、方法区空间、寄存器空间
	栈：局部变量、基本数据类型、引用变量
	堆：new出来的实体、对象

5、注意事项

	a.数组的长度            length属性
	b.数组的索引从0开始，到length-1结束
	c.数组下标不能超过length-1，否则会出现
		ArrayIndexOutOfBoundsException  数组越界
	d.Java中没有多维数组的定义，所谓多维数组其实是一维数组中的元素是个数组

6、数组的操作

	a.遍历
		i.for循环遍历
		int[]ages = new int []{1,2,3,4}
		for(int i = 0;i<ages.length;i++){
			System.out.println(ages[i]);			

		}
		ii. foreach(增强for循环)
		    int [] ages = new int[]{1,2,3,4};
		    for(int age:ages){
							
			System.out.print(age);
			}
	b.排序
			i.快速排序
Arrays.sort(ages);

	ii.冒泡排序
for (int age:ages){
System.out.print(age);
}
int[] ages = new int[]{3,4,2,6};
for (int i = 0;i<ages.length;i++){
for (int j = 0;j<ages.length-1;j++){
    if (ages[j+1]<ages[j]) {
        int temp = ages[j];
        ages[j] = ages[j+1];
        ages[j+1] = temp;
    }
}
}
for (int age:ages){
System.out.print(age);
}

iii.选择排序
int[] ages = new int[]{3,4,2,6};
for (int i = 0;i<ages.length;i++){
int min = i;
for (int j = i+1;j<ages.length;j++){
    if (ages[min]>ages[j]){
        min = j;
    }
}
if (min!=i){
    int temp = ages[i];
    ages[i] = ages[min];
    ages[min] = temp;
}
}
for (int age:ages){
System.out.print(age);
}

7、多维数组

数据类型 数组名[ ][ ]= new 数据类型 [m][n];
数据类型 [ ][ ]数组名= new 数据类型 [m][n]
数据类型[ ]数组名[ ]= new 数据类型 [m] [n]

七.常见的调试代码的方法

意义:定位问题,解决问题

1. 插断点

跟编辑器有关,结果比较直观

2. 插小旗

在需要调试的地方打印print语句,即输出当前变量的值,已查看当前变量是否出现异常.折半查找问题

3. 屏蔽代码

借助多行注释进行调试.借用/**/屏蔽掉不想运行的代码,放开想调试的代码.