零基础学Java笔记三

方法重载

定义：所谓“方法重载”就是指多个方法的方法名相同，但是参数列表不同

参数列表

参数列表不同包括：
1.参数个数不同
2.参数类型不同
3.参数的多类型顺序不同

注意事项

1.方法重载与参数名无关
2.方法重载与方法的返回值类型无关

package com.company.method;

/**
 * 方法重载：即多个方法的方法名相同，参数列表不同
 *  参数列表不同：1.参数的个数不同
 *               2.参数的类型不同
 *               3.参数的多类型顺序不同
 *  方法重载与什么无关？
 *  1.与参数的名称无关
 *  2.与方法的返回值类型无关
 * 
 */
public class MethodOverLoad2 {
    public static void main(String[] args) {
        //参数个数不同
        System.out.println(sum1(1,2));
        System.out.println(sum1(1,2,3));
        //参数类型不同
        System.out.println(sum2(1,2.3));
        System.out.println(sum2(1,2));
        //参数的多类型顺序不同
        System.out.println(sum3(3.5,2));
        System.out.println(sum3(2,5.5));
    }
    //参数个数不同
    public static int sum1(int a, int b){
        return a + b;
    }
    public static int sum1(int a,int b, int c){
        return a + b + c;
    }
    //参数类型不同
    public static int sum2(int m,double n){
        return (int) (m+n);
    }
    public static int sum2(int m,int n){
        return m+n;
    }
    //参数的多类型顺序不同
    public static double sum3(int x,double y){
        return x+y;
    }
    public static double sum3(double x,int y){
        return x+y;
    }
}

数组

1.初始数组

1.1概念

数组相当于一个容器，可以同时存放多个数据值

1.2特点

1.数组是一种引用的数据类型
2.数组当中的多个数据，类型必须保持一致
3.数组的长度在程序运行期间不可以改变

2.初始化数组

2.1动态初始化【指定数组的长度】

格式：数据类型[] 数组名称 = new 数据类型[数组长度]

2.2静态初始化【指定数组的内容】

格式1：数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，元素，...}
格式2：数据类型[] 数组名称 =

package array;

/**
 * 动态初始化和静态初始化都可以拆成两个步骤
 * 但是！
 * 当静态初始化用的是省略模式的时候，不可以拆分成两个步骤
 */
public class ArrayChapter08 {
    public static void main(String[] args) {
        //动态初始化:指定数组长度，不指定数组内容
        int[] arrayA ;
        arrayA = new int[5];
        //标准式静态初始化：指定数组内容
        String[] arrayB ;
        arrayB = new String[] {"hello","lucky","fighting"};
        //省略式静态初始化
        double[] arrayC = {1.2,3.4,5.6};
    }
}

3.访问数组

package array;

/**
 * 动态初始化和静态初始化都可以拆成两个步骤
 * 但是！
 * 当静态初始化用的是省略模式的时候，不可以拆分成两个步骤
 */
public class ArrayChapter08 {
    public static void main(String[] args) {
        //动态初始化:指定数组长度，不指定数组内容
        int[] arrayA ;
        arrayA = new int[5];
        //标准式静态初始化：指定数组内容
        String[] arrayB ;
        arrayB = new String[] {"hello","lucky","fighting"};
        //省略式静态初始化
        double[] arrayC = {1.2,3.4,5.6};
        //直接打印该数组
        System.out.println(arrayA);//直接打印数组名，得到的是一个内存地址[I@1b6d3586
        //按索引号遍历数组
        System.out.println(arrayB[0]); //hello
        System.out.println(arrayB[1]); //lucky
        System.out.println(arrayB[2]); //fighting
        //索引值是从0开始的，超出索引值会报错Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
       //System.out.println(arrayB[3]);
        System.out.println("================");
        //for循环遍历数组
        for (int i = 0; i < 3; i++) {
            System.out.println(arrayB[i]);
        }
        System.out.println("================");
        for (int i = 0; i < 3; i++) {
            System.out.println(arrayA[i]); //得到的全是0
            /*1.动态初始化数组的时候，数组中的元素会默认拥有一个默认值
            * 整型数组，元素默认值是0
            * 浮点型数组，元素默认值是0.0
            * 字符型数组，元素默认是'\u0000'
            * 布尔型数组，元素默认是false
            * 引用型数组，元素默认是null
            * 2.静态初始化数组，一开始也是有元素默认值的过程，但是系统会立刻马上再将元素的默认值替换成大括号里我们指定好的值
            */
        }


    }
}

4.获取数组的长度

格式：数组名称.length
这将会得到一个int数字，代表数组的长度

int[] arrayD = new int[5];
System.out.println(arrayD.length); //获取数组的长度，得到5

5.java的内存需要划分成为5个部分

6.有关数组的小练习

package array;

/**
 * 要求遍历数组，找到它的最大值
 */
public class ArrayChapter09 {
    public static void main(String[] args) {
        int[] arrayA = new int[]{23,45,12,78,54,33,99};
        int max_num = arrayA[0]; //暂且将0号元素赋给max_num
        for (int i = 1; i < arrayA.length; i++) {
            if (arrayA[i] > max_num){
                max_num = arrayA[i];
            }
        }
        System.out.println("the max num is : "+max_num);
    }
}