1. 方法：
概述：
方法就是完成特定功能的代码块（类似于其他一些语言函数的概念）
格式：
修饰符 返回值 方法名 （参数类型 参数名1，参数类型 参数名2 … … ）{
方法体语句；
return 返回值；
}
详细解释：
-
修饰符：目前就用 public static
-
返回值类型：就是功能结果的数据类型（无返回值用void）
-
方法名：符合命名规则即可。方便我们的调用
-
参数：
实际参数：就是实际参与运算的
形式参数：就是方法定义上的，用于接收实际参数的
-
参数类型：就是参数的数据类型
-
参数名：就是变量名
-
方法体语句：就是完成功能的代码
-
return：结束方法的
-
返回值：就是功能的结果，由return带给调用者
写好一个方法应该明确：
-
返回值类型
结果的数据类型
-
参数列表
要传递几个参数，以及每个参数的数据类型
方法的注意事项：
- 不调用，不执行
- 方法与方法是平级关系，不能嵌套定义
- 方法定义的时候参数之间用逗号隔开
- 方法调用的时候不用再传递数据类型
- 如果方法有明确返回值，一定要有return带回一个返回值
练习：
键盘录入一个数据n，输出对应的nn乘法表
import java.util.Scanner;
class FunctionTestS {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入n的值: ");
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();
}
}
}
方法重载：
概述：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
重载特点：
- 与返回值类型无关，只看方法名和参数列表。
- 在调用时，虚拟机通过参数列表的不同来区分同名方法
/*
比较两个数据是否相等。参数类型分别为
两个byte类型，两个short类型，两个int类型，两个long类型，
并在main方法中进行测试
*/
class FunctionTest6 {
public static void main(String[] args) {
//测试
byte b1 = 3;
byte b2 = 4;
System.out.println("byte:"+compare(b1,b2));
//测试
short s1 = 5;
short s2 = 5;
System.out.println("short:"+compare(s1,s2));
}
//byte类型
public static boolean compare(byte a,byte b) {
System.out.println("byte");
return a == b;
}
//short类型
public static boolean compare(short a,short b) {
System.out.println("short");
return a == b;
}
//int类型
public static boolean compare(int a,int b) {
System.out.println("int");
return a == b;
}
//long类型
public static boolean compare(long a,long b) {
System.out.println("long");
return a == b;
}
}
2. 数组
概念：
- 数组是存储同一种数据类型多个元素的集合。
- 数组既可以存储基本数据类型，也可以存储引用类型。
格式：
-
数据类型 [ ] 数组名；
举例：int [] a; 定义一个int类型的数组a变量
-
数据类型 数组名 [ ]；
举例：int a[]; 定义一个int类型的a数组变量
两种格式效果一样，都是定义一个int数组，只是念法上与些区别，推荐使用第一种。
1. 数组的初始化
概述：
为数组中的数组元素分配内存空间，并为每个数组元素赋值
方法：
- 动态初始化：初始化时，只指定初始化长度，由系统为数组分配初始值
- 静态初始化：初始化时，指定每个数组元素的初始值，由系统决定数组长度
动态初始化：
格式：
数据类型 [] 数组名 = new 数据类型 [数组长度]；
举例：
int [] arr = new int [3]；
解释：（定义了一个int类型的数组，这个数组中可以存放3个int类型的值）
-
左边：
int：说明数组中的元素的数据类型是int类型
[ ]：说明这是一个数据
arr：是数组的名称（也是一个地址值）
-
右边：
new：为数组分配内存空间
int：说明数组中的元素的数据类型是int类型
[ ]：说明这是一个数组
3：数组长度，其实也就是数组中元素的个数
静态初始化：
格式：
数据类型 [] 数组名 = new 数据类型 [] {元素1，元素2 … … }；
简化格式：
数据类型 [] 数组名 = {元素1，元素2 … … }；
举例：
int [] arr = new int [] {1，2，3}；
int [] arr = {1，2，3}；
解释：
定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且分别为1，2，3。
注意：不要同时使用动态和静态初始化
int [] arr = new int[3] {1, 2, 3}； //错误
2. 数组的操作
常见问题：
-
数组索引越界异常：
原因：访问了不存在的索引
-
空指针异常：
原因：数组已经不在指向堆内存了，而还用数组名去访问元素
获取数组中的元素方法
格式：数组名[索引]
索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1
1. 数组遍历：依次输出数组中的每个元素
class ArrayTest{
public static void main(String [] args){
int [] arr = {11, 22, 33, 44, 55};
for(int x = 0; x < arr.length; x++){
System.out.println(arr[x]);
}
System.out.println("--------------------");
printArray(arr);
}
public static void printArray(int [] arr){
for(int x = 0; x < arr.length; x++){
System.out.println(arr[x]);
}
}
}
数组提供了一个属性length，用于获取数组长度
格式：数组名.length
2. 获取最值：获取数组中的最大值或最小值
class ArrayTest2{
public static void main(String [] args){
int [] arr = {11, 22, 66, 44, 55};
int max = arr[0];
for(int x = 0; x < arr.length; x++){
if (arr[x] > max){
max = arr[x];
}
}
System.out.println("max: "+max);
System.out.println("--------------------");
System.out.println("max: "+getMax(arr));
}
public static int getMax(int [] arr){
int max = arr[0];
for(int x = 0; x < arr.length; x++){
if (arr[x] > max){
max = arr[x];
}
}
return max;
}
3. 数组元素逆序：把元素对调
class ArrayTest3{
public static void main(String [] args) {
int[] arr = {11, 22, 66, 44, 55};
reverse1(arr);
reverse2(arr);
}
public static void reverse1(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;
}
}
public static void reverse2(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;
}
}
注意：不需要返回逆序后的数组，因为两个数组其实是同一个数组
4. 数组元素查找：查找指定元素第一次在数组中出现的索引
class ArrayTest4{
public static void main(String [] args) {
int[] arr = {11, 22, 66, 44, 55};
int index = getIndex(arr, 22);
System.out.println("在数组中第一次出现的索引是："+index);
}
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;
}
}
3. Java中的内存分配
Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
-
栈 存储局部变量
-
堆 存储所有new出来的东西
-
方法区 (面向对象部分讲)
-
本地方法区 (和系统相关)
-
寄存器 (给CPU使用)
局部变量：在方法定义中或者方法声明上的变量都是局部变量。
栈内存的数据用完就会释放掉
堆内存的特点：
- 每个new出来的东西都有地址值
- 每个变量都有默认值
| byte，short，int，long | 0 |
|---|---|
| float，double | 0.0 |
| char | ‘\u0000’ |
| boolean | false |
| 引用类型 | null |
- 使用完毕就变成垃圾，但是并没有立即回收。会在垃圾回收器空闲的时候回收
栈内存的两个引用指向同一个堆内存空间
无论是它们谁的操作，都是针对同一个地方
228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
