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

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