JavaLearn Day2

JavaLearn Day2

方法重载

1.方法重载的基本使用以及注意事项

package learn.xin.day2;
/*
对于功能类似的方法来说，因为参数不一样，却需要记住那么多不同的方法名称，太麻烦。

方法的重载（Overload） 方法的名称一样，但是参数列表不一样

好处：只需要记住一个方法名称就可以实现多个类似的多个功能。

方法重载与下列因素有关：
1、参数个数不同
2、参数类型不同
3、参数的多类型顺序不同

方法重载与下列因素无关：
1、与参数的名称无关
2、与方法的返回值类型无关

 */
public class MethodOverload {
    public static void main(String[] args) {
/*        System.out.println(sumTwo(10,20)); //30
        System.out.println(sumThree(10,20,30)); //60
        System.out.println(sumFour(10,10,10,10)); //40

        太麻烦！！！*/

        System.out.println(sum(10,20));//两个参数
        System.out.println(sum(10,10,10));//三个参数
        System.out.println(sum(10,10,10,10));//四个参数
    }
    public static int sum(double a,int b){
        return (int) ( a + b );  //有关第三点例子
    }
    public static int sum(int a,double b){
        return (int) ( a + b );  //有关第三点例子
    }

    public static int sum(double a,double b){
        return (int) ( a + b );  //有关第二点例子
    }

    public static int sum(int a,int b){
        System.out.println("有两个参数的方法!!");
        return a + b;
    }
    
    /*public static int sum(int x,int y){
        return x + y;*/ //错误写法!! 与参数的名称无关
    
    public static int sum(int a,int b,int c){
        System.out.println("有三个参数的方法!!");
        return a + b + c;
    }
    public static int sum(int a,int b,int c,int d){
        System.out.println("有四个参数的方法!!");
        return a + b + c + d;
    }
}

2.重载练习

（1）

package learn.xin.day2;
/*
比较两个数据是否相等，
参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，
并在main方法中进行测试
*/
public class MethodOverloadSame {
    public static void main(String[] args) {
         byte a=11;
         byte b =12;
        System.out.println(isSame(a,b));
    }
    public static boolean isSame(byte a,byte b){
        System.out.println("两个byte的方法运行啦！！！");
        boolean same;
        if (a == b){
            same = true;
        }else {
            same = false;
        }
        return same;
    }

    public static boolean isSame(short a,short b){
        System.out.println("两个short的方法运行啦！！！");
        boolean same = a == b ? true : false;

        return same;
    }

    public static boolean isSame(int a,int b){
        System.out.println("两个int的方法运行啦！！！");
        return a == b;
    }

    public static boolean isSame(long a,long b){
        System.out.println("两个long的方法运行啦！！！");
        if (a == b){
            return true;
        }else {
            return false;
        }
    }
}

二、数组

1.数组的概念

数组的概念： 是一种容器，可以同时存放多个数据值。

数组的特点:

1.数组是一种引用数据类型

2.数组当中的多个数据，类型必须统一

3.数组的长度在程序运行期间不可改变

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式：

1.动态初始化 (指定长度)

2.静态初始化（指定内容）

2.数组的定义格式

1_动态初始化

package learn.xin.day2;
/*
动态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[数组长度]；

解析含义：
左侧数据类型 也就是 数组当中保存的数据，全都是统一的什么类型
左侧的中括号 代表我是一个数组
左侧数组名称 给数组取名
右侧的new 代表创建数组的动作
右侧数据类型 必须和左侧的数据类型保持一致
右侧中括号的长度 也就是数组当中 到底可以保存多少个数据， 是一个int数字

*/
public class Array {
    public static void main(String[] args) {
        //创建一个数组，里面可以放300个int数据
        int[] arrayA = new int[300];
        double[] arryB = new double[10];
        String[] arrayC = new String[10];
    }
}

2.静态初始化

package learn.xin.day2;
/*
动态初始化 创建数组的时候，直接指定数组当中的数据元素个数
静态初始化 创建数组的时候，不直接指定数组个数多少，而是直接将具体数据内容进行指定

静态初始化基本格式：
数据类型[] 数组名称 = new 数据类型[] {元素1，元素2……   }；

 注意事项：
 虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来。

 省略格式！！！
 数据类型[] 数组名称 = {元素1，元素2……   }；
 
 注意事项；
 1 静态初始化标准格式可以拆分为两个步骤
 int[] arraycc;
 arraycc = new int[]{    };
 
 2 动态初始化可以拆分为两个步骤；
 int[] arrayccc;
 arrayccc = new int []{   };
 
3 静态初始化一旦使用省略格式， 就不能拆分为两个步骤了。

使用建议！！
如果不确定数组中的具体内容， 用动态初始化；
否则，已经确定了具体内容，用静态初始化。
*/
public class Array2 {
    public static void main(String[] args) {
        int[] arrayA = new int[] {2,3,4,5,6,7};
        String[] arrayB = new String[]{"NiHao","SB","Good Morning"};

        int[] arrayC ={10,20,30};//省略格式
        
        
    }
}

3.访问数组元素进行获取和赋值

package learn.xin.day2;
/*
直接打印数组名称 得到的是数组对应的：内存地址哈希值。

访问数组元素的格式   数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素的编号
【注意】索引值从0开始，一直到数组长度的-1为止

使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值，规则如下：
如果是整数类型，那么默认为0
如果是浮点类型，那么默认为0.0
如果是字符类型，那么默认为'\u0000'
如果是布尔类型，那么默认为false
如果是引用类型，那么默认为null

注意事项
静态初始化其实也有默认值的过程，只不过系统自当将默认值替换成了{}中的具体数值。
*/
public class ArrayUse {
    public static void main(String[] args) {
        int[] arrayA = {10,20,30};
        int[] arrayB = new int[10];
        System.out.println(arrayA);//[I@5fd0d5ae
        System.out.println(arrayA[0]); //10

        int num = arrayA[0];
        System.out.println(num);
        System.out.println("xxxxxxxxxxxxxxxxxx");

        arrayB[0] = 123; //将123赋值给0号元素
        System.out.println(arrayB[0]);


    }
}

4.数组的常见问题_数组索引越界异常 空指针异常

如果访问数组元素的时候，索引编号不存在，那么将会发生
数组索引越界异常
ArrayIndexOutOfBoundsException

原因：索引编号写错了
解决：修改成为存在的正确索引编号

package learn.xin.day2;
/*
  所有的引用类型都可以赋值为一个null 但是代表其中什么都没有。
  
  数组必须进行new初始化才能使用其中的元素
  如果只是赋值一个null,没有进行new创建
  那么将会发生：
  空指针异常 NullPointerException
  
  原因：没有new
  解决方法：补上new
  */
public class ArrayNull {

    public static void main(String[] args) {
        int[] Array = null;
//        Array = new int[3];
        System.out.println(Array[2]);
    }
}

4.获取数组的长度

package learn.xin.day2;
/*
如何获取数组的长度 格式
数组名称.length

这将会得到一个int数字，代表数组的长度。
数组一旦创建，程序运行期间，长度不可改变。
*/
public class ArrayLength {
    public static void main(String[] args) {
        int[] arrayA = new int[3];
        int[] arrayB = {1,2,3,4,5};
        int length = arrayB.length;
        System.out.println("数组B的长度是"+length);
    }
}

5.数组的遍历输出

package learn.xin.day2;
/*
遍历数组：说的就是对数组当中的每一个元素进行逐一、挨个儿处理。默认的处理方式就是打印输出。
*/
public class Array3 {
    public static void main(String[] args) {
        int[] arrayA = {10,20,30,40,50};
        //使用循环，次数就是数组的长度。
        for (int y = 0;y < 5;  y++) {
            System.out.println(arrayA[y]);

        }
        System.out.println("xxxxxxxxxxxxxxxxxxxxxxx");
        
        
        //int len = arrayA.length;
        for (int h = 0;h < arrayA.length;  h++){
            System.out.println(arrayA[h]);
        }
    }

}

6.求出数组中的最值

最大值：

package learn.xin.day2;

public class ArrayMax {
    public static void main(String[] args) {
        int[] arrayA = {100,200,300,400,500,2000};
        int max = arrayA[0];
        for(int i =1 ; i < arrayA.length; i ++){
            if(arrayA[i]>max){
                max = arrayA[i];
            }
        }

        System.out.println("最大值："+ max);
    }
}

最小值：

package learn.xin.day2;

public class ArrayMin {
    public static void main(String[] args) {
        int[] arrayA = {100,200,300,400,500,2000};
        int min = arrayA[0];
        for(int i =1 ; i < arrayA.length; i ++){
            if(arrayA[i] < min){
                min = arrayA[i];
            }
        }

        System.out.println("最小值："+ min);
    }
}

7.数组元素翻转

package learn.xin.day2;

import org.w3c.dom.ls.LSOutput;

/*
数组元素的翻转
本来的样子{1,2,3,4,5,6}
之后的样子{6,5,4,3,2，1}

不能使用新数组，就用原本的唯一一个数组。
 */
public class ArrayReverse {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxx");
        /*
        初始化语句： int min = 0 , int max = array.length - 1
        条件判断：min<max
        步进表达式 min++  max--
        循环体：用三个变量
         */
        for(int min = 0, max = array.length - 1; min < max ; min++,max--){
            int x = array[min];
            array[min] = array[max];
            array[max] = x;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

8.数组作为方法参数

package learn.xin.day2;
/*
数组可以作为方法的参数
当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。
 */
public class ArrayParam {
    public static void main(String[] args) {
        int [] array = {1,2,3,4,5};
        printArray(array);
        System.out.println("xxxxxxxx");
        printArray(array);
        System.out.println("cccccccc");


    }

    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

9.数组作为方法返回值_返回地址

package learn.xin.day2;

/*
一个方法可以有多个参数，但是只能有0或者1个返回值，不能有多个返回值。

如果希望一个方法中产生了多个数据进行返回，
那么使用一个数组作为返回值类型即可。

任何数据类型都能作为方法的参数类型，或者返回值类型。
数组作为方法的参数，传递进去的其实是数组的地址值。
数组作为方法的返回值，返回的也是数组的地址值。
 */
public class ArrayReturn {
    public static void main(String[] args) {
        int[] result = math(1,2,3);
        System.out.println("总和：" + result[0]);
        System.out.println("平均数：" + result[1]);
    }
    public static int[] math(int a,int b,int c){
        int sum = a + b + c;
        int avg = sum / 3;

        //两个结果都希望进行返回
        //需要一个数组，数组可以保存多个结果
        /*int[] array = new int[];
        array[0] = sum;
        array[1] = avg;*/
        int[] array = {sum, avg };

        return array;
    }
}