java自学 2020.5.14总结

一周总结

java内存划分

数组

/*
数组的特点
1.数组是一种引用数据类型
2.数组当中的多个数据，类型必须统一
3.数组的长度在程序运行期间不可改变

两种常见的初始化类型
1.静态初始化（指定内容）
2.动态初始化（指定长度）

数组动态初始化格式：
数据类型[]数组名称 = new 数据类[数组长度]；

含义：
左侧数据类型，就是数组中的保存的数据
左侧的中括号，代表我是一个数组
左侧数组名称，给数组取一个名字
右侧的new；代表创建数组的动作
右侧数据类型；必须和左侧的数据类型一样
右侧的中括号长度，也就是数组当中，到底可以保存多少个数据，是一个int数字
 */
public class Demo05Array {
    public static void main(String[] args) {
        //创建一个数组，里面存放300个int数据
        //格式：数据类型[]数组名称 = new 数据类[数组长度]；
        int[] arrayA = new int[300];

        //创建一个数组，存放10个double数据类型
        double[] arrayB = new double[10];

        //创建一个数组，存放5个字符串
        String[] arrayC = new String[5];

    }
}

数组的（静态，动态）初始化

/*
动态初始化：在创建数组时候，直接指定数组中数据元素个数
静态初始化：在创建数组时候，不直接指定数组中数据元素个数，而是直接将具体的数据内容进行指定。

静态初始化格式：
数据类型[]数组名称 = new 数据类型[]{ 元素1，元素2，... }；
注意事项：
虽然静态初始化没有直接告诉长度，但是根据内容，可以自行推算出长度。
 */
public class Demo06Array {
    public static void main(String[] args) {
        //直接创建一个数组里面装的全是int数字，具体为5、15、25
        int[] arrayA = new int[]{5,10,25};

        //创建一个数组，用来装字符串：“Hello”“World”
        String[] arrayB = new String[]{"Hello","World"};
    }
}

数组注意事项

package wmr.day0506.demo02;
/*
数据类型[]数组名称 = new 数据类型[]{ 元素1，元素2，... }；

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

注意：
1.没有指定会自动推算。
2.静态初始化，可以拆分为两个步骤。
3.动态初始化也可以拆分为两个步骤。
4.静态初始化使用省略格式，不可拆分
使用建议：
如果不确定数组中的内容，用动态初始化；否则用静态初始化
 */
public class Demo07Array {
    public static void main(String[] args) {
        //省略格式的静态初始化
        int[] arrayA = {10,20,30};

        //静态初始化可拆分
        int[] arrayB;
        arrayB = new int[]{11,12,13};

        //动态初始化可拆分
        int[] arrayC;
        arrayC = new int[]{5};

        //静态不可以拆分
//        int[] arrayD;
//        arrayD = {10,20,30};
    }
}

package wmr.day0506.demo02;

/*
访问数组元素格式：数组名称【索引值】
索引值：就是一个int，代表数组当中元素的编号
【注意】索引值从0开始一直到“数组长度的-1”为止。
 */
public class Demo08ArrayUse {
    public static void main(String[] args) {
        //静态初始化省略格式
        int[] array = {10,20,30};
        System.out.println(array);//[I@58ceff1

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

        int num = array[1];
        System.out.println(num);
    }
}

一个数组的内存图

数组元素反转

package wmr.day0506.demo02;
/*
数组反转
 */
public class Demo10ArrayRevers {
    public static void main(String[] args) {
        int[] array = {10,20,30,40,50};

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

        /*
        初始化语句:int min = 0,max = array.length - 1
        条件判断:min < max
        步进表达式:min++,max--
        循环体：
         */
        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]);
        }
    }
}

数组作为方法参数

package wmr.day0506.demo04;
/*
数组可以作为方法的参数
调用方法时，小括号进行传参，进去的是地址值
 */
public class Demo01ArrayParam {
    public static void main(String[] args) {
        int[] array ={10,20,30,40,50};
       printArray(array);
        System.out.println("================aaa=========");
        printArray(array);
        System.out.println("===========bbb=========");
        }

    /*
    三要素
    返回值类型：只是进行打印，不需要计算，也没有结果用void
    方法名称：printArray
    参数列表:必须给我数组，我才能打印其中的元素，int[] array
     */
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

方法的重载

package wmr.day0506.demo03;
/*
方法的重载（overload）：多个方法的名称一样，但是参数列表不一样。
好处，只需要记住一个方法名称，就可以实现多个类似的功能

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

方法重载与下列方法无关
1.与参数的名称无关
2.与方法的返回值类型无关
 */
public class Demo01MatherOverload {
    public static void main(String[] args) {

        System.out.println(sum(10,20));//两个参数的方法
        System.out.println(sum(10,20,30));//三个参数的方法

        
    }
    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 a,int b,int c){
        System.out.println("有三个参数的方法执行");
        return a + b + c;

    }
}