JAVA学习Day02

Java学习Day02

Scanner 对象

用来获取用户的输入

语法

Scanner s = new Scanner(System.in);

通过Scanner类的next()与next Line()方法获取输入的字符，在读取前我们一般需要用hasNext()判断是否还有输入的数据。

import java.util.Scanner;
public class Demo01{
    public static void main(String[] args){
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("使用next方式接收：");
        
        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            //使用next方式接收：
            String str = scanner.next();
            System.out.println("输出的内容为："+str);
        }
        
        //使用IO流的类不关闭会一直占用资源，用完即关
        scanner.close();
    }
}

next()以空格为结束符

nextLine()以回车为结束符

Scanner 进阶

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //从键盘键入数据
        int i = 0;
        float f = 0.0f;
        System.out.println("请输入数据");
        //判断是否为整数
        if(scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据"+i);
        }else {
            System.out.println("数据不合法");
        }

        System.out.println("请输入数据");
        //判断是否为小数
        if(scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据"+f);
        }else {
            System.out.println("数据不合法");
        }
        scanner.close();
    }
}

增强for循环

主要用于数组和集合的增强型for循环

语法

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

声明语句：声明心得局部变量，其类型必须和数组元素的类型匹配。作用域限定在循环语句块，其值与此时数组元素的值相等

表达式： 表达式是要访问的数组名，或者是返回值为数组的方法。

对比

public class Demo06 {
    public static void main(String[] args) {
        int [] number = {1,2,3,4,5,6,7,8,9,10};
        for (int i=0;i<5;i++){
            System.out.print(number[i]+"\t");
        }
        System.out.println();
        System.out.println("====================================================");
        //遍历数组中元素
        for (int x:number){
            System.out.print(x+"\t");
        }
    }
}

运行结果

1	2	3	4	5	
====================================================
1	2	3	4	5	6	7	8	9	10

continue语句

再循环语句中作用是终止本次循环，执行下一次循环。（即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判断）

代码演示

public class Demo07 {
    public static void main(String[] args) {

        for(int i=0;i<100;i++ ){
            if (i%10==0){
                System.out.println("测试");
                continue;
            }
            System.out.print(i);
        }
    }

}

结果

测试
123456789测试
111213141516171819测试
212223242526272829测试
313233343536373839测试
414243444546474849测试
515253545556575859测试
616263646566676869测试
717273747576777879测试
818283848586878889测试
919293949596979899

结果可以看出，所有10的倍数都没有被输出，跳过了执行

在嵌套循环语句中，continue语句后面也可以通过使用标记的方式结束本次外层循环，用法与break 类似

Java方法

什么是方法

Java方式是语句的集合，它们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用
设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，有利于后期的扩展

方法命名

第一个单词小写后面单词驼峰命名

方法编写小试

public class Demo08 {
    public static void main(String[] args) {
        //实际参数：实际调用传递给他的参数
        int sum = add(1,3);
        System.out.println(sum);
    }
    //方法编写 ：加法
    //形式参数，用来定义作用的
    public static  int add(int a, int b){
        return a+b;
    }
}

结果输出为4

方法语法

修饰符 返回值类型 方法名(参数类型 参数名1 , 参数类型 参数名2...){
	...
	方法体
	...
	return 返回值;
}

方法的重载

重载（over loading）是在一个类里面，方法名相同，而参数不同。返回类型可以相同也可以不同

JAVA允许在一个程序中定义多个名称相同的方法，但是参数类型或者个数必须不同

方法重载的规则：

方法名必须相同。
参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。
方法的返回类型可以相同也可以不同
仅仅返回类型不同不足以成为方法的重载。

方法重载练习

public class Demo09 {
    public static void main(String[] args) {
        //针对求和方法的调用
        int sum1 = add(2,3);
        int sum2 = add(2,3,4);
        double sum3 = add(2.3,2.3);
        //打印求和结果
        System.out.println("sum1="+sum1);
        System.out.println("sum2="+sum2);
        System.out.println("sum3="+sum3);
    }
    /*
    * 方法重载练习，编写求和方法
    * */
    //实现两个整数相加
    public static int add(int a, int b){
        return a+b;
    }
    //实现三个整数相加
    public  static int add(int a, int b, int c){
        return a+b+c;
    }
    //实现两个小数相加
    public  static double add(double a, double b){
        return a+b;
    }
}

结果

sum1=5
sum2=9
sum3=4.6

在main方法中调用add()方法时，通过传入不容的参数便可以确定调用哪个重载的方法

可变参数（不定项参数）

jdk1.5开始，java支持传递同类型的可变参数给一个方法。
方法声明中，在指定参数类型后加一个省略号（。。。）。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class Demo10 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax(34,15,44,56,78,34);
        printMax(new double[]{1,3,6,2,8,12});
    }
    public  static void printMax(double... number){
        if (number.length == 0){
            System.out.println("NO argument passed");
            return;
        }
        double result = number[0];

        //排序
        for(int i = 0; i <number.length;i++){
            if (number[i] > result){
                result = number[i];
            }
        }
        System.out.println("The max value is "+ result);
    }
}