JAVA 基础篇

一、数组

1、 什么是数组？

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

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

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

2、数组取值：

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

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

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

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

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

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

注意事项：

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

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

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

     public static void main(String[] args) {
         // 动态初始化
         int[] arrayA = new int[];
         arrayA[] = ;
         arrayA[] = ;
         arrayA[] = ;
         System.out.println(arrayA[]);
         System.out.println(arrayA[]);
         System.out.println(arrayA[]);
         System.out.println("============");
         // 静态初始化，一个步骤
         int[] arrayB = new int[] { , ,  };
         System.out.println(arrayB[]);
         System.out.println(arrayB[]);
         System.out.println(arrayB[]);
         System.out.println("============");
         // 静态初始化，两个步骤
         int[] arrayC;
         arrayC = new int[] { , ,  };
         System.out.println(arrayC[]);
         System.out.println(arrayC[]);
         System.out.println(arrayC[]);
         System.out.println("============");
         int[] arrayD= {,,};
         System.out.println(arrayD[]);
         System.out.println(arrayD[]);
         System.out.println(arrayD[]);
     }

3、获取数组长度

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

 public static void main(String[] args) {
         int[] arrayA= {,,,,,};
         System.out.println(arrayA.length);
     }

4、数组索引越界异常

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

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

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

     public static void main(String[] args) {
         int[] arrayA = { , ,  };
         System.out.println(arrayA[]); //
         System.out.println(arrayA[]); //
         System.out.println(arrayA[]); //
         System.out.println("数组的长度：" + arrayA.length);
         System.out.println("=====================");
         System.out.println(arrayA[]); // 编译没有报错，运行就报错！
         System.out.println(arrayA[-]); // 数组索引从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(,);
         //打印调用
         System.out.println(Sum(,));
         //赋值调用
         int result=Sum(,);
         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(, ));
         System.out.println(sum(, , ));
         System.out.println(sum(, , , ));
     }

     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就是实际参数

引用类型传参图解