java语言基础3

方法概述和格式说明

修饰符 返回值类型 方法名（参数类型 参数名1，参数类型 参数名2。。。）{
方法体语句；
return返回值；
}

要想写好一个方法，就必须明确两个东西；
A：返回值类型
结果的数据类型
B：参数列表
你要传递几个参数，以及每个参数的数据类型

单独调用，一般来说没有意义，不推荐
输出调用，有意义，但是不够好，因为我们可能需要针对结果进行进一步操作；
赋值调用，推荐

什么是方法

方法就是完成特定功能的代码块
在很多语句里面都有函数的定义
函数在 Java中被称为方法

格式：
修饰符 返回值类型 方法名（参数类型 参数名1，参数类型 参数名2。。。）{
方法体语句；
return返回值；
}

详细解释;
修饰符：目前就用 public static 。
返回值类型：就是功能结果的数据类型。
方法名：符合命名规则即可。
参数：
实际参数：就是实际参与运算的。
形式参数：就是方法定义上的，用于接收实际参数的。
参数类型：就是参数的数据类型；
参数名：就是变量名。
方法体语句：就是完成功能的代码。
return:结束方法的。
返回值：就是功能的结果，由return带给调用者。

方法的注意事项

方法不调用不执行；
方法与方法是平级关系，不能嵌套；
方法定义的时候参数之间用逗号隔开；
方法调用的时候不用在传递数据类型；

方法的调用void类型方法的定义和调用

// An highlighted block
for(int x = 0; x < 4; x++){
	for(int y = 0; y <5; y++){
	System.out.print("*");
}
	System.out.println();
}

// An highlighted block
//单独调用；对
pringXing(3,4);
pringXing(6,7);
pringXing(8,9);
//输出调用；(错误)
System.out.println(pringXing(3,4));
//赋值类型；（错误）
void V=pringXing(3,4);

写一个m行n列的代码；
两个明确：
返回值类型：这个时候没有明确的返回值，不写东西也不行，所以，这里记住是void
参数列表：int m,int n;

// An highlighted block
public static void pringXing(int m,int n){
	for(int x = 0; x < mk; x++){
		for(int y =0;y <n; y++){
		System.out.print("*");
}
		System.out.println("x");
}
}
# 根据键盘录入输出对应的乘法表
键盘录入一个数据n(1<=n<=9),输出对应的nn乘法表；
```javascript
// An highlighted block
int n = sc.nextInt();
printNN(n);


public static void printNN(int n){
	for(int x = 1; x<n; x++){
	for(int y =1; y<x; y++){
	System.out.print(y +"*"+x+"="+y*x+"\t");

}
	System.out.println();
}

}

方法重载概述和基本使用

我要求数的和
我们的需求不断的发生改变，我们就对应的提拱了多个求和
但是呢，他们额的名字是不一样的
而我们又要求方法命名做到：见名知意。
但是，很明显，现在没有做到。
针对这种情况：方法的功能相同，参数列表不同的情况，Java运行他们命名一样。
其实，这种情况有一个专业名词：方法重载。
方法重载：
在同一个类中，方法名相同，参数列表不同。与反回值类型无关。
参数列表不同：
参数个数不同
参数类型不同

数组概述和定义格式说明

数组概述：数组是存储多个变量（元素)的东西（容器） ；
这多个变量的数据类型要一致；

数组概念：数组是存储同一种数据类型的多个元素集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式：格式1：数组类型[] 数组名；
格式2：数据类型 数组名[];
注意：这两种定义做完了，数组中是没有元素值的。
int[] a;定义一个int类型的数组a变量；
int a[];定义一个int类型 a 数组变量；

数组的初始化动态初始化

Java初始化概述：
java中数组必须先初始化，然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式：
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

动态初始化格式：
数据类型[] 数组名 = new 数据类型[数组长度]；
数组长度其实就是数组中元素的个数。
举例：
int [] arr = new int[3];
解释：定义了一个int类型的数组这个数组中可以存放三个int类型的值。
左边：
int：说明数组中的元素的数据类型时int类型；
[]：说明这是一个数组；
arr：数组名称；
右边：
new:为数组分配内存空间。
int：说明数组中的元素的数据类型时int类型；
[]：说明这是一个数组；
3：数组长度，其实也就是数组中元素的个数

其实数组中的每个元素都是有编号的，并且是从0开始，最大编号是数组的长度-1。
用数组名和编号的配合就可以获取数组中的指定编号元素。这个编号的专业叫法：索引
通过数组名访问数据的格式是：数组名[索引]；

Java中的内存分布以及栈和堆的区别

*Java中的内存分配：
java程序在运行时，需要在内存中的分配空间。为了提交运算效率，就对空间进行了不同区域的划分
，一位内每一片区域都有特定的处理数据方式和内存管理方式。
栈 存储局部变量；
堆 存储new出来的东西；
方法区
本地方法区（和系统有关）
寄存器（给CPU使用）

*局部变量：在方法定义中或者方法声明上的变量都称为局部变量。

int[] arr存储在栈中；
new int[3];存储在堆中

int[] arr = new int[3];
System.out.println(arr);//返回的是地址值；
System.out.println(arr[0]);//0
System.out.println(arr[1]);//0
System.out.println(arr[2]);//0

*堆内存的特点：每一个new出来的东西都有地址值。
每个变量都有默认值
byte,short,int,long,默认值是0;
float,double默认值是0.0;
char默认值是’\u0000’;
boolean 默认值是false;
引用类型默认值是null;
使用完毕就变成了垃，但是并没有立即回收，会在垃圾回收期空闲的时候回收；
举例栈内存中int a =100;用完就立即释放

数组的内存

定义第一个数组，定义完毕后，给数组元素赋值。赋值完毕后，在输出数组名称和元素。
定义第二个数组，定义完毕后，给数组元素赋值。赋值完毕后，在输出数组名称和元素。
定义第三个数组，把第一个数组的地址值赋值给他。(注意类型一致)，通过第三个数组的名称去把元素重新赋值
最后，再次输出数组名称和元素。

栈内存的两个引用指向同一给堆内存空间。
无论是他们谁的操作，都是针对同一个地方。

数组的初始化静态初始化及内存图

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：
数据类型 [] 数组名 = new 数据类型[]{元素1，元素2，…};
举例：
int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放三个int 类型的值，并且值分别是1，2，3.
其实还有一种简化写法：int[] arr = {1,2,3};

注意：不要同时动态数组和静态数组；

数组操作常见的小问题越界和空指针

数组操作的两个常见小问题：
Array(数组)Index（索引）OutOf(超出)Bounds(边界)Exception(异常)；
原因：你访问了不存在的索引；
Null（空）Pointer（指针）Exception（异常）；
原因：数组已经不再指向堆内存了，而你还用数组名去访问元素；

// An highlighted block
public static void main(String[] args){
	int[] arr ={1.2.3};
	System.out.println(arr[3]);
	//空指针异常；

// An highlighted block
//引用类型的常量：空常量 null；
	arr = null;
	System.out,println(arr[0]);
}

数组操作1遍历

数组遍历（依次输出数组中的每个元素）
就是依次输出数组中的每个元素。
注意：数组提供了一个属性length用于获取数组长度；

数组的操作2获取最值

数组获取最值（获取数组中的最大值最小值）
分析：
A：定义一个数组，并对数组的元素进行静态初始化；
B：从数组中任意的找一个元素作为参照物（一般取第一个，默认它就是最大值）；
C：然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开
D：最后参照物里面保存的就是最大值；

数组的操作3元素逆序

数组元素逆序（就是把元素对调）
分析：
定义一个数组，并进行静态初始化；
思路：
把0索引和arr.length-1的数据交换；
把1索引和arr.length-2的数据调换；
…
只要做到arr.length/2的时候即可。

数组的操作4查表法

数组查表法（根据键盘）

总结

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）方法重载
在同一个类中，方法名相同，参数列表不同，与返回值无关

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

2.数组（掌握）
（1）数组：存储同一种数据类型的多个元素的容器
（2）特点：每一个元素都有编号，从0开始，最大编号为长度-1.
编号的专业叫法：索引
（3）定义格式
A：数据类型[] 数组名；
B：数据类型 数组名[];
（4）数组的初始化
A：动态初始化
只给长度，系统给出默认值
举例：int[] arr = new int[3];
B：静态初始化
给出值，系统决定长度
举例：int[] arr = new int[]{1,2,3};
简化版：int[] arr = {1,2,3};
(5)java的内存分配
A：栈 存储局部变量(int[] arr)
B：堆 存储所有new出来的(new int[]{1,2,3})
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：遍历
方式一：
下面展示一些 内联代码片。

// An highlighted block
public static void printArray(int [] arr) {
		for(int x =0;x<arr.length;x++) {
			System.out.println(arr[x]);
		}
	}

	方式二：

// An highlighted block
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]+",");
			}
		}
	}

B：最值
	最大值：

// An highlighted block
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;
}

	最小值：

// An highlighted block
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：

// An highlighted block
public static int getMax(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;
	}
}

	方式二：

// An highlighted block
public static int getMax(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：查表

// An highlighted block
public static String getString(String[] atrArray,int index){
			return strArray[index];
}

E:基本查找
	方式1：

// An highlighted block
public static int getIndex(int[] arr,int value){
			for(int x=0;x<arr.length;x++){
				if(arr[x] ==value){
				return x;
		}
	}
				return -1;
}

	方式2：

// An highlighted block
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;
}