Java 03

最新推荐文章于 2024-09-13 21:40:38 发布

不会编程的小小怪

最新推荐文章于 2024-09-13 21:40:38 发布

阅读量93

点赞数

分类专栏： Java 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_54357806/article/details/129113378

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.方法

完成特定功能的代码块

语句定义格式：

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

名词解释：

修饰符：对方法所施加的权限修饰，目前我们还没有讲到修饰符的概念，所以现在这两天只需要记住一种修饰写法：public static
    其余的修饰符写法，我们说到面向对象的时候细讲
返回值类型：分为两类，一类是有返回值，一类是无返回值，类型是由方法中是否有return决定的
方法名：只是一个名字而已，但是要遵循标识符的命名规则，并且要见名知意 eat()  sleep()
参数:实参，形参
    形参：在方法定义时的参数名
    实参：在方法调用时传入真正的值
参数类型：
    顾名思义就是要传值的数据类型
参数名：
    就是一个变量名，要遵循标识符的命名规则
函数体：
    要实现方法的主体内容代码
return：
    如果方法有返回值，就用return来返回，return用于结束整个方法
返回值：
    如果方法有返回值，用return将返回值返回给调用者。

注意事项：

1、方法与方法是一个平级关系，不允许嵌套定义
2、方法不调用不执行   
3、如果要定义一个没有返回值的方法，返回值类型用一个关键字代替：void

实例：

import java.util.Scanner;

//返回两个数中的最大值
//判断俩个数是否相等
//求三个数中的最大值
public class Functiontest1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数字a1:");
        int a1 = sc.nextInt();
        System.out.println("请输入第二个数字a2:");
        int a2 = sc.nextInt();
        System.out.println("请输入第三个数字a3:");
        int a3 = sc.nextInt();
        System.out.println("a1,a2最大值为:" + maxNum(a1, a2));
        System.out.println("----------------------------------------");
        System.out.println("a1,a2二者是否相等:" + isEqual(a1, a2));
        System.out.println("----------------------------------------");
        System.out.println("a1,a2,a3最大值为:" + maxNum3(a1, a2, a3));

    }

    public static int maxNum(int a1, int a2) {
        if (a1 > a2) {
            return a1;
        } else {
            return a2;
        }
    }

    public static boolean isEqual(int a1, int a2) {
        return a1 == a2;
    }

    public static int maxNum3(int a1, int a2, int a3) {
        if (a1 > a2) {
            if (a1 > a3) {
                return a1;
            } else {
                return a3;
            }
        } else {
            if (a2 > a3) {
                return a2;
            } else {
                return a3;
            }
        }
    }
}

方法的重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

特点

与返回值类型无关，只看方法名和参数列表在调用时，JVM通过参数列表的不同来区分同名方法

实例

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

        int a = 3;
        int b = 4;
        int c = 5;
        byte d = 6;
        float e = 12.34F;

        //求两个数之和
        System.out.println(sum(a, b));

        //求三个数之和
        System.out.println(sum(a, b, d));

        System.out.println(sum(a,b,e));


    }
    public static float sum(int a1, int b1, float c1) {
        return a1 + b1 + c1;
    }


    public static int sum(int a1, int b1, byte c1) {
        return a1 + b1 + c1;
    }


    public static int sum(int a1, int b1) {
        return a1 + b1;
    }

//    public static long sum1(int a1, int b1) {
//        return a1 + b1;
//    }
}

1、基本数据类型当作方法的实参传入的时候，方法内部的变化，与方法外部的变量值不受影响
2、引用数据类型当作方法的实参传入的时候，传入的是地址值，方法内部的变化会影响到地址值真正对应的空间值，
    所以外部的引用数据类型变量的值会发生变化

2.数组

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

语句定义格式：

1、数据类型[] 数组名
         举例：int[] arr;  这里的数组名其实就是一个变量的名，符合标识符的命名规则
     2、数据类型 数组名[]
         举例：int arr[];
注意事项:
     推荐使用第一种定义格式，可读性更强，早期的时候很多人使用第二种格式，现在趋向于第一种格式

2.1 初始化

所谓初始化其实就是对数组在内存中开辟一个连续的内存空间并对每个元素分配值。

2.1.1 动态初始化

动态初始化：
    初始化时只指定数组长度，由系统为数组分配初始值
    默认值是多少？不同的元素数据类型默认值都一样吗？如果不一样分别是什么呢？

int默认值为0 float，double默认值为0.0 String char初始化为null

语句定义格式：
    数据类型[] 数组名 = new 数据类型[数组的长度]
    举例：创建长度为5，存储的是int类型元素的数组
    int[] arr = new int[5];

访问数组名，打印的是其地址

2.1.2 静态初始化

初始化时指定每个数组元素的初始值，由系统决定数组长度。

语句定义格式：元素的数据类型[] 数组名 = new 元素的数据类型[]{元素1,元素2.....}
简化写法：元素的数据类型[] 数组名 = {元素1,元素2.....}

例：

int[] arr = new int[]{11,22,33,44};
int[] arr = {11,22,33,44};

2.1.3 实例

1.数组遍历

import java.util.Arrays;
//数组遍历
public class Arraytest01 {
    public static void main(String[] args) {
        int[] array1=new int[]{11,22,33,55,33,552,532,17};
        for(int i=0;i<array1.length;i++){
            System.out.print(array1[i]+"\t");
        }
        
    }
}

2.数组获取最值(获取数组中的最大值最小值)


public class Arraytest02 {
    public static void main(String[] args) {
        int[] arr1={55,99,37,16,4,66,299};
        int max_arr=getMaxNum(arr1);
        System.out.println("最大值为:"+max_arr);
        int min_arr=getMinNum(arr1);
        System.out.println("最小值为:"+min_arr);
    }

    public static int getMaxNum(int[] arr1){
        int max=arr1[0];
        for(int i=1;i<arr1.length;i++){
            if(max<arr1[i]){
                max=arr1[i];
            }
        }
        return max;
    }

    public static int getMinNum(int[] arr1){
        int min=arr1[0];
        for(int i=1;i<arr1.length;i++){
            if(min>arr1[i]){
                min=arr1[i];
            }
        }
        return min;
    }

}

3.数组元素逆序 (就是把元素对调)

import java.util.Arrays;


public class Arraytest03 {
    public static void main(String[] args) {
        int[] arr={55,99,37,16,4,66,299};
        System.out.println("初始数组："+ Arrays.toString(arr));
        sortReverse(arr);
        System.out.println("逆序后为："+Arrays.toString(arr));
    }

    public static void sortReverse(int[] arr){
        for(int i=0;i<arr.length/2;i++){
            int temp=arr[i];
            arr[i]=arr[arr.length-1-i];
            arr[arr.length-1-i]=temp;
        }
    }
}

4.数组查表法(根据键盘录入索引,查找对应星期)

import java.util.Scanner;

public class Arraytest04 {
    public static void main(String[] args) {
        String[] week={"星期一","星期二","星期三","星期四","星期五","星期六","星期七"};
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入索引:");
        int index=sc.nextInt();
        System.out.println("索引对应:"+week[index-1]);
    }
}

5.数组元素查找(查找指定元素第一次在数组中出现的索引)

import java.util.Scanner;

public class Arraytest05 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入要查找的值:");
        int value=sc.nextInt();
        int[] arr={11,22,33,55,33,552,532,17};
        for(int i=1;i<arr.length;i++){
            if(arr[i]==value){
                System.out.println("指定元素第一次在数组中出现的索引:"+i);
                break;
            }
            else if(i==arr.length-1){
                System.out.println("数组中无此元素。");
            }
        }
    }
}

2.2 数组操作常见的两个小问题

数组索引越界 ArrayIndexOutOfBoundsException 访问到了数组中的不存在的索引时发生。

空指针异常 NullPointerException 数组引用没有指向实体，却在操作实体中的元素时。

2.3 二维数组

其实就是元素为一维数组的数组

语句定义格式

数据类型[][] 变量名 = new 数据类型[m][n];
   举例：
       int[][] arr = new int[3][2];
       表示定义了一个二维数组，二维数组中有3个一维数组，每个一维数组的长度为2，每个一维数组中的元素数据类型是int类型

今后可能会遇到的其他二维数组的格式：
   int[] arr[] = new int[3][3];
   int arr[][] = new int[3][3];
   int arr [] [] = new int[3][3];
   int [] [] arr = new int[3][2];

二维数组中第二种格式：
    数据类型[][] 数组名 = new 数据类型[m][];
    m代表的是有多少个一维数组。
    后续将创建一维数组进行赋值

public class Array2Demo2 {
    public static void main(String[] args) {
        //数加有3个班级，1班有3个人，2班有4个人，3班有5
        //使用二维数组进行表示
        int[][] arr = new int[3][];
        //创建1班的一维数组赋值到二维数组中
        arr[0] = new int[]{11,22,33};
        //2班
        arr[1] = new int[]{100,200,300,400};
        //3班
        arr[2] = new int[]{1,2,3,4,5};

    }
}

二维数组创建的第三种格式：
    在创建的同时给值
    数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2},{...},{......}

public class Array2Demo3 {
    public static void main(String[] args) {
        //创建二维数组存储每个季度的值
        int[][] gongsi = new int[][]{{22, 66, 44}, {77, 33, 88}, {25, 35, 65}, {11, 66, 99}};

        //定义一个sum变量接收和
        int sum = 0;
        for (int i = 0; i < gongsi.length; i++) {
            for (int j = 0; j < gongsi[i].length; j++) {
                sum += gongsi[i][j];
            }
        }

        System.out.println("该公司年销售总额为：" + sum + "万元");

        

    }
}