本文主要是介绍Java基础02，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Java基础02

JavaDoc生成文档

参数信息：

@author 作者名
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况

生成文档：

javadoc -encoding UTF-8 charset UTF-8 xx.java

Jvm就会根据Java文件中的JavaDoc注释去生成相应的JavaDoc文档

用户交互Scanner类

Scanner类能获取用户的输入

基本语法：Scanner scanner = new Scanner(System.in);，这样就创建了一个scanner对象，

那么我们通过创建的这个scanner对象来获取用户输入通过Scanner类的next()与nextLine()方法获取字符串输入，读取前一般需要用hsaNext()与hasNextLine()判断时候还有数据输入

next() :读取一个字符，其在使用的时候需要注意一下几点：

1. 一定要读取到有效字符后才可以结束输入
2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
3. 只有输入有效字符后才将其后面的空白作为分隔符或结束符
4. next()不能得到带有空格的字符串

 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.next();
        System.out.println(s);
    }

当输入一串空格加字符串后，得到的结果：

当字符之间间隔空格时，得到的结果：

nextLine() :以Enter为结束符，nextline方法返回回车之前的所有字符,可以获取空白：

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        String s = scanner.next();
        String s = scanner.nextLine();
        System.out.println(s);
    }

同样测试当输入一串空格加字符串后，得到的结果：

当字符之间间隔空格时，得到的结果：

Scanner :进阶

我们还可以通过scanner.nextdouble()来获取浮点数输入，nextint来获取整数输入等等...

Java流程控制

顺序结构：

一句一句代码的往下执行，称之为顺序结构

选择结构

1. if单选结构：结构中仅仅包含一个if
2. if双选择结构：if-else结构，与if单选结构相差不大
3. if多选择结构：if-elseif...-else,一旦一个elseif语句为True，则跳过下面所有语句
4. 嵌套if结构：if-if

 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩:");
        //if-elseif-else结构
        while (scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            if(x>60&&x<=100){
                System.out.println("及格");
            }
            else if(x<60&&x>=0){
                System.out.println("不及格");
            }
            else{
                System.out.println("输入数据不合法");
            }
        }


        scanner.close();


    }

5. switch多选择结构：

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入大写等级：");
        String x = scanner.next();
        switch (x){
// 注意：每个case结束后要有break语句，否则会一直执行
            case "A":
                System.out.println("优秀");
                break;
            case  "B":
                System.out.println("合格");
                break;
            case "C":
                System.out.println("一般");
                break;
            default:
                System.out.println("非法输入");
        }
    }

循环结构

1. while循环：while(表达式){} 表达式为True 循环执行
2. do-while循环：do{}while(表达式) 至少执行一次

   public static void main(String[] args) {
        //输出1-20的数
        //while循环
        System.out.println("while方式输出");
        int i = 1;
        int a = 1;
        while (i<=20){
            System.out.println(i);
            i++;
        }
        System.out.println("------------------------");
        System.out.println("do-while方式输出");
        do{
            System.out.println(a);
            a++;
        }while (a<=20);
    }

二者的区别在于：while先判断后执行，do-while先执行一次后判断

3. for循环：

    public static void main(String[] args) {
        int sum = 0;
        int xsum = 0;
//for循环
        for (int i = 0; i <=100; i++) {
            if(i%2==0){
                sum+=i;
            }
            else{
                xsum+=i;
            }

        }
        System.out.println("偶数和"+sum);
        System.out.println("奇数和"+xsum);
    }

增强for循环：主要用于数组上面的输出之类

    //增强for循环
    public static void main(String[] args) {
        int[] num = new int[]{10,20,30,40};
        for(int i:num){
            System.out.println(i);
        }
    }

方法

方法的定义及调用

修饰符 返回值类型 方法名（参数类型 参数名）{方法体}

public static int add(int a,int b){
     return a+b;
}

方法重载

在一个类中，有相同的函数名，但是形参不同的函数

重载规则

1. 方法名必须相同
2. 参数列表必须不同，个数或类型不同，参数排列顺序不同等
3. 方法的返回类型可以相同也可以不同
4. 仅仅返回类型不同不足以方法重载

方法名称相同时，编译器会根据调用的方法的参数个数，参数类型等去逐个匹配，选择对应的方法，如果匹配失败，则编译器报错。

  public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double x = scanner.nextDouble();
        double y = scanner.nextDouble();
        double z = scanner.nextDouble();
        //两个参数，调用第一个add方法
        double q = add(x,y);
        System.out.println(q);
        //三个参数，调用第二个add方法
        double w = add(x,y,z);
        System.out.println(w);
    }
    public static double add(double a,double b){
        return a+b;
    }
    //方法重载add
    public static double add(double a,double b,double c){
        return (a+b)/c;
    }

递归

一个方法反复调用自己的方法，递归包含两个部分：

1. 递归头：什么时候不调用自身方法，如果没有头则陷入死循环
2. 递归体：什么时候需要调用自身方法

   public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        System.out.println(diGui(i));
    }
    // 使用阶乘来解释递归
    public static  int diGui(int i){
        if (i==1) {
            // 递归头，当i=1时停止调用递归体
            return 1;
        }else {
            // 递归体,反复调用diGui()
            return i*diGui(i-1);
        }
    }

数组

相同类型数据的有序集合，属于引用类型

数组的声明及创建

声明一个数组：变量类型[] 变量名字 = 变量的值

列如：int[] a = {1,2,3}

创建一个数组对象：

int[] a = new int[]

数组初始化的方式

1. 静态初始化：int[] a = {1,2,3,4}
2. 动态初始化：int[] b = new int[10] 然后再一个一个赋值
3. 默认初始化：就是未被初始化的空间都是默认的值

数组的基本特点

1. 数组的长度时确定的，数组一旦被创建，大小就是不可以被改变的了
2. 数组中的元素类型必须相同，不允许出现混合类型
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型
4. 数组变量属于引用类型，数组可以看成是对象，数组中的每个元素相当于该对象的成员变量
5. 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身实在堆中的

Arrays类

数组的工具类java.util.Arrays，Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接通过类名来调用，而不需要new对象

在这里先定义几个数组，方便下面介绍Arrays的一些功能

   int[] a = {1,2,5,35,666,3,876};
        int[] b = {2,4,7,10,999};
        int[] c = {1,2,5,35,666,3,876};

Arrays类的一些常用功能：

1. 给数组赋值，通过fill方法

     // Arrays.fill()将数组a中的所有元素赋值为0
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));
        // 将第二，五个数赋值为6
        Arrays.fill(a,2,5,6);
        System.out.println(Arrays.toString(a));

2. 对数组排序：通过sort方法，升序排序

      // Arrays的sort方法对数组进行排序
        Arrays.sort(a);
        // Arrays.toString()是输出数组的一种方法
        System.out.println(Arrays.toString(a));

3. 比较数组：通过equals方法比较数组中元素是否相等

        // Arrays.equals()比较两个数组是否相等，返回值为Boolean类型
        boolean x = Arrays.equals(a,c);
        System.out.println(x);

4. 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

        Arrays.sort(a);
        // 通过binarySearch方法能对排序好的数组进行二分查找法操作,返回的是要查找的数在排好序数组中的下标
        Arrays.binarySearch(a,666);
        System.out.println(Arrays.binarySearch(a,666));

这篇关于Java基础02的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！