Java基础 --- 方法
方法什么是方法
[*]方法（method）是程序中最小的执行单元。
[*]实际应用当中，将重复的方法打包
[*]提高代码的复用性
[*]提高代码可维持性
总结：
[*]什么是方法?
方法是程序中最小的执行单元。
[*]实际开发中，什么时间用到方法?
重复的代码、具有独建功能的代码可以抽取到方法中。
[*]实际开发中，方法有什么好处?
[*]可以提高代码的复用性
[*]可以提高代码的可维护性
方法的格式
把一些代码打包在一起，用到的时间就调用
方法定义
把一些代码打包在一起，该过程称为方法定义。
方法的定义格式
public static 返回值类型 方法名 (参数) {
方法体;
return 返回体;
}方法调用
方法定义后并不是直接运行的，需要手动调用才华执行，该过程称为方法调用。
最简单的方法定义和调用
格式（方法）：
public static void 方法名 (){
方法体 (就是打包起来的代码);
}范例（方法）：
public static void playGame (){
七个打印语句;
}格式（调用）：
方法名 ();范例（调用）：
playGame ();注意：方法必须先定义后调用，否则程序将报错
public class MethodDemo1 {
public static void main(String[] args) {
//目标：掌握最简单的方法定义和调用的格式
//调用方法
playGame();
}
//定义一个方法
public static void playGame(){
System.out.println("选人物");
System.out.println("准备开局");
System.out.println("对线");
System.out.println("崩盘");
System.out.println("崩盘");
System.out.println("骂队友");
System.out.println("送人头");
System.out.println("GG");
}
}练习
展示女朋友的信息
需求：定义一个方法，在方法内部打印你女朋友的全部信息。
public class MethodDemo2 {
public static void main(String[] args) {
//目标：利用方法最简单的格式完成当前练习
//调用方法
printGFInfo();
}
public static void printGFInfo(){
System.out.println("柳如烟");
System.out.println("校花");
System.out.println("18岁");
}
}人肉计算机
需求：定义一个方法，在方法内部定义两个变量。
求出他们的和并举行打印。
public class MethodDemo3 {
public static void main(String[] args) {
//目标：利用方法最简单的格式完成当前练习
//需求：在方法内部定义两个变量并求和打印
getSum();
}
public static void getSum(){
int num1 = 10;
int num2 = 20;
int result = num1 + num2;
System.out.println(result);
}
}带参数的方法的定义和调用
单个参数（方法）
格式：
public static void 方法名(参数){ ... ...}范例：
public static void method(int number){ ... ...}多个参数（方法）
格式：
public static void 方法名(参数1,参数2,......){ ... ...}范例：
public static void getSum(int number1,int number2){ ... ...}带参数方法（调用）
单个参数
单个参数：方法名(参数);
范例1：method(10);
范例2：method(变量);
多个参数
多个参数：方法名(参数1,参数2,......);
范例1：getSum(10,20);
范例2：getSum(变量1,变量2);
注意：方法调用时，参数的数量与范例必须与方法定义中小括号内里的变量逐一对应，否则程序将报错。
public class MethodDemo4 {
public static void main(String[] args) {
//目标：掌握带参数方法定义的格式和调用的格式
getSum(10,20);
}
public static void getSum(int num1, int num2){
int result = num1 + num2;
System.out.println(result);
}
}形参和实参
[*]形参：全称形式参数，是指方法定义中的参数
[*]实参：全称实际参数，方法调用中的参数
注意：方法调用时，形参和实参必须逐一对应，否则程序将报错。
练习
人肉计算机1
需求：定义一个方法，求长方形的周长，将结果在方法中举行打印。
public class Test1 {
public static void main(String[] args) {
//需求：定义一个方法，求长方形的周长，将结果在方法中进行打印。
//目标：根据不同的需求，荀泽定义无参的方法，还是带参数的方法
getLength(5.2,1.3);
}
//1.我要干嘛？求长方形的周长
//2.我干这件事情，需要干什么才能完成？长 宽
public static void getLength(double len,double width){
double result = (len + width) * 2;
System.out.println(result);
}
}人肉计算机2
需求：定义一个方法，求圆的面积，将结果在方法中举行打印。
public class Test2 {
public static void main(String[] args) {
//需求：定义一个方法，求圆的面积，将结果在方法中进行打印。
//目标：根据不同的需求，选择定义无参的方法，还是带参数的方法
getArea(1.5);
}
//1.我要干嘛？求圆的面积
//2.我干这件事，需要什么才能完成？ 半径的平方 * π
public static void getArea(double radius){
double result = radius * radius * 3.14;
System.out.println(result);
}
}带返回值方法的定义和调用
方法的返回值实在就是方法运行的最终结果。
[*]如果在调用处要根据方法的结果，去编写另一段代码逻辑
[*]为了在调用处拿到方法产生的结果，就需要定义带有返回值的方法
带返回值方法 定义
格式：
public staric 返回值类型 方法名 (参数){
方法体;
return 返回值;
}范例：
public static int getSum(int a,int b){
int c = a + b;
return c;
}带返回值方法的调用
[*]直接调用：
方法名(参数);
[*]赋值调用：
整数类型 变量名 = 方法名 (实参);
[*]输出调用：
System.out.println(方法名 (实参));
public class MethodDemo5 {
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;//返回给方法的调用处
}
}总结
[*]什么时间用到有返回值的方法？
在调用处要根据方法的结果，去编写另一段代码。
[*]由返回值方法的定义格式
public static 返回值类型 方法名(参数){
方法体;
return 返回值;
}
[*]有返回值方法的调用格式
直接调用，赋值调用，输出调用
[*]有返回值方法中参数的运行过程
练习
人肉计算机
需求：定义一个方法，求一家阛阓每个季度的营业额。
根据方法结果再计算出整年营业额。
public class MethodDemo5 {
public static void main(String[] args) {
//目标：掌握带返回值方法的定义和调用格式
//先计算第一个季度的营业额
int sum1 = getSum(10,20,30);
//再来计算第二个季度的营业额
int sum2 = getSum(20,30,40);
//计算第三个季度的营业额
int sum3 = getSum(20,30,40);
//计算第四个季度的营业额
int sum4 = getSum(20,30,40);
//求全年的总营业额
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;//返回给方法的调用处
}
}比力巨细
需求：定义方法，比力两个长方形的面积。
public class Test3 {
public static void main(String[] args) {
//目标：要能区分出什么时候使用带返回值的方法
//需求：定义方法，比较两个长方形的面积。
//调用方法获取长方形的面积，再进行比较
double area1 = getArea(5.3,1.7);
double area2 = getArea(2.4,2.7);
if(area1 > area2){
System.out.println("第一个长方形更大");
}else{
System.out.println("第二个长方形更大");
}
}
//定义一个方法求长方形的面积
//1.我要干什么？求长方形的面积
//2.需要什么？长 宽
//3.方法的调用处，是否需要继续使用方法的结果
//如果要用，那么方法必须有返回值
//如果不要用，方法可以写范湖只，也可以不写返回值
public static double getArea(double len,double width){
double area = len * width;
return area;
}
//在以后实际开发应用当中，我们易班是把重复的代码或者具有独立功能的代码抽取到方法当中。
//以后我们直接调用就可以了
}方法小结
方法的注意事项
[*]方法不调用就不执行
[*]方法与方法之间是平级关系，不能相互嵌套定义
[*]方法的编写次序和执行次序无关
[*]方法的返回值范例为void，表现该方法没有返回值，没有返回值的方法可以省略return语句不写。
如果要编写return，后面不能跟具体的数据。
[*]return语句下面，不能编写代码，因为永远执行不到，属于无效的代码
return关键字
[*]方法没有返回值：可以省略不写。如果书写，表现竣事方法
[*]方法有返回值：必须要写。表现竣事方法和返回结果
方法重载
[*]在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能。
[*]每个方法具有不同的参数范例或参数个数，这些同名的方法，就构成了重载关系
[*]简单记：同一个类中，方法名相同，参数不同的方法。与返回值无关。
参数不同：个数不同、范例不同、次序不同
次序不同可以构成重载，但是不建议！
练习
方法重载
需求：利用方法重载的思想，设计比价两个整数是否相同的方法。
要求：兼容全整数范例（byte,short,int,long）
public class Test4 {
public static void main(String[] args) {
/*需求：使用方法重载的思想，设计比价两个整数是否相同的方法。
要求：兼容全整数类型（byte,short,int,long）
*/
//调用
compare(10,20);
compare((byte) 10,(byte) 20);
byte b1 = 10;
byte b2 = 20;
compare(b1,b2);
}
//会把相同功能的方法名起成一样的名字
//好处1；定义方法的时候可以不用那么多的单词了
//好处2：调用方法的时候也不需要那么麻烦了。
public static void compare(byte b1,byte b2){
System.out.println(b1 == b2);
}
public static void compare(short s1,short s2){
System.out.println(s1 == s2);
}
public static void compare(int i1,int i2){
System.out.println(i1 == i2);
}
public static void compare(long n1,long n2){
System.out.println(n1 == n2);
}
}练习
数组遍历
需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：
public class Test5 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {11,22,33,44,55};
//2.调用方法遍历数组
printArr(arr);
}
//定义方法用于数组的遍历
//1.我要干嘛？ 遍历数组
//2.我干这件事需要什么才能完成？ 数组
//3.方法的调用处是否需要继续使用结果？ 不需要返回值
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);
}else{
System.out.print(arr + ", ");
}
}
System.out.println("]");
}
}数组最大值
需求：设计一个方法求数组的最大值，并将最大值返回
public class Test6 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {1,2,3,4,5};
//2.调用方法求最大值
int max = getMax(arr);
//3.打印
System.out.println(max);
}
//1.我要干嘛？ 求最大值
//2.我干这件事，需要什么才能完成？ 数组
//3.是否返回？ 返回
public static int getMax(int[] arr){
int max = arr;
for (int i = 1; i < arr.length; i++) {
if(arr > max){
max = arr;
}
}
return max;
}
}判断是否存在
需求：定义一个方法判断数组中的某一个数据是否存在，将结果返回给调用处
public class Test7 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {1,2,3,4,5};
//2.判断一个数字在数组中是否存在
boolean flag = contains(arr,4);
System.out.println(flag);
}
//1.我要干嘛？
//2.我干这件事，需要什么才能完成？ 数组 数字
//3.调用处是否需要继续使用结果？ 返回 true false
public static boolean contains(int[] arr,int number){
for (int i = 0; i < arr.length; i++) {
if(arr == number){
return true;
}
}
//什么时候数字在数组中是不存在的
//当数组里面所有的数据全部比较完毕之后
return false;
//return break 关键字的区别
//return：其实跟循环没有什么关系，跟方法有关，表示1结束方法 2返回接过
// 如果方法执行到了return，那么整个方法全部结束，里面的循环也会随之结束
//break关键字
//其实跟方法没有什么关系，结束循环或者switch。
}
}复制数组
需求：定义一个方法copyOfRange(int[] arr,int from,int to)
功能：将数组arr中从索引from（包含from）开始。到索引to竣事（不包含to）的元素复制到新数组中，将新数组返回
public class Test8 {
public static void main(String[] args) {
/*需求：定义一个方法copyOfRange(int[] arr,int from,int to)
功能：将数组arr中从索引from（包含from）开始。到索引to结束（不包含to）的元素复制到新数组中，将新数组返回
*/
//1.定义原始数组
int[] arr = {1,2,3,4,5,6,7,8,9};
//2.调用方法
int[] copyArr = copyOfRange(arr,3,7);
//3.遍历数组
for (int i = 0; i < copyArr.length; i++) {
System.out.print(copyArr + " ");
}
}
public static int[] copyOfRange(int[] arr,int from,int to){
//1.定义数组
int[] newArr = new int;
//2.把原始数组arr中的from到to上对应的元素，直接拷贝到newArr中
//伪造索引
int index = 0;
for (int i = from; i < to; i++) {
newArr = arr;
index++;
}
//3.返回
return newArr;
}
}方法的内存
方法调用的基本内存原理
[*]方法被调用之后就会进栈执行
[*]方法进栈时，先进栈的方法后出，后进展的方法先出（先进后处）
方法传递基本数据范例的内存原理
基本数据范例
[*]变量中存储的是真实的数据
引用数据范例
[*]只要是new出来的都是引用数据范例
[*]变量中存储的是所在值
[*]引用：利用了其他空间的数据
从内存的角度去解释：
[*]基本数据范例：数据值是存储在自己的空间中
[*]特点：赋值给其他变量，也是赋的真实的值
[*]引用数据范例：数据值是存储在其他空间中，自己空间中存储的是所在值
[*]特点：赋值给其他变量，赋的所在值
方法传递引用数据范例的内存处理
[*]传递基本数据范例时，传递的是真正的数据，形参的改变，不影响实际参数的值
[*]传递引用数据范例时，传递的是所在值，形参的改变，硬性实际参数的值
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]