JAVA学习第四天

JAVASE

java方法

java方法是语句的集合，它们在一起执行一个功能

方法是解决一类问题的步骤的有序组合

方法包含于类或对象中

方法在程序中被创建，在其他地方被引用

一个方法只完成一个功能

格式： 修饰符 返回值类型 方法名（参数类型 参数名）{

​ 方法体

​ return返回值； // void没有返回值

}

package base03;
​
public class demo01 {
    // main 方法
    public static void main(String[] args) {
        
        // 实际参数
        int sum  = add(1,5);
        System.out.println(sum);
    }
    // 加法
    // 形式参数 用来定义作用的
    public static int add(int a, int b){
        return a + b;
    }
}

package base03;
​
public class demo02 {
    public static void main(String[] args) {
        int a = max(10,10);
        System.out.println(a);
    }
    // 比大小
    public static int max(int num1, int num2){
        int result = 0;
        if (num1 == num2){
            System.out.println("num1 == num2");
            return 0; // 终止方法
        }
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }
}
​

方法调用

调用方法对象名.方法名(实参列表)

方法的重载

重载就是在一个类中有相同的函数名称但是形参不同的函数

规则：方法名必须相同

​ 参数列表必须不同

​ 返回类型都可以

递归

递归就是方法自己调用自己

递归可以将大的复杂的问题转化为规模比较小的问题来解决，减少了代码量

递归头：

递归体：

package base03;
​
public class Demo04 {
    public static void main(String[] args) {
        int a = f(5);
        System.out.println(a);
    }
​
    public static int f(int n){
        if(n==1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}

数组

数组：相同类型的数字的集合

首先声明数组变量，才能在程序中使用数组。

在java 语言中用new操作符来创建数组

数据类型[] 数组名 = new 数据类型[数组长度]；

package base03;
​
public class Demo05 {
​
    // 数组类型  数组名  =  变量的值；
    public static void main(String[] args) {
        int[] nums; //定义数组
       // int nums2[]; // 定义数组 但不常用
        nums = new int[10]; // 存放十个int类型的数字
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
​
        System.out.println(nums[9]);
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }
        System.out.println(sum);
    }
}

数组的初始化：

静态初始化： int[] a = {1,2,3};

​ Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化：int[] a = new int[2];

​ a[0] = 1;

​ a[1] = 2;

数组默认初始化： 数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素被按照实例变量同样的方式被隐式初始化。

package base03;
​
public class Demo06 {
    public static void main(String[] args) {
        // 静态初始化  创建加赋值
        int[] a = {1,2,3,4,5,6,7};
        System.out.println(a[0]);
​
        // 动态初始化
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
​
        //默认初始化的数值为 0
    }
}

数组的特点：

长度确定，一但创建就不可改变

其元素类型相同

数组元素可以是任何类型

数组的变量是引用类型，数组也可以看成是对象

数组对象本身是在堆中

数组使用：

package base03;
​
public class Demo07 {
    public static void main(String[] args) {
        // 遍历数组
        int[] arrays = {1,2,3,4,5};
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("=======================");
        // 查找最大元素
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (arrays[i]>max){
                max = arrays[i];
            }
        }
        System.out.println(max);
    }
}
​

package base03;
​
public class Demo08 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
​
        // 没有下标
        for (int array : arrays) {
            System.out.println(array);
        }
        printArray(arrays);
        int[] a = reverse(arrays);
        printArray(a);
​
    }
​
    // 打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
​
​
        }
    }
​
    // 反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        // 反转
        for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
​
        }
        return result;
    }
}
​

多维数组

package base03;
​
public class Demo09 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        printArray(array[0]);
    }
    // 打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
​
        }
    }
​
}

Arrays类

包含数组的各种方法 都是static修饰的静态方法0

package base03;
​
import java.util.Arrays;
​
public class Demo10 {
    public static void main(String[] args) {
        int[] a = {1,2,5,44444,99,666,7879};
        System.out.println(a); // [I@4554617c
​
        // 打印数组元素
        System.out.println(Arrays.toString(a)); //[1, 2, 5, 8, 99, 666, 7879]
​
        // 数组进行排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        
        // 填充
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序