=============================================================================
=============================================================================

涉及到的知识点有：
1：方法(掌握)
　　(1)方法的定义
　　(2)方法的格式
　　(3)如何写一个方法呢？两个明确
　　(4)如何进行方法调用呢？
　　　　A:有明确返回值的方法调用的方式
　　　　B:没有明确返回值的方法调用的方式：(即用void类型修饰的方法调用)
　　(5)方法的案例
　　(6)方法的注意事项
　　(7)方法的重载
　　(8)方法重载的案例
2：数组(一维数组)(掌握)
　　(1)数组的定义
　　(2)数组的特点
　　(3)数组的定义格式
　　(4)数组的初始化方式
　　　　A:动态初始化
　　　　B:静态初始化(常用)
　　(5)Java语言的内存分配
　　(6)数组的内存图解
　　(7)数组操作时的两个常见小问题
　　(8)数组的常见操作
　　　　A:数组的遍历
　　　　　　方式1
　　　　　　方式2
　　　　B:数组的最值
　　　　　　最大值
　　　　　　最小值
　　　　C:数组的逆序(逆置)
　　　　　　方式1：//使用一个索引，需要考虑到变量的变化。
　　　　　　方式2：//使用两个索引，不用考虑变量变化。
　　　　D:数组的查表(根据键盘录入索引,查找对应星期)
　　　　E:数组的元素查找(查找指定元素第一次在数组中出现的索引)

=============================================================================
=============================================================================
1：方法(掌握)
　　(1)方法的定义：就是完成特定功能的代码块。
　　　　注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。
　　(2)方法的格式：
　　　　修饰符 返回值类型 方法名(参数类型 参数名1, 参数类型 参数名2, 参数类型 参数名3...) {
　　　　　　方法体语句; 　　　　  ----------------------------------------------------
　　　　　　return 返回值; 　　　　　　　　 参数列表
　　　　}
　　　　---------------------------------------
　　　　修饰符：目前就用 public static。后面再详细讲解其他修饰符。
　　　　返回值类型：就是功能结果的数据类型。
　　　　方法名：就是起了一个名字，符合命名规则即可，方便我们调用该方法。
　　　　参数类型：就是参数的数据类型。限定调用方法时传入参数的数据类型。
　　　　参数名：就是变量名，接收调用方法时传入的参数。
　　　　参数分类：
　　　　　　实际参数(实参)：实际参与运算的数据。
　　　　　　形式参数(形参)：方法上定义的，用于接收实际参数的变量。
　　　　方法体语句：就是完成功能的代码。
　　　　return：结束方法以及返回方法指定类型的值。
　　　　返回值：就是功能的结果，由return带给调用者。
　　(3)如何写一个方法呢？两个明确：
　　　　a:返回值类型：明确功能结果的数据类型。
　　　　b:参数列表：明确参数的个数以及参数的数据类型。
　　(4)如何进行方法调用呢？
　　　　A:有明确返回值的方法调用的方式：
　　　　　　a:单独调用，没有意义。
　　　　　　　　sum(x, y);
　　　　　　b:输出调用，但是不够好，因为我不一定非要把结果输出，可能针对结果进行进一步操作。但是讲课一般我就用了。
　　　　　　　　System.out.println(sum(x, y));
　　　　　　c:赋值调用，推荐方式。
　　　　　　　　int z = sum(x, y);
如下图所示01：

　　　　B:没有明确返回值的方法调用的方式：(即用void类型修饰的方法调用)
　　　　　　a:只能单独调用。
　　(5)方法的案例：
　　　　A:求和方案。
　　　　B:获取两个数中的较大值。(返回值是int类型，用三元改进。)
　　　　C:比较两个数据是否相同。(返回值是boolean类型，用三元改进。)
　　　　D:获取三个数中的最大值。(返回值是int类型，用if else嵌套，用三元改进。)
　　　　E:输出m行n列的星形。(返回值是void类型。)
　　　　F:键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表。
　　(6)方法的注意事项：
　　　　A:方法不调用不执行。
　　　　B:方法与方法是平级关系，不能嵌套定义。
　　　　C:方法在定义的时候，参数是用逗号,隔开的
　　　　D:方法在调用的时候，不用在传递数据的类型。
　　　　E:如果方法有明确的返回值类型，就必须有return语句返回。
　　(7)方法的重载
　　　　在同一个类中，方法名相同，参数列表不同。与返回值无关。

　　　　参数列表不同：
　　　　　　参数的个数不同。
　　　　　　参数的对应的数据类型不同。
　　(8)方法重载的案例
　　　　不同的类型的多个同名方法的比较。
-----------------------------------------------------------------------------

2：数组(一维数组)(掌握)
　　(1)数组的定义：存储同一种数据类型的多个元素(变量)的容器(集合)。
　　(2)数组的特点：每一个元素都有编号，从0开始，最大编号是长度-1。
　　　　编号的专业叫法：索引(角标)。
　　　　数组既可以存储基本数据类型，也可以存储引用数据类型。
　　(3)数组的定义格式：
　　　　A:数据类型[] 数组名; 　　int[] a; 　　//定义了一个int类型的数组a变量。
　　　　B:数据类型 数组名[]; 　　int a[]; 　　//定义了一个int类型的a数组变量。
　　　　---------------------------------------
　　　　推荐是用A方式，A方式的可读性更强，B方法就忘了吧。在Java中均可。
　　　　B方式早期的时候确实有很多人这样用。不过，现在这样用的人越来越少了。
　　　　作为Java的粉丝C#(Java的模仿者)就不再支持第二种语法格式了。越来越多的语言可能会抛弃第二种格式。
　　　　但是看源码的时候要能看懂。
　　(4)数组的初始化方式：
　　　　Java中的数组必须先初始化,然后才能使用。
　　　　所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
　　　　　　A:动态初始化
　　　　　　　　只指定数组长度，由系统分配初始值。(数组长度其实就是数组中元素的个数。)
　　　　　　　　　　举例： int[] arr = new int[3];
　　　　　　　　　　　　    System.out.println(arr); 　　//[I@6d06d69c     地址值，数组名其实就是该数组首元素的地址。
　　　　　　B:静态初始化(常用)
　　　　　　　　给初值，由系统决定数组长度。
　　　　　　　　　　举例：    int[] arr = new int[]{ 1, 2, 3 };
　　　　　　　　　　简化版：int[] arr = { 1, 2 ,3 };
如下图所示06：

　　(5)Java语言的内存分配：
　　　　Java程序在运行时，需要在内存中的分配空间。
　　　　为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
　　　　A:栈：存储局部变量。
　　　　B:堆：存储所有new出来的东西。
　　　　C:方法区(面向对象部分详细讲解)
　　　　D:本地方法区(系统相关)
　　　　E:寄存器(CPU使用)
　　　　---------------------------------------
　　　　注意：
　　　　　　a:局部变量：在方法定义中或者方法声明上定义的变量。使用完毕，立即消失。
　　　　　　b:栈内存和堆内存的区别：
　　　　　　　　栈：数据使用完毕，就消失。
　　　　　　　　堆：每一个new出来的东西都有地址。
　　　　　　　　　　堆中的每一个变量都有默认值。
　　　　　　　　　　byte,short,int,long   --> 0
　　　　　　　　　　float,double 　　     --> 0.0
　　　　　　　　　　char 　　　　　　    --> '\u0000'          //因为Java语言采用的是Unicode编码。
　　　　　　　　　　boolean 　　　　     --> false
　　　　　　　　　　引用类型 　　　　      --> null
　　　　在Java语言中，数据使用完毕后，就变成垃圾了，但并没有立即回收，会在垃圾回收器空闲的时候回收。
　　　　在C++语言中，有构造函数和析构函数，调用析构函数用来释放空间。
如下图所示02：

　　(6)数组的内存图解:
　　　　A:一个数组
　　　　B:二个数组
　　　　C:三个数组(两个栈变量指向同一个堆内存)
如下图所示03/04/05：

　　(7)数组操作时的两个常见小问题：
　　　　a：ArrayIndexOutOfBoundsException:数组索引越界异常。
　　　　　　原因：你访问了不存在的索引。
　　　　b：NullPointerException:空指针异常。
　　　　　　原因：数组已经不再指向堆内存了。而你还用数组名去访问元素。(即:数组引用没有指向实体，却在操作实体中的元素。)
　　(8)数组的常见操作:
---------------------------------------
　　　　A:数组的遍历
　　　　　　数组的一个属性：获取数值长度：数值名.length
　　　　　　方式1：
　　　　　　　　public static void printArray(int[] arr) {
　　　　　　　　　　for(int x = 0; x < arr.length; x++) {
　　　　　　　　　　　　System.out.println(arr[x]);
　　　　　　　　　　}
　　　　　　　　}

　　　　　　方式2：通过字符串的拼接，让元素在一行上输出。
　　　　　　　　public static void printArray(int[] arr) {
　　　　　　　　　　System.out.print("[ ");
　　　　　　　　　　for(int x = 0; x < arr.length; x++) {
　　　　　　　　　　　　if(x == arr.length - 1) {
　　　　　　　　　　　　　　System.out.println(arr[x]+" ]");
　　　　　　　　　　　　}else {
　　　　　　　　　　　　　　System.out.print(arr[x]+", ");
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　}
---------------------------------------
　　B:数组的最值
　　　　最大值：
　　　　　　public static int getMax(int[] arr) {
　　　　　　　　int max = arr[0];

　　　　　　　　for(int x = 1; x < arr.length; x++) {
　　　　　　　　　　if(arr[x] > max) {
　　　　　　　　　　　　max = arr[x];
　　　　　　　　　　}
　　　　　　　　}

　　　　　　　　return max;
　　　　　　}

　　　　最小值：
　　　　　　public static int getMin(int[] arr) {
　　　　　　　　int min = arr[0];

　　　　　　　　for(int x = 1; x < arr.length; x++) {
　　　　　　　　　　if(arr[x] < min) {
　　　　　　　　　　　　min = arr[x];
　　　　　　　　　　}
　　　　　　　　}

　　　　　　　　return min;
　　　　　　}
---------------------------------------
　　C:数组的逆序(逆置)
　　　　方式1：//使用一个索引，需要考虑到变量的变化。
　　　　　　public static void reverse(int[] arr) {
　　　　　　　　for(int x = 0; x < arr.length / 2; x++) {
　　　　　　　　　　int temp = arr[x];
　　　　　　　　　　arr[x] = arr[arr.length - 1 - x];
　　　　　　　　　　arr[arr.length - 1 - x] = temp;
　　　　　　　　}
　　　　　　}

　　　　方式2：//使用两个索引，不用考虑变量变化。
　　　　　　public static void reverse(int[] arr) {
　　　　　　　　for(int start = 0, end = arr.length - 1; start <= end; start++, end--) {
　　　　　　　　　　int temp = arr[start];
　　　　　　　　　　arr[start] = arr[end];
　　　　　　　　　　arr[end] = temp;
　　　　　　　　}
　　　　　　}
---------------------------------------
　　D:数组的查表(根据键盘录入索引,查找对应星期)
　　　　public static String getString(String[] strArray, int index) {
　　　　　　return strArray[index];
　　　　}
　　E:数组的元素查找(查找指定元素第一次在数组中出现的索引)
　　　　方式1：
　　　　　　public static int getIndex(int[] arr, int value) {
　　　　　　　　for(int x = 0; x < arr.length; x++) {
　　　　　　　　　　if(arr[x] == value) {
　　　　　　　　　　　　return x;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　return -1; //找不到的时候对应的返回的值。或者是for循环的判断条件语句为false时候对应的方茴的值。
　　　　　　}
　　　　　　特别注意：只要是判断条件语句，就有可能是false，所以要细心！！！

　　　　方式2：
　　　　　　public static int getIndex(int[] arr, int value) {
　　　　　　　　int index = -1;

　　　　　　　　for(int x = 0; x < arr.length; x++) {
　　　　　　　　　　if(arr[x] == value) {
　　　　　　　　　　　　index = x;
　　　　　　　　　　　　break;
　　　　　　　　　　}
　　　　　　　　}

　　　　　　　　return index;
　　　　　　}
=============================================================================