20200629

方法练习

1.题目要求：定义一个方法用来判断两个数字是否相同

public class Demo01MethodSame {
    public static void main(String[] args) {
        System.out.println(isSame(10,20));
        System.out.println(isSame(10,10));


    }

    public static boolean isSame(int a, int b){

        return a == b;
    }
}

2.题目要求：定义一个方法用来求出1-100之间所有数字的和值

public class Demo01MethodSame {
    public static void main(String[] args) {
        System.out.println("结果是：" + getSum());
    }

    public static int getSum() {
        int sum = 0;
        for (int i = 1; i <=100; i++) {
            sum += i;
        }
        return sum;
    }

}

3.题目要求：定义一个方法用来打印指定次数的HelloWorld

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

        printCount(10);
    }
    public static void printCount(int num){
        for (int i = 1; i <= num; i++) {
            System.out.println("Hello,World!"+ i);
        }
    }
}

方法的注意事项

• 方法应该定义再类当中，但是不能再方法当中再定义方法，不能嵌套
• 方法定义的前后顺序无所谓
• 方法定义之后不会执行，如果希望执行一定要调用：单独调用、打印调用、赋值调用
• 如果方法有返回值，那么必须协商return返回值，不能没有
• return后面的返回值数据，必须和方法的返回值类型对应起来
• 对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己
• 对于void方法当中最后一行的return可以省略不写
• 一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到

方法的重载(OverLoad)

多个方法的名称一样但是参数列表不一样

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

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

        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
    }
    public static int sum(int a, int b){
        System.out.println("有2个参数的方法执行");
        return a + b;
    }
    public static int sum(int a, int b, int c){
        System.out.println("有3个参数的方法执行");
        return  a + b + c;
    }
    public static int sum(int a ,int b, int c, int d){
        System.out.println("有4个参数的方法执行");
        return a + b + c + d;
    }
}

方法重载与下列因素有关：

• 参数个数不同
• 参数类型不同
• 参数的多类型顺序不同

方法重载与下列因素无关

• 与参数的名称无关
• 与方法的返回值类型无关

public class Demo01MethodOverLoadSame {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        System.out.println(isSame(a,b));//两个byte参数的方法执行
                                        //false

        System.out.println(isSame((short)20,(short)20));//两个short参数的方法执行
                                                        //true

        System.out.println(isSame(11,12));//两个int参数的方法执行
                                          //false

        System.out.println(isSame(10L,20L));//两个long参数的方法执行
                                            //true

    }
    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;
        }
    }
}

 

数组

是一种容器，可以同时存放多个数据值

特点：

• 数组是一种引用数据类型
• 数组当中的多个数据类型必须统一
• 数组的长度在程序运行期间不能改变

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

两种常见的初始化方式：

• 动态初始化（指定长度）
• 静态初始化（指定内容）

动态初始化数组的格式：

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

左侧数据类型：也就是数组当中保存的数据全都是统一的类型

左侧的中括号：代表是一个数组

左侧数组名称：给数组取一个名字

右侧的new：代表创建数组的动作

右侧数据类型：必须和左边的数据类型保持一致

右侧中括号的长度：也就是数组当中到底可以保存多少个数据

public class Demo01Arry {
    public static void main(String[] args) {
        int[] arrayA = new int[300];
        
        double[] arrayB = new double[10];
        
        String[] arrayC = new String[5];
    }
}

动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数

静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少而是直接将具体的数据内容进行指定

静态初始化基本格式：

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

public class Demo02Array {
    public static void main(String[] args) {
        int[] arrayA = new int[]{ 5, 15, 25};

        String[] arrayB = new String[]{ "Hello","World", "java"};
    }
}

省略格式：

数据类型 [ ] 数组名称 = {元素1，元素2...}；

public class Demo03Array {
    public static void main(String[] args) {
        int[] arrayA = { 10, 20, 30};
    }
}

注意事项：

• 静态初始化没有直接指定长度，但是仍然会自动推算得到长度
• 静态初始化标准格式可以拆分成为两个步骤

        int [ ]  arrayB;

        arrayB = new int [ ] { 11, 21, 31 } ;

• 动态初始化也可以拆分成为两个步骤

       int [ ] arrayC ;

       arrayC = new int [5] ;

• 静态初始化一旦使用省略格式就不能拆分成两个步骤了

使用建议：如果不确定数组当中的具体内容，用动态初始化

                  已经确定了具体的内容，用静态初始化

访问数组元素格式：数组名称 [ 索引值 ]

索引值：就是一个int数字，代表数组当中元素的编号

【注意】索引值从0开始一直到“数组的长度-1为止”

public class Demo04ArrayUse {
    public static void main(String[] args) {
        int[] array = { 10, 20, 30};

        System.out.println(array);//[I@1540e19d 内存地址值

        System.out.println(array[0]);//10
        System.out.println(array[1]);//20
        System.out.println(array[2]);//30
        
    }
}