Java之路 - 方法、重载、数组

1.方法

定义位置,类中方法外面。
返回值类型,必须要和 return 语句返回的类型相同,否则编译失败 。

三种调用方法:单独调用、打印调用、赋值调用

此前定义的void类型只能单独调用,不能打印调用和赋值调用

打印调用:

 

public class FunctionPart {
    public static void main(String[] args) {
        System.out.println(getSum(3, 8));
    }

    public static int getSum(int x, int y) {
        int result = x + y;
        return result;
    }
}

 

赋值调用:

public class FunctionPart {
    public static void main(String[] args) {
        int result = getSum(3, 8);
        System.out.println(result);
    }

    public static int getSum(int x, int y) {
        int result = x + y;
        return result;
    }
}

 

练习一:判断两个数字是否相同

//练习一:判断两个数字是否相同
public class FunctionPart {
    public static void main(String[] args) {
        boolean result = isSame(10,12);
        System.out.println(result);
    }
    public static boolean isSame(int x,int y){
        //第一种方法
        /*if (x == y){
            return true;
        }else{
            return false;
        }*/
        //第二种方法
       /* boolean same;
        same = x == y ? true : false;
        return same;*/
       //第三种方法
        /*boolean same;
        same = x == y;
        return same;*/
        //第四种方法
        return x == y;
    }
}
判断两个数字是否相同

 

 

练习二:求出1-100的和

//练习二:求出1-100之间所有数字的和
public class FunctionPart {
    public static void main(String[] args) {
        System.out.println(sumNum(1, 100));

    }

    public static int sumNum(int start, int end) {
        int sum = 0;
        for (int i = start; i <= end; i++) {
            sum += i;
        }
        return sum;
    }
}
升级版,给定起始值和结束值返回结果

 

 

练习三:打印指定次数的helloworld

//打印指定次数的helloword
public class FunctionPart{
    public static void main(String[] args) {
        printHw(10);
    }
    public static void printHw(int times){
        for (int i = 1; i <= times; i++) {
            System.out.println("Hello Word" + i);
        }
        System.out.println();
    }
}
打印指定次数的helloworld

 

2.方法的重载(overload)

方法重载:指在同一个类中,允许存在一个以上的同名方法,只要它们的参数列表不同即可,与修饰符和返回值类型无关。!!!
参数列表:个数不同,数据类型不同,顺序不同。

如:

public static int getSum(int a, int b) {
        return a + b;
    }
    public static int getSum(int a, double b) {
        return (int) (a + b);
    }
    public static int getSum(double a, int b) {
        return (int) (a + b);
    }

 


重载方法调用:JVM通过方法的参数列表,调用不同的方法。

//方法的重载
public class FunctionPart {
    public static void main(String[] args) {
        System.out.println("输出结果为" + getSum(3, 9));
        System.out.println("输出结果为" + getSum(3, 9,2));
        System.out.println("输出结果为" + getSum(3, 9,5,7));
    }

    public static int getSum(int a, int b) {
        return a + b;
    }
    public static int getSum(int a, int b, int c) {
        return a + b + c;
    }
    public static int getSum(int a, int b, int c, int d) {
        return a + b + c + d;
    }
}

 

 

练习一:四种数据类型判断是否相同

//判断两个数据是否相等
public class FunctionPart {
    public static void main(String[] args) {
        int a = 10;
        int b = 12;
        System.out.println(isSame(a,b));
        System.out.println(isSame((short)a , (short) b));
        System.out.println(isSame((byte) a , (byte) b));
        System.out.println(isSame((long) a , (long) b));
    }

    public static boolean isSame(byte a, byte b) {
        if (a == b) {
            return true;
        } else {
            return false;
        }

    }

    public static boolean isSame(short a, short b) {
        return a == b;
    }

    public static boolean isSame(long a, long b) {
        return a == b;
    }

    public static boolean isSame(int a, int b) {
        return a == b;
    }
}
判断是否相同

 

 3.数组 引用类型

数组定义格式详解:
  数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
  [ ] : 表示数组。
    数组名字:为定义的数组起个变量名,满足标识符规范,可以使用名字操作数组。
  new:关键字,创建数组使用的关键字。
  数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
  [长度]:数组的长度,表示数组容器中可以存储多少个元素。
  注意:数组有定长特性,长度一旦指定,不可更改。

动态初始化:

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

 

静态初始化:

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

 

三种格式:

public class ArrayPart {
    int [] arrary = new int [3];
    int [] arrary1 = new int [] {1,3,4};
    int [] arrary2 = {1,2,3,4};

}

 

注意:如果使用动态初始化数组时,且为空时,会默认拥有一个默认值,规则如下:

1.如果是整数(四种整数)类型,那么默认为0;

2.如果是浮点类型,那么默认为0.0;

3.如果是字符类型,那么默认为 '\u0000'(字符类型默认值 );  输出时看不见

4.如果是布尔类型,那么默认为false;

5.如果是引用类型,那么默认为 null;

静态初始化其实也有默认值的过程,只不过系统马上将默认值替换成为了大括号里的具体数值;

4.java内存的划分 - 共5个部分

1.栈(Stack):存放的都是方法中的局部变量  ,方法的运行一定在栈当中

   局部变量:方法的参数,或者是方法{}内部的变量  

   作用域:一旦超出作用域,立刻从栈内存当中消失

2.堆(Heap):凡是new出来的东西都在堆当中

  堆内存里面的东西都有一个地址值(地址值也是个变量,存在栈当中):16进制

  堆内存里的数据都有默认值

3.方法区(Method Area):存储 .class相关信息,包含方法的信息。

4.本地方法栈(Native Method Stack):与操作系统相关

5.寄存器(pc Register):与CPU相关

 

注意!!!!:数组一旦创建,程序运行期间,长度不可改变

如下:

public class ArrayPart {
    public static void main(String[] args) {
        int[] array1 = new int[]{1,3,5};
        System.out.println(array1.length);
        array1 = new int[5];
        System.out.println(array1.length);
        System.out.println(array1[1]);
    }
}

此时array1并不是被扩展了,而是产生了一个新的实体数组,内存地址改变了,所以array[1]的输出值为0,而不是原来那个数组的3

内存图:

 

 

遍历输出数组:

public class ArrayPart {
    public static void main(String[] args) {
        int[] array1 = new int[]{1, 3, 5,10};
        for (int i =0; i < array1.length;i++){
            System.out.println(array1[i]);
        }
    }
}

 

数组元素反转练习:

 

 

代码实现:

//数组元素反转
public class ArrayPart {
    public static void main(String[] args) {
        int[] array = {2, 5, 6, 8, 2, 7};
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min]; //通过一个空变量来做两者的值交换
            array[min] = array[max];
            array[max] = temp;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

 

a

a

a

a

 

posted @ 2020-04-07 15:41  五号世界  阅读(240)  评论(0编辑  收藏  举报