JavaSe day1 控制流程&方法

总用时8个番茄

控制流程

Scanner

import java.util.Scanner;

public class Demo01 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in); //创建Scanner对象
		String str = scan.nextLine(); //获取输入语句
		System.out.println(str);	
		scan.close();  //凡是属于IO流的如果不关闭会一直占用资源，所以要习惯关闭
	}
}

注意：一定要关闭IO流

next()&netxLine()区别

next()

• 有效字符前的空白，会自动消除

-->0/0/hah
-->hah

• 有效字符后的空白作为分隔结束符，所以next()不能输入带有空格的字符串

-->hello0/world
-->hello

nextLine()

以Enter为结束符，会输入回车前所有的内容，可以获得空白

-->0/hello0/world
-->0/hello0/world

判断是否还有输入/输入类型

hasNext()、hasNextLine()、hasNextFloat() 判断输入的是否是Float类型的

		Scanner scan = new Scanner(System.in);
		System.out.println("请输入一个整数");
		int i;
		if(scan.hasNextInt()){ //判断输入的是否是整数
			i=scan.nextInt();
			System.out.println("你输入的是整数"+i);
		}else {
			System.out.println("你输入的不是整数");
		}
		scan.close();

看源码

按ctrl点那个类

点左下角可以看到里面方法

这个就是Scanner.next()方法的源码

if语句

equals 判断字符串是否相等

		String i = scan.nextLine();
		if (i.equals("hello")){ //判断字符串i是否和hello相同
			System.out.println("same");
		}else{
			System.out.println("no same");
		}

注意只能对比字符串，不可以比较int、float，会报错

Switch多选择结构

一定要记住

switch(表达式){
    case value:
        break;
    case value:
        break;
    default: //可选
}

在JDK7以后，表达式才支持字符串

case穿透现象

就是如果一条case语句后面不写break，就会继续运行下去

		char grad = 'a';
		switch (grad){
			case 'a':
				System.out.println("优秀");
			case 'b':
				System.out.println("良好");
			case 'v':
				System.out.println("及格");
		}
-->  优秀
     良好
	 及格

		char grad = 'a';
		switch (grad){
			case 'a':
				System.out.println("优秀");
                break;
			case 'b':
				System.out.println("良好");
			case 'v':
				System.out.println("及格");
		}
-->  优秀

for循环

快捷创建for循环

输入：100.for
马上变成从0开始，到100，自增的运算		
-->  for (int i = 0; i < 100; i++) {
			
		}
  
    

九九乘法表

	public static void main(String[] args) {
		for (int i = 1; i < 10; i++) {
			for (int j = 1; j <i+1; j++) {
				System.out.print(i+"*"+j+"="+i*j+" ");
			}
			System.out.println();
		}
	}

增强for循环

for(声明语句:表达式){
	代码
}

		int[] a = {1,2,3,4,5};
		for(int x:a){ //将数组a中的每一个数逐一赋值到x中
			System.out.println(x);
		}

break&continue

breake是跳出整个循环，不会再进行循环了

continue是跳出这一次循环，循环还会继续

方法

System.out.println()
    
System:系统类
out:对象
println():方法

设计方法的原则：（原子性）一个方法只完成一个功能，有利于后期的拓展

定义方法

修饰符 返回类型 方法名(参数类型 参数名){
    
    方法体
        
    return 返回值
}

• 修饰符：public公共
• 返回类型：就是最后return的类型，如果没有返回值就填 void
• 方法名：遵循 驼峰规则 setArray()
• 参数类型：这里是形式参数
• 方法体：定义具体的功能

return 0;//是终止方法的意思

方法的重载

在一个类中，有相同的方法名称，但是形式参数不同，编译器根据不同的形参，来调用相应的方法

规则：

• 方法名字相同
• 参数列表不同（参数个数不同，类型不同，参数排列顺序不同）

//匹配大小的问题，涉及到参数个数不同，参数类型不同，分辨调用相同名字但是方法内容不同的方法，这就叫方法的重载
public class Demo01 {
	public static void main(String[] args) {
		int i = max(11,12);//两个int型参数
		System.out.println("最大的数是"+i);
		System.out.println("************");
		double j = max(11.2,5.2);//两个double型参数
		System.out.println("最大的数是"+j);
		System.out.println("************");
		int k = max(10,2,62);//三个int型参数
		System.out.println("最大的数是"+k);
	}
    
    //两个int型参数
	public static int max(int x, int y) {
		int res;
		if (x>y){
			res = x;
		}else {
			res = y;
		}
		return res;
	}
    
    //两个double型参数
	public static double max(double x, double y) {
		double res;
		if (x>y){
			res = x;
		}else {
			res = y;
		}
		return res;
	}
    
    //三个int型参数
	public static int max(int x, int y,int z) {
		int res;
		if (x>y){
			if (y>z){
				res=x;
			}else{//z>y
				if (z>x){
					res=z;
				}else {//x>z
					res=x;
				}
			}
		}else { //y>x
			if (x>z){
				res=y;
			}else { //z>x
				if (z>y){
					res=z;
				}else { //y>z
					res=y;
				}
			}
		}
		return res;
	}
}


最大的数是12
************
最大的数是11.2
************
最大的数是62

理论：

方法名称相同时候，jvm会根据调用方法的参数个数和参数类型逐一匹配，来选择对应的方法，如果匹配失败，就会报错

可变参数

如果我要比较一串数量不定的数，里面谁最大。因为不知道这串数字有多少个数，所以定义方法时候就不能规定死参数个数的多少，因此要引入可变参数的概念

使用方法：

• 在方法参数类型后面加一个省略号…
• 一个方法只能指定一个可变参数，他必须是方法最后一个参数。任何方法都必须在它之前声明

可变参数的实质是数组

public class Demo01 {
	public static void main(String[] args) {
        
		max(12,2,56.2);//本质上就是输入了一个double类型的数组
		System.out.println("****************");
		max(new double[]{12,2,56.2}); //
        
	}

	public static void max(double... nums){ //等价于 double[] nums，但是如果改成这个以后，max(12,2,56.2)就会报错，因为这里输入的不是一个数组；
		double result = nums[0];//像数组一样操作
		for (int i = 0; i < nums.length; i++) {
			if (nums[i]>result){
				result=nums[i];
			}
		}
		System.out.println("the max value is:"+result);

	}
}

递归