方法基础
方法的引入
public class Test01
{
public static void main(String[] args)
{
// 需求1：编写程序计算 10 和 20 的和，并输出结果
int a = 10;
int b = 20;
int c = a + b;
System.out.println(a + "+" + b + "=" + c);
// 需求2：666 和 888 的和，并输出结果
int a = 666;
int b = 888;
int c = a + b;
System.out.println(a + "+" + b + "=" + c);
/*
以上需求代码相似实质是以一个需求，功能相同
只不过每次参与的数据不同
* 在 Java中应当有一种机制：
- 某种功能的代码只需要使用一次
- 功能间的交互，只需要传入具体数据，即可得到结果
这样的代码就可以重复利用，提高代码复用性
使用这种方法我们称为【调用/invoke】
*/
// 【调用/invoke】 sumInt方法
MethodTest.sumInt(10, 20);
MethodTest.sumInt(666, 888);
// 效果与前面代码相同
}
// 单独定义一个方法【暂时不解释方法语法】
// 作用：完成计算两个int类型数据的和，并输出结果
public static void sumInt(int a, int b)
{
int c = a + b;
System.out.println(a + "+" + b + "=" + c);
}
}
java的方法也就相当于c语言中的函数
java方法是语句的集合，它们在一起执行一个功能
- 方法包含于类体当中定义，一个类体中可以定多多个方法
- 方法体中不可以定义方法
- 方法体由Java语句构成
- 方法是解决某一类问题的有序组合【自上而下】
- 方法在程序中被创建，在其他地方被引用
- 只有被【调用/invoke】时，才会执行
方法的语法
[修饰符列表] 返回值类型 方法名(参数列表)
{
方法体
[return 返回值;]
}
//注意中括号中的内容可选
[return 返回值;] 如果没有，返回值类型为 void
只要是数据就有数据类型，所以 返回值 与 返回值类型 必须一致
语法结构解释：
- 修饰符列表
可选，不是必要
告诉编译器如何调用该方法，定义了该方法的访问类型
目前统一写为：public static
修饰符列表有 static 关键字调用格式：类名.方法名(实参列表);
实参列表：你根据实际想要传让的数据 - 返回值类型
一个方法是可以完成某一个特定功能的，这个功能结束之后大多数都需要返回最终执行的结果
返回值类型程序员需要根据实际方法制定
方法可能会没有返回值，当方法没有返回值时返回值类型是 void 同时不可以有 返回值，但可以编写 return ; - 方法名
满足标识符要求即可，最好见名知意
方法名使用小驼峰命名法，首个词最好是动词 - 参数列表：内包含形参
形参是局部变量：int a; double b; float c; String args; …
形参数量：0 ~ N
多个形参之间使用 ; 分隔
形参中起决定性作用的是形参的数据类型，形参的名字只是局部变量的名字
方法【调用/invoke】时，实际给方法传递的真实数据，被称作【实参】
形参列表与实参列表需要数据类型对应，数量对应 - 方法体
方法体必须由大括号括起来
方法体包含具体的Java语句，语句有逻辑顺序【自上而下】 - 只要带有 return 关键字的语句执行，则 return 所在的方法强制结束
假设：你想象你要办一个工厂
- 参数列表就是是你提供原料【但你还不知道具体的数值】
- 返回值类型就是你想要生成个什么【先规定个类型型号】
- 返回值就是工厂实物产出，当然也可能没有出货
- 方法名就是你要办工厂的名字
// public 表示公开的
// class 表示定义类
// Test02 一个类名
public class Test02
{
// 这里 类体
// 类体中不能直接编写Java语句，除说明变量
// 下面是一个方法
// public 表示公开的
// static 表示静态的
// void 表示方法执行结束后没有数据返回
// main 一个特殊的方法名【主方法】
// (String[] args) ：形式参数列表，其中String[]是一种数据类型【字符串】，args是一个局部变量的变量名
// 主方法的编写是固定的，因为这是 SUN公司 所规定的，表示程序的入口
public static void main(String[] args)
{
// 这里 方法体
int num;
// 调用方法sumInt()的计算10 和 20求和并输出结果，返回求和
num = MethodTest02.sumInt(10, 20); // (10, 20) 是实参列表
System.out.println("从方法中返回的和： " + num);
// 再次调用
num = MethodTest02.sumInt(num, 10); // (num, 10) 是实参列表
MethodTest02.sumInt(10, 20); // 返回值的接收与否可以根据情况选择
}
// 下面是一个自定义的方法
// 方法作用：计算两个int数据的和，输出计算结果并返回和
// 写一个方法之前需要进行规划
// 修饰符类型：public static
// 方法名：sum 求和的意思
// 形式参数列表：(int a, int b) 要求是两个int数据
// 返回值类型：int 返回值是两个int数据的和，计算后的和仍旧是int
// 方法体：主要是求和，输出计算结果并返回和
public static int sumInt(int a, int b)
{
// (int a, int b) 是形参列表
int c = a + b;
System.out.println("调用方法sumInt的输出： " + c);
return c;
}
}
方法的调用
/*
方法调用
*/
public class Test03
{
public static void main(String[] args)
{
// 调用方法
Test03.m();
// 对于方法的修饰符列表当中有static关键字： “类名.”可以省略
m();
// 调用其他类【不是本类中的】方法
A.doOther();
// 测试省略
// doOther(); 编译报错
}
public static void m()
{
System.out.println("m method execute !")
m2(); // 在本类中，编译通过
}
public static void m2()
{
System.out.println("m2 method execute !")
}
}
class A
{
public static void doOther()
{
System.out.println("A's doOther method invoke !")
// m2(); 报错 m2()方法 不在 类A 中不能直接调用
}
}
- 注意：Java的方法在同一个类中调用，可以省略 类名.
方法的执行
public class Test04
{
public static void main(String[] args)
{
System.out.println("main begin");
m1(); // main暂定等待m1执行完毕，进入m1
System.out.println("main over");
}
public static void m1()
{
System.out.println("m1 begin");
m2(); // m1暂定m2执行完毕，进入m2
System.out.println("m1 over");
}
public static void m2()
{
System.out.println("m2 begin");
System.out.println("m2 over");
}
}
/*
结果分析：
main begin
m1 begin
m2 begin
m2 over
m1 over
main over
main方法最先调用，main方法也是最后结束
最后调用的是m2方法，该方法最先结束
*/
注意：
- 方法中的代码是自上而下的顺序执行即可
- 当前程序没有结束，下一行代码是无法执行
return语句相关
- 带有return关键字的java语句只要执行，那么所在方法结束
- 在“同一作用域”当中，return语句下面不能编写的任何代码
public class Test05
{
public static void main(String[] args)
{
// hi; 报错，方法带括号
hi();
n();
}
/*
public static int m(int a)
{
if (a > 10)
{
return 1;
}
}
编译器报错：缺少返回语句，
程序无法保证 "return 1;" 百分之百会执行
*/
public static int m()
{
int a = 10;
if (a > 10)
{
return 1; // 作用域 if
}
else
{
return 0; // 作用域 else
}
}
public static int n()
{
int a = 10;
if (a > 10)
{
return 1; // 作用域 if
// System.out.println("Hello"); 报错
}
System.out.println("Hello"); // 通过
return 0; // 通过
}
public static void hi()
{
System.out.println("Hi")
}
}
- 返回值类型中是void的方法当中使用 return ;
public class Test05
{
public static void main(String[] args)
{
m();
}
public static void m()
{
for(int i = 0; i < 10; i++)
{
if(i == 5)
{
return ; // 不是终止for循环，是终止 m() 方法
// 区别 break; 是终止for循环
}
System.out.println("i --> " + i);
}
System.out.println("Hello World!");
}
}
关于JVM的内存分配问题
-
方法只是定义，不调用，是不会执行的；JVM 中也不会给该方法分配“运行所属”的内存空间
-
在JVM内存划分有三块主要的内存空间（除此之外还有）：
~~~~~~~~~~ 方法区内存
~~~~~~~~~~ 堆内存
~~~~~~~~~~ 栈内存 -
关于栈数据结构：
~~~~~~~~~~ 栈：stack，是一种数据结构
~~~~~~~~~~ 数据结构反应是数据的存储形态
~~~~~~~~~~ 数据结构是独立的学科，不属于任何编程语言的范畴
~~~~~~~~~~ 作为程序员需要提前精通：数据结构 + 算法【计算机专业必修】
~~~~~~~~~~ 常见数据结构：
~~~~~~~~~~~~~~~~~~~~ 数组
~~~~~~~~~~~~~~~~~~~~ 队列
~~~~~~~~~~~~~~~~~~~~ 栈
~~~~~~~~~~~~~~~~~~~~ 二叉树
~~~~~~~~~~~~~~~~~~~~ 哈希表
~~~~~~~~~~~~~~~~~~~~ . . . . . . -
关于【栈/Stack】
~~~~ 基础成分：栈顶元素，栈底元素，栈帧
~~~~~~~~~~ 栈帧永远指向栈顶元素
~~~~~~~~~~ 栈顶元素处于活跃状态，其它元素静止
~~~~~~~~~~ 术语：
~~~~~~~~~~~~~~~~~~~~ 压栈/入栈/push
~~~~~~~~~~~~~~~~~~~~ 弹栈/出栈/pop
~~~~~~~~~~ 栈数据结构存储数据的特点是；
~~~~~~~~~~~~~~~~~~~~ 先入后出
~~~~~~~~~~~~~~~~~~~~ 后入先出 -
方法代码片段存在哪里？方法执行的时候执行过程的内存在哪里分配
~~~~~~~~~~ 方法代码片段属于.calss字节码文件的一部分，字节码文件在类加载的时候，将其存放在方法区当中。所以JVM中的三块主要内存空间中方法区内存最先有数据。存放了代码片段。
~~~~~~~~~~ 代码片段虽然在方法区内存当中只有一份，但是可以被重复调用。每一次调用这个方法的时候，需要给该方法分配独立的活动场所，在栈内存中分配。【栈内存中分配方法运行的所属内存空间】
描述：方法在调用的瞬间，会给该方法分配内存空间，会在栈中会发生压栈动作，方法执行结束之后，给该方法分配的内存空间全部释放，此时发生弹栈动作
~~~~~~~~~~
~~~~~~
压栈：给方法分配内存
~~~~~~~~~~
~~~~~~
弹栈：释放该方法的内存空间
- 局部变量在方法体在声明，局部变量在运行阶段内存在栈中分配
可以解释为什么局部变量生命周期最短，出了大括号就无法使用，因为方法结束后，进行弹栈释放该方法的内存空间，局部变量同样随方法一同释放
结合栈回顾前面方法程序执行示例v
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
