JAVA学习之路--基础篇四

最新推荐文章于 2023-03-22 21:07:38 发布

爱吃咸鱼的鸟

最新推荐文章于 2023-03-22 21:07:38 发布

阅读量154

点赞数

分类专栏： java最最基础

本文链接：https://blog.csdn.net/qq_45594960/article/details/108433767

版权

java最最基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

什么是方法？

1、方法是完成某个功能的一组语句，通常将某个功能写成一个方法

2、定义方法就是编写有特定功能的一段代码，在程序中使用同样功能的地方可以调用定义好的方法，实现代码的重用

方法语法结构：
  【修饰符列表】 返回值类型 方法名(形式参数列表){
       方法体;
      // return跟你的返回值类型有关，
      // 如果返回值类型是void，那么不加return
       [return[返回值];]
  }

怎么调用方法？

在主方法[main方法]里面直接调用方法

调用方法语法：类名.方法名(实际参数列表);

当修饰符列表有 “static” 关键字的话，可以不用写类名

返回值类型

1，什么是返回值？

一个方法为了完成某一特定的功能，当该功能结束后，其返回执行结果，并且该结果可能为某一具体存在的数据，这个存在的数据称之为返回值

2，返回值的具体类型

返回值是一个具体存在的数据，因此需要定义返回值类型；具体类型可以为基本数据类型和所有引用数据类型

如果某一个方法执行结束后不返回任何数据，那么则需要编写：void关键字;初此之外，必须返回数值且返回数值与所定义的数据类型相一致；否则编译器报错

返回值语法结构：
    【修饰符列表】 返回值类型 方法名(形式参数列表){
         方法体;
      return 值;//当关键字为void时，不写返回值
    }

数据类型可以为：
byte short int long float double boolean char String void…

3，方法名：

合法的标识符，最好做到见名知意，首字母要求小写，后面每个单词首字母要求大写，遵循驼峰命名规则

4，形式参数列表：

形参为局部变量，形参个数可以为多个，每个形参之间用逗号隔开

形参名字为一个标识符，其决定性作用的为其数据类型

方法在调用的时候。实际给这个方法传递的真实数据为实际参数，简称：实参

5，方法体：

方法体必须由大括号“{ }”括起来，由Java语句构成，遵循自上而下的代码执行顺序

如以下代码：

public class MethodText01
{
 
 public static void main(String[] args){
 
           MethodText01.sum(1,2); //调用方法sum
 }
 
  //定义方法sum
 public static void sum(int a,int b){
 //给定变量从c，将变量a与b相加之后的值赋值给c
  int c=a+b;
  System.out.println("两数之和为："+c);  //输出变量c的值
     }
  }

输出结果：
在这里插入图片描述
分析：

方法实例

试分析以下输出结果：


/*分析以下程序输出结果
   m1 begin
   m2 begin
   m3 begin
   m3 over
   m2 over
   m1 over
*/

public class MethodText02
{
	
	public static void main(String[] args){
	
	   System.out.println("m1 begin");
	   m1();
	   System.out.println("m1 over");
	}
	public static void m1(){
	   System.out.println("m2 begin");
	   m2();
	   System.out.println("m2 over");
	}
	public static void m2(){
	   System.out.println("m3 begin");
	   System.out.println("m3 over");
	}
}

输出结果：
在这里插入图片描述
分析：

在这里插入图片描述

方法在JVM中的内存的分配与变化：

1，方法只定义，不调用，不会执行；并且在JVM中不分配运行所属的内存空间

2，在JVM内存划分上有这样三块主要内存空间：
方法区
栈区
堆区

3，方法代码片段存在哪里？方法执行的过程中内存在哪里分配？

方法代码片段属于.class字节码文件的一部分，字节码文件在类加载的时候，将其放到了方法区当中。所以JVM中的方法区内存最先有代码片段

代码片段只有1份，但可重复调用;在调用过程中，需要给该方法分配独立的活动场所，

在栈内存中分配【栈内存中分配方法运行的所属空间】

方法在调用的时候，会给该方法分配独立的内存空间，在栈中分配，此时发生压栈动作，方法执行结束之后，给该方法分配的内存空间全部释放，此时发生弹栈动作

  栈遵循：先进后出原则
  压栈：给方法分配内存
  弹栈：给方法释放内存空间

局部变量在方法体中声明，局部变量运行阶段内存存储在栈中

例：计算1~n的和：使用方法
要求：在控制台输入具体的n

public class RecursionText02 
{
	public static void main(String[] args) 
	{
		java.util.Scanner s=new java.util.Scanner(System.in);
		System.out.printf("请输入您要计算的前几项的和【从1~n】：");
	    int n=s.nextInt();
		System.out.println("1~"+n+"的和为:"+sum(n));
		
	}
	public static int sum(int n){
		int reasurt=0;
			for(int i=0;i<=n;i++)
		{
			reasurt+=i;
		}
	return reasurt;
}
}

运行结果：
在这里插入图片描述

例如：
班里有5名同学，分别有java，web两门课程，统计每门课程的平均分，和总分，统计每名同学的平均分和总分

public class SumText{
	public static void main(String[] args) {
		java.util.Scanner s=new java.util.Scanner(System.in);
		System.out.print("请输入学生个数：");
		int xs=s.nextInt();
		System.out.print("请输入科目数量：");
		int km=s.nextInt();
		int[][]arr=new int[xs][km];
		for(int i=0;i<xs;i++){
			for(int j=0;j<km;j++){
				System.out.println("请输入第"+(i+1)+"个学生；第"+(j+1)+"门功课成绩：");
				arr[i][j]=s.nextInt();
			  }
			  java.util.Arrays.toString(arr);
			  /*

			   1.Arrays.toString(a)方法是是用来将数组a转换成String类型输出，
			  入参可以是long，float，double，int，boolean，byte，object
               型的数组，使用此方法可以很方便地输出数组，而不用一个一个地输出数组元素。

               2.a.toString()方法只会打印出数组的地址。

              */
              }
		  sum(arr);
		  average(arr);
		  sum1(arr);
		  average1(arr);
}
*求每一个学生的和*/
      public static void sum(int [][]arr)
      {
	
        
	     for(int i=0;i<arr.length;i++)
           {   
           	   int sum=0;
	          for(int j=0;j<arr[i].length;j++)
	          {
		      sum+=arr[i][j];
	          }

              System.out.println("您输入的第"+(i+1)+"个学生的总分:"+sum);

           }

       }
       /*求每一个学生的平均分*/
public static void average(int [][]arr){
	
	for(int i=0;i<arr.length;i++)
{     int sum=0;
	for(int j=0;j<arr[i].length;j++){
		sum+=arr[i][j];
	}
     double average=(double)sum/(arr[i].length);
	System.out.println("您输入的第"+(i+1)+"个学生的平均分:"+average);
}

}

/*求科目总分：*/

public static void sum1(int [][]arr){
	int sum=0;
	for(int i=0;i<arr.length;i++)
{     
	for(int j=0;j<arr[i].length;j++){
		sum+=arr[i][j];
	}
	
}
System.out.println("您要求的科目的总分为："+sum);
}

/*求两门科目的平均分：*/

public static void average1(int [][]arr){
	int sum=0;
	double average=0;
	for(int i=0;i<arr.length;i++)
{     
	for(int j=0;j<arr[i].length;j++){
		sum+=arr[i][j];

	}
	 
	 average=(double)sum/(arr[i].length);
    
}
  System.out.println("您要求的科目的平均分为:"+average);
}


}

输出结果如下：
在这里插入图片描述

方法重载

方法重载：overload

功能虽然不同，但是功能相似的，可以使用同一种方法，来完成多种方法相同的执行结果

1，什么时候用方法重载？

功能相似的时候，尽可能让方法名相同，功能不同的时候，尽可能方法名不同

2，什么条件满足了以后构成方法重载？

在同一类当中
方法名相同
参数列表不同：-数量不同 -顺序不同 -类型不同

3，方法重载和什么有关系？和什么没关系？

和方法名+参数列表有关
和返回值类型无关
和修饰符列表无关

例如：

public class OverloadText01
{
	public static void main(String args[]){
		m1();
		m1(1,2);
		m2(2,3);
		m2(5.0);
		m3(1,2.0);
		m3(1.0,2);
		m4(1,2);
		m4(1.0,2.0);
		m5(3,4);    
	}
	//以下两个方法构成方法重载
	//在同一类当中，方法名相同
	public static void m1(){}
	public static void m1(int a,int b){}

	//以下两个方法构成方法重载
	//在同一类当中，方法名相同
    //参数列表：数量不同
	public static void m2(int a,int b){}
	public static void m2(double a){}

    //以下两个方法构成方法重载
	//在同一类当中，方法名相同
	//参数列表：顺序不同
	public static void m3(int a,double b){}
	public static void m3(double a,int b){}
    
	//以下两个方法构成方法重载
	//在同一类当中，方法名相同
	//参数列表：类型不同
	public static void m4(int a,int b){}
	public static void m4(double a,double b){}
public static void m5(int a,int b){}
	//public static void m5(int b,int a){}
	//在方法中起决定性作用的为参数数据类型，而不是数据名
    //这叫方法重复，会报错！
	/*OverloadText02.java:55: 错误: 已在类 OverloadText02中定义了方法 m5(int,int)
        public static void m5(int b,int a){}
		
                           ^
						   1 个错误
     */
}


public class OverloadText02
{
	
	public static void main(String args[]){
		//此时调用的不再是不同的方法，而是依靠不同的参数数据类型，实现不同方法调用的效果
		//同时也避免了记忆不同方法名的困难
		//这种机制叫做：方法重载
		//功能相似的时候，可以用同一种方法名
		//功能不同的时候，尽量用不同的方法名，好区分
		System.out.println(sum(1,2));
		System.out.println(sum(1.0,2.0));
		System.out.println(sum(1L,2L));

	}

	public static int sum(int a,int b){
		return a+b;  	
	}

	public static long sum(long a,long b){
		return a+b;  	
	}

    public static double sum(double a,double b){
		return a+b;  	
	}

}

方法递归


关于方法的递归调用：
       递归：在方法中调用本方法
	      m(){
			  m();
		  }

递归调用很耗费栈内存，一般不经常使用

以下程序一直运行之后，出现【Error】：
java.lang.StackOverflowError

这表明，栈内存溢出错误
该错误无法挽回，导致JVM停止工作

因此，递归调用必须有结束条件！【也有可能有结束语句，但还出现栈内存溢出现象，因为递归太深】

public class RecursionText01
{
	public static void main(String[] args){
		doSome();      
	}

	//以下的代码可以被重复调用
	//只要调用该方法，就会在栈内存中分配一块所属的内存空间
	//在方法之中调用方法，这就是递归调用
	public static void doSome(){
		System.out.println("Begin!");
		doSome();//调用方法，又会输出"Begin!"，不停止
		System.out.println("Over!");//这行代码不会输出，因为上一行代码未结束
		   
	}

}

在这里插入图片描述

使用方法递归调用求：在控制台输入具体的数字，计算1~n的和

/*
   使用方法递归调用求：在控制台输入具体的数字，计算1~n的和
*/


public class RecursionText03 
{
	public static void main(String[] args) 
	{
        java.util.Scanner s=new java.util.Scanner(System.in);
		System.out.print("请输入你要计算的前n项和的n的具体值：");
		int n=s.nextInt();
		System.out.println("1~"+n+"的和为："+sum(n));
	}
	public static int sum(int n){
		if(n==1)
		{
			return 1;      		
		}

		return n+sum(n-1);
	}
}

运行结果：
在这里插入图片描述

只是因遇见了程序
便
运行了今生
…

爱吃咸鱼的鸟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA学习之路--基础篇四

目录方法方法方法语法结构：【修饰符列表】返回值类型方法名(形式参数列表){ 方法体; }当修饰符列表有 “static” 关键字的话，怎么调用方法？调用方法：类名.方法名(实际参数列表);返回值类型1，什么是返回值？一个方法为了完成某一特定的功能，当该功能结束后，其返回执行结果，并且该结果可能为某一具体存在的数据，这个存在的数据称之为返回值2，返回值的具体类型返回值是一个具体存在的数据，因此需要定义返回值类型；具体类型可以为基本数据类型和所有引用数据类型如果某
复制链接

扫一扫