JAVA 基础篇

一、数组 

1、 什么是数组？

 数组和变量差不多，也是可以存放数据的，但是数组可以存放多个数据，而且多个数据的数据类型统一
 格式
 数据类型 [] 数组名称;
 还有一种等效的写法，不推荐
 数据类型 数组名称[];
 变量如果定义好了之后，要想使用，一定要赋值
 数组如果定义好了之后，要想使用一定要初始化
 初始化：就是在内存当中开辟数组的空间，并且赋值一些默认值(准备工作)
 数组的初始化方式有两种：
 1、动态初始化，指定数组的长度
 2、静态初始化，指定数组的内容

 动态初始化：直接指定数组的长度，也就是数组当中到底可以存放多少个数据
 格式一、
 数据类型[] 数组名称=new 数据类型[数组长度];
 解析：
 左侧数据类型：也就是数组当中存放的元素全部都是统一的什么类型
 左侧的[]：代表这个一种数组类型
 数组名称：就是一个自定义的标识符，通过名称，可以使用数组当中的数据
 右侧的new：代表创建动作，内存当中开辟空间，创建数组
 右侧数据类型：一定要和左侧的数据类型一样
 右侧[]当中的数组长度：也就是到底能存放多少个数据
 格式二、
 数据类型[] 数组名称;
 数组名称=new 数据类型[数组长度];

    public static void main(String[] args) {
        //格式一
        int[] array1=new int[2];        
        //格式二
        int[] arrar2;
        arrar2=new int[2];
    }

 2、数组取值：

如何访问数组当中的元素？
如果直接打印数组的名称，那么到底的是地址值(的哈希值 )

如何访问数组当中的一个具体元素呢？格式
数组名称[索引编号]
索引：也就是数组当中多个元素的编号，从0开始，一直到“长度-1”位置

动态初始化的时候，数组当中的元素都会被赋予一个默认值。
规则：
如果整数，默认就是0；如果是浮点数，默认是0.0；如果是字符，默认是'u0000'(Unicode写法)

如果布尔值，默认是false；如果是字符串或其他引用类型，那么是null(空常量)

    public static void main(String[] args) {
        int[] arrayA=new int[3];
        System.out.println(arrayA);//[I@279f2327
        System.out.println(arrayA[0]);
        System.out.println(arrayA[1]);
        System.out.println(arrayA[2]);
    }

 数组在初始化的时候，还有另外一种方式，静态初始化
 静态初始化不会直接指定长度，而是直接指定具体的元素内容
 标准格式
 数据类型[] 数组名称=new 数据类型[]{元素1,元素2};
 标准格式也可以拆分成为两个步骤
 数据类型[] 数组名称;
 数组名称=new 数据类型[]{....};
 简便格式：
 数据类型[] 数组名称={元素1,元素2};
 一旦使用了简便格式，必须一个步骤完成初始化，不能拆分两个步骤

注意事项：

1、虽然静态初始化没有指定长度，但是仍然可以根据具体元素的个数自动推算出来长度

2、虽然简便格式当中可以不写new....，但是仍然有内存当中开辟空间的过程

3、虽然直接指定了具体元素内容，但是仍然会有默认值被替换的过程

    public static void main(String[] args) {
        // 动态初始化
        int[] arrayA = new int[3];
        arrayA[0] = 10;
        arrayA[1] = 15;
        arrayA[2] = 20;
        System.out.println(arrayA[0]);
        System.out.println(arrayA[1]);
        System.out.println(arrayA[2]);
        System.out.println("============");
        // 静态初始化，一个步骤
        int[] arrayB = new int[] { 30, 40, 50 };
        System.out.println(arrayB[0]);
        System.out.println(arrayB[1]);
        System.out.println(arrayB[2]);
        System.out.println("============");
        // 静态初始化，两个步骤
        int[] arrayC;
        arrayC = new int[] { 60, 70, 80 };
        System.out.println(arrayC[0]);
        System.out.println(arrayC[1]);
        System.out.println(arrayC[2]);
        System.out.println("============");
        int[] arrayD= {11,12,13};
        System.out.println(arrayD[0]);
        System.out.println(arrayD[1]);
        System.out.println(arrayD[2]);
    }

3、获取数组长度

无论动态还是静态初始化，数组都具有长度，如何才能获取长度呢？
格式：
数组名称.length
将会得到一个int数字，代表数组的长度
【注意】
一个数组一旦在内存当中创建了，那么数组的长度就不能发生变化

public static void main(String[] args) {
        int[] arrayA= {1,2,3,4,5,6};
        System.out.println(arrayA.length);
    }

4、数组索引越界异常

数组元素的索引编号，从0开始，一直到“长度-1”为止

如果一个数组长度为3，那么元素的编号分别是：0，1,2.没有3号元素的

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

    public static void main(String[] args) {
        int[] arrayA = { 10, 20, 30 };
        System.out.println(arrayA[0]); // 10
        System.out.println(arrayA[1]); // 20
        System.out.println(arrayA[2]); // 30
        System.out.println("数组的长度：" + arrayA.length);
        System.out.println("=====================");
        System.out.println(arrayA[3]); // 编译没有报错，运行就报错！
        System.out.println(arrayA[-1]); // 数组索引从0开始，绝对不可能为负数
    }

5、数组内存示意图

二、JAVA内存分配

1、栈(Stack)：主要用来存放局部变量

2、堆(Heap)：凡是new 出来的东西，都在堆当中。堆当中的数据有默认值规则

　　a)：整数，默认是：0

　　b)：浮点数，默认是：0.0

　　c)：字符，默认是："u0000"(Unicode写法)

　　d)：布尔值，默认是：false

　　e)：引用类型(含字符串)，默认为null(空常量)

3、方法区(Method Area)：存放与class相关的信息

4、本地方法区(Native Method Area)：与操作系统相关

5、寄存器(pc Register)：与CPU相关，性能极高

 三、方法

 格式：

修饰符 返回值类型 方法名称(参数类型 参数名称)

{

　　...方法体

　　return 返回值;

}

解释：

修饰符：目前的固定写法：两个关键字，public static

返回值类型：方法最终产生的数据类型

方法名称：自定义的名称，规则和变量一样

参数类型：进入方法的数据是什么类型

参数名称：进入方法的数据，对应的变量名称

方法体：需要执行的若干行代码

return：有两个作用，第一结束当前方法，第二带着后面的返回值交给调用处

返回值：方法的最终数据结果

注意事项：

1、返回值类型必须和返回值对应

2、如果参数有多个，那么用逗号进行分割

调用：

1、单独调用

格式：方法名称(参数值);

在使用单独调用的时候，无法使用方法的返回值

2、打印调用

格式：System.out.println()

3、赋值调用

格式：数据类型 变量名称=方法名称(参数值);

调用方法，并且将返回值交给一个变量。注意，变量的数据类型必须和方法的返回值类型对应

public class Demo03MethodInvoke {
    public static void main(String[] args) {
        //单独调用
        Sum(10,20);
        //打印调用
        System.out.println(Sum(30,40));
        //赋值调用
        int result=Sum(50,60);
        System.out.println(result);
    }

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

 方法调用图解

 四、方法重载

现在的问题描述
对于类似的多个方法，全都是执行相加的操作，但是因为参数列表不一样，所以需要记住多个名字，太麻烦！

解决方法
使用方法重载(Overload)的技术，可以达到效果
对于类似功能的多个方法，只要记住一个相同的方法名即可，可以根据参数列表的不同自动适配

方法重载(Overload)：方法的名称相同，但是参数列表不同。

注意事项

什么叫做参数列表不同？

1、参数的个数不同

2、参数的类型不同

3、参数 的多类型顺序不同

重载与下列因素无关

1、与返回值类型无关

2、与参数的名称无关

    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) {
        return a + b;
    }

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

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

什么叫“参数传递”？

【形式参数(形参)】：在定义方法的时候，写在小括号之内的参数

eg：public static int sum(int a,int b){...}//这里的a和b是在定义的时候写的，所以是形式参数

【实际参数(实参)】：在调用方法的时候，真正传入方法里的数据，叫做实际参数

eg：int num=sum(10,20); //这里的10和20就是实际参数

 引用类型传参图解