JavaSE方法学习笔记
什么是方法
-
概念
方法（method）是程序中最小的执行单元
public class MethodsDemo01 { public static void main(String[] args) { System.out.println("HelloWorld!"); System.out.println("HelloWorld!"); } }我们写的中间的这个就是main方法、主方法。
现在里面有两条语句。问，能不能让他们分开运行。我不想运行第一条语句或者不运行第二条语句。
如果不用注释，那是不可能实现的。因为main方法里面的代码就是一个整体。不可能说把这个拆分。运行这个不运行那个。因此就说是最小的执行单元。每个方法都会被看作一个最小的执行单元。然后执行。
在代码当中我们可以自己定义以西其他的方法，同样的，方法里面的代码要么是全都一起执行，要么全都不执行。
-
应用
- 重复的代码、具有独立功能的代码可以抽取到方法中
-
作用
- 提高代码的复用性
- 提高代码的可维护性
感觉我在哪里使用过方法，但不叫这个名字，对，函数。在C语言中要定义一个主函数main才可以运行。python里面没有，但是python里面的函数、或者说C语言里面的函数都是可以为提高代码的复用性和可维护性。而Java叫主方法。
将一段代码封装成函数，然后就是到处调用，方便性直接拉满
通过搜索：方法就是函数、函数就是方法。只不过每个语言的叫法不一样。方法是特殊的函数，定义在类里面。
方法和函数的本质是相同的，对一段代码的抽象。但是
- 函数、显式地传输数据，与类和对象无关
- 方法：隐式传输数据，可以直接处理对象传输的数据。依赖于类和对象
可以理解为方法定义在类中。
面向过程C语言中，只有函数没有方法。面向对象Java中只有方法而没有函数。
python既有函数又有方法，怎么区分呢，以类为基准，函数定义在类的外面。方法是定义在类的里面
方法的格式
把一些代码打包在一起，用到的时候就调用。
-
方法定义
把一些代码打包在一起，该过程称为方法定义
-
方法调用
方法定义后并不是直接运行的，需要手动调用，该过程称为方法调用。
-
方法的定义格式
public static 返回值类型 方法名 (参数){ 方法体; return 返回值; }
方法虽然是Java里面提出来的，但就说我，我经常用python，这完全就很像是定义函数，def关键字、参数、函数体、返回值；调用。可以说是换汤不换药。
最简单的方法定义和调用
-
定义
public static 返回值类型 方法名 (参数){ 方法体（带包起来的代码）; }// 定义一个方法 public static void playGame() { System.out.println("电脑开机"); System.out.println("启动idea"); System.out.println("新建项目"); System.out.println("编写代码"); System.out.println("运行程序"); System.out.println("电脑关机"); } -
调用
方法必须先定义后调用，否则程序将报错
方法名();public class MethodsDemo01 { public static void main(String[] args) { // 调用playGame方法 playGame(); }方法调用是要在主方法里面调用的。因为程序会优先找到主方法，然后运行里面的代码。当代码运行到调用的方法时，就会执行这个方法
以下做个完整的实现，以我编写Java程序的流程
package MethodsDome;
public class MethodsDemo01 {
public static void main(String[] args) {
// 调用playGame方法
playGame();
}
// 定义一个方法
public static void playGame() {
System.out.println("电脑开机");
System.out.println("启动idea");
System.out.println("新建项目");
System.out.println("编写代码");
System.out.println("运行程序");
System.out.println("电脑关机");
}
}
`
方法是要定义在主方法的外面。
就说这是我编写Java程序的流程，如果说我要编写多个Java程序，那么就调用这个方法多次
public class MethodsDemo01 {
public static void main(String[] args) {
// 调用playGame方法
playGame();
playGame();
...
}
也可以在方法里面定义变量或者调用方法
-
定义变量
public static void getSum() { int a = 10; int b = 20; int c = a + b; System.out.println(c); } -
方法调用方法
// 第一个方法 public static void myMethods1() { myMethods2(); // 调用方法 } // 第二个方法 public static void myMethods2() { System.out.println("HelloJava"); }
注意，以上两个都没有在主方法调用。
带参数的方法定义和调用
-
定义
单个参数定义
public static void 方法名 (参数) { }public static void 方法名 (int number) { }多个参数定义
public static void 方法名 (参数1, 参数2, ...) { }public static void 方法名 (int number1, int number2) { } -
调用
注意：方法调用时，参数的数量与类型必须与方法定义i中的小括号里面的变量一一对应，否则程序将保错
单个参数
方法名(参数);method(10);多个参数
方法名(参数1, 参数2, ...)method(10, 20, ...)
那就写个求和的类型叭
package MethodsDome;
public class MethodsDemo04 {
public static void main(String[] args) {
getSum(10, 20); // 30
getSum(10, 15); // 25
getSum(10, 2); // 12
}
public static void getSum(int num1, int num2) {
int result = num1 + num2;
System.out.println(result);
}
}
这个如果不说类的问题，很像是python和C里面的函数。
形参和实参
-
形参
形式参数，是指方法定义中的参数
-
实参
实际参数，方法调用中的参数
这两个概念想必不陌生，都是有的，同时我也是容易混淆他们。python的期末考试里面有这题，我感觉我答错了
package MethodsDome;
public class MethodsDemo04 {
public static void main(String[] args) {
getSum(10, 20); // 30
getSum(10, 15); // 25
getSum(10, 2); // 12
}
public static void getSum(int num1, int num2) {
int result = num1 + num2;
System.out.println(result);
}
}
还是把这段代码拿下来。
我们分析
getSum(10, 15);
这个是方法调用，因此，10和20叫做实参。方法调用里的参数
public static void getSum(int num1, int num2) {... ...}
中的int num1 和 int num2就是形参，这个就是可以理解为占位，这个地方你要用，但你不知道你要放什么，先占着。
因此这段话还可以改一下
注意：方法调用时，形参和实参必须一一对应，否则程序将保错
【练习】长方形周长计算
package Test;
public class Test01 {
public static void main(String[] args) {
length(3, 5);
length(3.5, 5.5);
}
public static void length(double len, double width){
double result = (len+width)*2;
System.out.println(result);
}
}
【练习】圆面积计算
package Test;
public class Test02 {
public static void main(String[] args) {
getArea(2);
getArea(6);
}
public static void getArea(double radius){
double result = radius * radius * 3.14;
System.out.println(result);
}
}
带返回值的方法定义和调用
- 调用处拿到方法的结果之后，才能进行下一步操作
- 方法的返回值其实就是方法运行的最终结果
- 如果在调用处要根据方法的结果，去编写另外一段代码逻辑
- 为了在调用处拿到方法产生的结果，就需要定义带有返回值的方法。
-
定义
public static 返回值类型 方法名 (参数) { 方法体; return 返回值; }public static int getSum(int a, int b){ int c = a + b; return c; } -
调用
-
直接调用
方法名(实参)对方法的返回值不进行任何操作
-
赋值调用
整数类型 变量名 = 方法名(实参) -
输出调用
System.out.println(方法名(实参))
-
package MethodsDome;
public class MethodsDemo05 {
public static void main(String[] args) {
// 直接调用
getSum(10, 20, 30);
// 直接调用
int sum = getSum(10, 20, 30);
System.out.println(sum);
// 直接调用
System.out.println(getSum(10, 20, 30));
}
public static int getSum(int num1, int num2, int num3) {
int result = num1 + num2 + num3;
return result;
}
}
这个很像C语言和python的函数，C语言我可能有点忘记，但都是有函数的
-
【练习】人肉计算机
需求：定义一个方法，求一家商场每个季度的营业额。 根据方法结果再计算出全年营业额。
package MethodsDome; public class MethodsDemo05 { public static void main(String[] args) { int sum1 = getSum(10, 20, 30); // 第一季度 int sum2 = getSum(40, 50, 60); // 第一季度 int sum3 = getSum(70, 80, 90); // 第一季度 int sum4 = getSum(100, 110, 120); // 第一季度 int sum = sum1 + sum2 + sum3 + sum4; // 全年 System.out.println(sum); } public static int getSum(int num1, int num2, int num3) { int result = num1 + num2 + num3; return result; } }
练习
比较大小
需求：定义方法，比较两个长方形的面积
package Test;
public class Test03 {
public static void main(String[] args) {
double A = getArea(3, 4);
double B = getArea(2, 5);
if (A > B){
System.out.println("长方形A比长方形B的面积大");
}else{
System.out.println("长方形B比长方形A的面积大");
}
}
public static double getArea(double len, double width){
double result = len * width;
return result;
}
}
小总结
方法的注意事项
方法不调用就不执行
方法与方法之间是平级关系，不能相互嵌套定义
方法的编写顺序和执行顺序无关
方法的返回值类型为
void表示该方法没有返回值没有返回值的方法可以省略return语句不写
如果要编写return，后面不能跟具体的数据
return语句下面，不能编写代码，因为永远执行不到，属于无效的代码
return
- 方法没有返回值，可以省略不写，如果书写，表示结束方法
- 方法有返回值，必须要写，表示结束方法和返回结果
- return不能单独存在，一定要写在方法的里面。
其实这个方法不是难，就是换了个名字，从我认识的函数变成了方法。可以这么认为。
对一段代码进行封装，重复利用。然后没了，
整数类型 变量名 = 方法名(实参)
这个赋值调用变量的数据类型我感觉老师讲错了。
方法返回的是什么数据类型，那么定义接收数据的变量数据类型也应该和方法返回值的数据类型一样
数据类型 变量名 = 方法名(实参)
方法的重载
概念
- 在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能
- 每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系。
简单记忆
同一个类中，方法名相同，参数不同的方法。与返回值无关。
参数不同：个数不同、类型不同、顺序不同
这个怎么理解呢，咱们不提C语言了。就说python，定义多个函数时，函数名不能说相同的，而Java是允许的，重载我想着是要学习多个方法怎么加载到栈里面，不是，重载讲的是重复的意思。
比如说，有这么一个需求，定义两个数相加、三个数相加，四个数…，或者是小数
如果不用重载这么一个概念。
package MethodsDome;
public class MethodsDemo06 {
public static void main(String[] args) {
}
// 两个数相加
public static int sumTwo(int a, int b) {
return a + b;
}
// 三个数相加
public static int sumThree(int a, int b, int c) {
return a + b + c;
}
// 四个数相加
public static int sumFour(int a, int b, int c, int d) {
return a + b + c + d;
}
// 两个小数相加
public static double sumTwodecimals(double a, double b) {
return a + b;
}
}
使用重载
package MethodsDome;
public class MethodsDemo06 {
public static void main(String[] args) {
}
// 两个数相加
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;
}
// 两个小数相加
public static double sum(double a, double b) {
return a + b;
}
}
他这样是不会报错欸。这里给Java加分，python想函数名我都想半天。但要注意是相同功能的方法、。
虚拟机是怎么区分方法
Java虚拟机会通过参数的不同来区分同名的方法
因为实参和形参是一致的
所以当我调用sum(10, 20) 那么虚拟机会找两个数相加的方法， 同样sum(10, 20, 30) 时，那就是三个数相加。
练习
方法重载
需求：使用方法重载的思想，设计比较整数是否相同的方法
要求：兼容权整数类型（byte、short、int、long）
package Test;
public class Test4 {
public static void main(String[] args) {
compare((byte) 10, (byte)20);
compare(10, 20);
}
// byte
public static void compare(byte a, byte b) {
System.out.println("byte");
System.out.println(a==b);
}
// short
public static void compare(short a, short b) {
System.out.println("short");
System.out.println(a==b);
}
// int
public static void compare(int a, int b) {
System.out.println("int");
System.out.println(a==b);
}
// long
public static void compare(long a, long b) {
System.out.println("int");
System.out.println(a==b);
}
}
数组遍历
需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11,22,33,44,55]
package Test;
public class Test05 {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
printArr(arr);
}
public static void printArr(int[] arr) {
System.out.print("{");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length-1){
System.out.print(arr[i]);
}else {
System.out.print(arr[i] + ", ");
}
}
System.out.print("}");
}
}
要注意这个输出格式哟。
数组最大值
需求：设计一个方法求数组的最大值，并将最大值返回
package Test;
public class Test06 {
public static void main(String[] args) {
int[] arr = {18, 54, 11, 39, 30};
System.out.println(maxArr(arr));
}
// 找最大值方法
public static int maxArr(int[] arr) {
// int max = 0; // 存放最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
}
我一开始是让max=0 ，老师的是让max=arr[0] 数组第一个元素。都可以实现。
判断是否存在
定义一个方法判断数组中的某一个数是否存在，将结果返回给调用处
package Test;
public class Test07 {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
boolean result = containsArr(arr, 33);
System.out.println(result);
}
public static boolean containsArr(int[] arr, int num) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
return true;
}
}
return false;
}
}
这里应该需要注意break和return用法
return
其实跟循环没有什么关系，跟方法有关的，表示1，结束方法，2，返回结果
如果方法执行到了return，那么整个方法全部结束，里面的循环也就结束了。
break
其实跟方法没有什么关系，用于结束循环或者swicth
为什么说这个。
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
return true;
}
}
为什么不写成
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
return true;
}else{
return false;
}
}
- break：结束整个循环
- return：结束方法。
这么一写，这个循环只是执行一遍，找到了那就是找到了，找不到那也就找不到了。因为遇到了return。
复制数组
需求： 定义一个方法
copyofRange(int[] arr, int from, int to)功能：
将数组arr中从索引from（包含from)开始。 到索引to结束（不包含to)的元素复制到新数组中， 将新数组返回。
package Test;
public class Test08 {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55, 66, 77, 88, 99, 0};
int[] newArr = copyofRange(arr, 2, 6);
printArr(newArr);
}
// 复制数组方法
public static int[] copyofRange(int[] arr, int from, int to) {
int[] newArr = new int[to-from];
int index=0;
for(int i = from; i <to; i++) {
newArr[index] = arr[i];
index++;
}
return newArr;
}
// 数组遍历方法
public static void printArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
我偷个懒，把第一题我第一次写的方法复制了过来。这也就可以看出来写方法就是为了减少代码重复利用
输出语句记录
System.out.println("abc"); // 先打印abc，在进行换行
System.out.print("abc"); // 只打印abc，不换行
System.out.println(); // 不打印，换行
冒泡排序（优化）
// 冒泡排序方法从
public static int[] sortArr(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
// 内循环，控制次
for (int j = 0; j < arr.length - 1 - i; j++) {
// 比较相邻的两个元素
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
以后需要的时候直接copy，就不用造轮子了。哈哈哈
方法的内存
首先温故一下前一篇学习笔记的部分内容，每一个软件打开，都是需要占用一定的内存空间。Java也是这样。
可Java会利用这块空间，把整体又分成了五个部分，栈、堆、方法区、本地方法栈、寄存器。
我把那两张贴过来。
- 找：方法运行时使用的内存。比如main方法运行，进入方法栈中执行。
- 堆：存储对象或者数组。new来创建的，都存储在堆内存
因为学习的是方法，使用重点放在栈上，这两条概念是要明白的。
方法调用的基本内存原理
-
只有一个主方法
public class MethodsDemo07 { public static void main(String[] args) { int number = 10; System.out.println("number的值为：" + number); } }这段代码不陌生，并且只有一个主方法，程序怎么运行呢，方法进栈，然后再栈里面开辟一块小空间，存放number变量，方法执行完，方法出栈。
这张图很熟悉，方法执行完毕，方法出栈、变量也就消失
-
多方法
先说规律，先进后出
什么意思呢，这就和子弹弹夹是一个道理，先装进行的子弹最后打出。
我们现在有3个方法，方法1、方法2和方法3
这里不讲究先来后到，我先进去，我先走，谁最后一个进行谁第一个走，谁第一个进去，谁最后一个走。
挤公交是不是这么一个道理，你先上车了，陆陆续续也有人上来，等下车的时候，必须是你前面的人先走开，不然把你堵得死死的你怎么下来。
看这段代码
public class MethodsDemo08 { public static void main(String[] args) { eat(); } public static void eat() { study(); System.out.println("吃饭"); sleep(); } public static void sleep() { System.out.println("睡觉"); } public static void study() { System.out.println("学习"); } }
首先，main方法第一个进入栈，主方法。然后再主方法里面调用了eat()方法，因此，eat()方法加载到栈。
又有再eat()方法里面调用了study()方法，所以study方法加载到栈。
study方法里面有一条输出语句。输出学习。study()方法执行完毕，出栈
因为eat()方法没有执行完，所以接着执行，往下走
因为eat()方法没有执行完，所以回到了eat()方法。执行输出语句后，接着调用sleep()方法。然后执行sleep()方法里面的输出语句。
到此可以看到方法全部执行完毕，那么怎么出去呢。
sleep方法先出去，之后eat、主方法最后。
以上的演示，就是一个或多个方法的进栈出栈的情况，其实不难理解，现在还是属于顺序结构程序，跟着顺序看都是可以想明白的。方法调用就要进栈，结束出栈。你要坐公交，那就上车，不坐公交，下车。
方法传递基本数据类型的内存原理
基本数据类型和引用数据类型
-
基本数据类型
变量中存储真实的数据
四类八种，整数、小数、字符、布尔值
这些都是没有问题的，同时我们再看看他们的内存
package Test; public class Demo { public static void main(String[] args) { int a = 10; double b = 13.14; } }
这张图已经不陌生了，即使变量一会一变。
在内存中分别给变量a、b各自开辟一看空间，然后限定数据类型、值
a、b变量里面存储的数据是在变量中真实存在的。
就是说变量a里面就是10、变量b里面就是13.14，如果还有变量，那么变量里面就是这个值。不是别的，为什么说不是别的
（我想猜测一下。基本数据类型和引用数据类型的不同就是基本数据类型只是用到了栈，堆不参与。变量里面存储的是真实的数据。然后再看数组的定义，变量存储的不是数组，而是一个地址，起到指引的作用。这里是我的一个猜测，一会见分晓。）
-
引用数据类型
变量中存储的是地址值
引用：使用了其他空间中的数据
package ArrayDemo; public class ArrayDemo06 { public static void main(String[] args) { // 定义一个数组 int[] arr = new int[2]; System.out.println(arr); // [I@776ec8df } }
这个图片并不陌生，然后我大概也是猜对了。
int[] arr中的arr存储的不是数组的元素，而是数组的地址。
从内存的角度去接释
-
基本数据类型
数值是存储在自己的空间中，
赋值给其他变量，也赋的是真实的值
写个代码
int a = 10; int b = a; b = 20;执行这段代码，他就会在栈内存里给自己开辟一块空间，独立的。这块空间叫a，存放的是整数类型10。
当执行
int b = a;同样开辟空间。然后我让b = 10;因为空间是独立的，你就改变不了其他变量。 -
引用数据类型
数值是存储在别的空间中，
自己空间存储的的地址值，
int[] arr1 = {1, 2, 3}; int[] arr2 = arr1; arr2[1] = 4;这个又是怎么理解。
首先要明白数组定义的两种格式，把这个转换成完整格式就撒
int [] arr = new int[]{1, 2, 3};看到了new，那就是要在堆空间里面开辟内存存放数组。那此时arr1收到的就不是真实数据，而是数组在堆内存的地址值。arr1 = 10100111这是个十六进制。arr2 = arr1;就是把arr1的地址值赋给了arr2，arr2 = arr1 = 10100111arr2 [1] = 4通过地址找元素，因为和arr1共有一个元素，所以arr1也会被改变
基本数据类型：有自己的空间，不会被其他变量改变，存储的是真实的数据
引用数据类型：没有自己的空间，存储的是地址值，如果有变量共用一个地址值，容易改变。
方法的值传递
-
方法传递基本数据类型的内存原理
传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值。
package Test; public class Demo { public static void main(String[] args) { int number = 10; System.out.println("调用change方法前：" + number); // 10 change(number); System.out.println("调用change方法后：" + number); // 10 } public static void change(int number) { number = 20; } }看这段代码的值，首先可以确定一点的是堆内存不参与，没有new。
这是个基本数据类型。变量各自有自己的空间。
main方法进栈，开辟一块空间存放number的值，然后打印输出。当执行到change方法时，100赋值给了change里的number为100。但是因为是基本数据类型，两个方法的number变量的值并不会互相影响，所以没有发生改变。
因为都是在各自的空间完成的赋值，所以互不影响
package Test; public class Demo { public static void main(String[] args) { int number = 10; System.out.println("调用change方法前：" + number); // 10 number = change(number); System.out.println("调用change方法后：" + number); // 20 } public static int change(int number) { number = 20; return number; } }这样就要发生改变。number空间里的值一开始是10， 然后我又重新赋值，20
-
方法传递引用数据类型的内存原理
传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值。
package Test; public class Demo { public static void main(String[] args) { int[] arr = {10, 20, 30}; System.out.println("调用change方法前：" + arr[1]); // 20 change(arr); System.out.println("调用change方法后：" + arr[1]); // 200 } public static void change(int[] arr) { arr[1] = 200; } }这个就不一样了。用到了堆，虽然是在各自的方法里创建的arr，但是他们都在指向的一个地址。然后又回到了上面。
浅说一下这两种的传递方式
基本数据类型的方法传递像是
int a = 10;
int b = a;
而引用数据类型
int[] arr1 = {11, 22, 33};
int[] arr2 = arr1;
这么一看，又回到了前面，柳暗花明。
总结
什么是方法，相当于函数，不过方法定义在类里面，最后这点是我百度的。总觉得方法和函数特别相似，但我又没有证据。就是定义，然后调用。在这里又要提到一个重载的概念，在python中我根本不敢定义两个相同name的函数，一堆错，而Java不祥之，但有条件，参数不能一样，这点好评，不用为英语差发愁了。
然后就是方法的内存，这里需要重点学习一下。基本数据类型和引用数据类型。他们在内存里面是怎么存在的，前者互不干扰，后者就不一样了。然后是方法传递内存原理，看着很复杂，其实自己画画图，也就明白了。
好了，我的学习笔记到此结束。
里面肯定有许许多多的bug，欢迎大家指出！毕竟这样成长更快。
也感谢大家可以看到这样，如果帮到了你，是我的荣幸。
谢谢大家！
mber空间里的值一开始是10， 然后我又重新赋值，20
-
方法传递引用数据类型的内存原理
传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值。
package Test; public class Demo { public static void main(String[] args) { int[] arr = {10, 20, 30}; System.out.println("调用change方法前：" + arr[1]); // 20 change(arr); System.out.println("调用change方法后：" + arr[1]); // 200 } public static void change(int[] arr) { arr[1] = 200; } }这个就不一样了。用到了堆，虽然是在各自的方法里创建的arr，但是他们都在指向的一个地址。然后又回到了上面。
[外链图片转存中…(img-CqSDJCLl-1660448675301)]
浅说一下这两种的传递方式
基本数据类型的方法传递像是
int a = 10;
int b = a;
而引用数据类型
int[] arr1 = {11, 22, 33};
int[] arr2 = arr1;
这么一看，又回到了前面，柳暗花明。
总结
什么是方法，相当于函数，不过方法定义在类里面，最后这点是我百度的。总觉得方法和函数特别相似，但我又没有证据。就是定义，然后调用。在这里又要提到一个重载的概念，在python中我根本不敢定义两个相同name的函数，一堆错，而Java不祥之，但有条件，参数不能一样，这点好评，不用为英语差发愁了。
然后就是方法的内存，这里需要重点学习一下。基本数据类型和引用数据类型。他们在内存里面是怎么存在的，前者互不干扰，后者就不一样了。然后是方法传递内存原理，看着很复杂，其实自己画画图，也就明白了。
好了，我的学习笔记到此结束。
里面肯定有许许多多的bug，欢迎大家指出！毕竟这样成长更快。
也感谢大家可以看到这样，如果帮到了你，是我的荣幸。
谢谢大家！
413
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
