重踏学习Java路上_Day05(java 基础下，方法与数组)

1:方法(掌握)
(1)方法：就是完成特定功能的代码块。
注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。
(2)格式：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句;
return 返回值;
}

修饰符：目前就用 public static。后面再详细讲解其他修饰符
返回值类型：就是功能结果的数据类型
方法名：就是起了一个名字，方便我们调用该方法。
参数类型：就是参数的数据类型
参数名：就是变量
参数分类：
实参（实际参数）：实际参与运算的数据
形参（形式参数）：方法上定义的，用于接收实际参数的变量
方法体语句：就是完成功能的代码块
return：结束方法
返回值：就是功能的结果，由return带给调用者。
(3)两个明确：
返回值类型：结果的数据类型
参数列表：参数的个数及对应的数据类型
(4)方法调用
A:有明确返回值的方法
a:单独调用，没有意义
b:输出调用，不是很好，因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了。
c:赋值调用，推荐方案
B:void类型修饰的方法
a:单独调用
(5)案例：
A:求和方案
B:获取两个数中的较大值
C:比较两个数据是否相同
D:获取三个数中的最大值
E:输出m行n列的星形
F:输出nn乘法表
(6)方法的注意事项
A:方法不调用不执行
B:方法之间是平级关系，不能嵌套定义
C:方法定义的时候，参数是用，隔开的
D:方法在调用的时候，不用在传递数据类型
E:如果方法有明确的返回值类型，就必须有return语句返回。
(7)方法重载
在同一个类中，方法名相同，参数列表不同。与返回值无关。
JVM会通过参数列表的不同来区分同名方法
参数列表不同：
参数的个数不同。
参数的对应的数据类型不同。
(8)方法重载案例
不同的类型的多个同名方法的比较。

2:数组(掌握)
(1)数组：是存储在同一种数据类型的多个元素的集合，也可以看成一个容器，数组既可以存储基本数据类型，也可以存储引用数据类型。静态初始化与动态初始化不能同时使用，例如，

       int[] arr = new int[3]{1,2,3},这样写编译器不懂如何去编译。
(2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。
编号的专业叫法：索引
(3)定义格式
A:数据类型[] 数组名;   int[] a;定义一个int类型的数组a变量（推荐用法）
B:数据类型 数组名[];   int a[]; 定义一个int类型的a数组变量

定义数组
方式1（推荐，更能表明数组类型）
type[] 变量名 = new type[数组中元素的个数];
比如：
int[] a = new int[10];
数组名，也即引用a，指向数组元素的首地址。
方式2（同C语言）
type变量名[] = new type[数组中元素的个数];
如：
int a[] = new int[10];
方式3 定义时直接初始化
type[] 变量名 = new type[]{逗号分隔的初始化值};
其中红色部分可省略，所以又有两种：
int[] a = {1,2,3,4};
int[] a = new int[]{1,2,3,4};
其中int[] a = new int[]{1,2,3,4};的第二个方括号中不能加上数组长度，因为元素个数是由后面花括号的内容决定的。

数组动态初始化定义长度问题，只要在定义是填入int类型的值，就不会报错，不管是变量还是固定值。 

  public static void main(String[] args) {
        //这种数组的长度设定也不会报错，是对的，也是属于固定长度，只要是字面上在构造数组时有定值就行，也可以是int类型的变量值
        int[] arr = new int[3];
        int[] arr2 = new int[arr.length];//这里是获取arr的长度
        int num = (int)Math.random()*100+1;
        int[] arr3 = new int[num];//这里获取的是num的int类型随机值，也不会报错，所以，构造只需要int的类型实际值就行
    }

 

数组操作的两个常见小问题：

一是，越界（ArrayIndexOutOfBoundsException:数组索引越界异常，原因，你访问的索引不存在），二是，空指针（NullPointerException:空指针异常，原因：数组已经不再指向堆内存了，而你还有数组名去访问元素）；

 

推荐是用A方式，B方法就忘了吧。
但是要能看懂
(4)数组的初始化：

Java中的数组必须先初始化，然后才能使用，并为每个数组元素赋值；

何为初始化？

就是为数组开辟内存空间，并为每个数组元素赋予值。初始化时，两种初始化方式只能为一种

A:动态初始化
初始化时只是指定组的长度，有系统为数组分配初始值。

举例：int[] arr = new int[3];
B:静态初始化（一般推荐使用静态初始化）
初始化时只指定数组长度，由系统为数组分配初始值。

举例：int[] arr = new int[]{1,2,3};（new：为数组分配一个内存空间）
简化版：int[] arr = {1,2,3};

例子：

int[] arr = new int[3];

/*

上面式子的左边：

   int:说明数组中的元素的数据类型是int整型类型

   []:说明这是一个数组

   arr：说明数组的名称是arr

上面式子的右边：

   new:为数组分配内存空间

   int：说明数组总的元素的数据类型是int类型

   []：说明这是一个数组

   3：为数组长度，其实也就是数组中的元素个数

*/

 System.out.println(arr);//输出的是内存地址值

 其实数组中的每个元素都是有编号的，并且是从0开始，最大编号是数组的长度-1

 用数组名和编号的配合就可以获取数组中的指定编号的元素，这个编号的专业叫法：索引

 通过数组名访问数据的格式是：数组名[索引];

 

(5)Java的内存分配

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

具体的是划分如下5个内存空间：
A:栈：存储局部变量
B:堆：存储所有new出来的
C:方法区(面向对象部分详细讲解)
D:本地方法区(系统相关)
E:寄存器(CPU使用)

注意：
a:局部变量 在方法定义中或者方法声明上定义的变量。
b:栈内存和堆内存的区别
栈：数据使用完毕，就消失。
堆：每一个new出来的东西都有地址
每一个变量都有默认值
byte,short,int,long 0
float,double 0.0
char '\u0000'
boolean false
引用类型 null
数据使用完毕后，在垃圾回收器空闲的时候回收。
(6)数组内存图
A:一个数组

B:二个数组

C:三个数组(两个栈变量指向同一个堆内存)

(7)数组的常见操作
A:遍历
方式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.println(arr[x]+", ");
}
}
}

方式3：

int arr[] = new int[]{1,2,3};

for(int i : arr){

    System.out.println(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++) {  //利用折半来进行逆序，可以使时间变为OT=N/2;
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;会报错，原因是，若if的判断永远是false怎么样都不会走到if的代码块去执行return的内容，整个方法就会没有返回值，所以编译器在编译时会报错。

}
}

return -1;//如果找不到数据，我们一般返回一个负数即可，而且一般是返回-1；
}

方式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;
}