类的成员之一：方法（method）

最新推荐文章于 2023-08-07 09:29:12 发布
最新推荐文章于 2023-08-07 09:29:12 发布
阅读量701 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43788522/article/details/113879526
版权

文章目录

①什么是方法

在这里插入图片描述

②方法的声明格式

在这里插入图片描述

③方法的分类

在这里插入图片描述

③方法的调用

在这里插入图片描述
注意：

  1. 方法被调用一次，就会执行一次
  2. 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
  3. 定义方法时，方法的结果应该返回给调用者，交由调用者处理。
  4. 方法中只能调用方法或属性，不可以在方法内部定义方法。
/*
 * 类中方法的声明和使用
 * 
 * 方法：描述类应该具有的功能。
 * 比如：Math类：sqrt()\random()...
 * 		Scanner类：nextXxx() ...
 * 		Arrays类：sort()\ binarySearch()\toString()\equals()\...
 * 
 * 1.举例：
 * public void eat(){}
 * public void sleep(int hour){}
 * public String getName(){}
 * public String getNation(String nation){}
 * 
 * 2.方法的声明：权限修饰符	返回值类型		方法名（形参列表）{
 * 				方法体
 * 			}
 * 	注意：static、final、abstract 来修饰的方法，后面讲
 * 
 * 3.说明：
 * 		3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
 * 			Java规定的4种权限修饰符：private、public、缺省、protected---》封装性细说
 * 		
 * 		3.2 返回值类型： 有返回值  vs 没有返回值
 * 			3.2.1  如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
 *                return关键字来返回指定类型的变量或常量：“return 数据”。
 * 				  如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
 *               使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
 * 
 * 			3.2.2 我们定义方法该不该有返回值？
 * 				① 题目要求
 * 				② 凭经验：具体问题具体分析
 * 
 *      3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
 *      
 *      3.4 形参列表： 方法可以声明0个，1个，或多个形参。
 *         3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...
 *         
 *         3.4.2 我们定义方法时，该不该定义形参？
 *         		① 题目要求
 *         		② 凭经验：具体问题具体分析
 *      
 *      3.5 方法体：方法功能的体现。 		
 * 
 *  4.return关键字的使用：
 *  	1.使用范围：使用在方法体中
 *  	2.作用：① 结束方法
 *            ② 针对于有返回值类型的方法，使用"return 数据"方式返回所要的数据。
 *      3.注意点：return关键字后面不可以声明执行语句。
 *      
 *  5. 方法的使用中，可以调用当前类的属性或方法
 *  		特殊的：方法A中又调用了方法A:递归方法。
 *     方法中，不可以定义方法。
 */
public class CustomerTest {
	public static void main(String[] args) {
		
		Customer cus=new Customer();
		cus.sleep(10);
	}
}

//客户类
class Customer{
	//属性
	String name;
	int age;
	boolean isMale;
	
	//方法
	public void eat(){
		System.out.println("刘瘦瘦吃饭");
		return;
		//return后不可以声明表达式
//		System.out.println("hello");
	}
	
	public void sleep(int hour){
		System.out.println("休息啦"+hour+"小时");
		eat();
		//自己调自己栈溢出了（StackOverflowError）sleep(10);
	}
	
	public String getName(){
		
		if(age>18){
			return name;
		}else{
			return "Tom";
		}
	}
	
	public String getNation(String nation){
		String info = "我的国籍是：" + nation;
		return info;
	}
	
	//体会形参是否需要设置的问题
//	public void sort(int[] arr){
//		
//	}
//	public void sort(){
//		int[] arr = new int[]{3,4,5,2,5,63,2,5};
//		//。。。。
//	}
	
	public void info(){
		//错误的方法里不能声明方法
//		public void swim(){
//			
//		}
		
	}
}

练习

在这里插入图片描述

/*
 * 4. 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：
1) 生成随机数：Math.random()，返回值类型double;  
2) 四舍五入取整：Math.round(double d)，返回值类型long。
 */
public class StudentTest {
	public static void main(String[] args) {
		
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
		
		//声明Student类型的数组
		Student[] stus = new Student[20];
	  //String[] arr = new String[10];对象数组的内存分析见下图
		
		for(int i = 0;i < stus.length;i++){
			//给数组元素赋值
			stus[i] = new Student();
			//给Student对象的属性赋值
			stus[i].number = (i + 1);
			//年级：[1,6]
			stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);//[0.0,1.0)-->[0.0,6.0)-->[1.0,7.0)-->[1,6]
			//成绩：[0,100]
			stus[i].score = (int)(Math.random() * (100 - 0 + 1));//[0.0,1.0)-->[0.0,101.0)-->[0.0,100]
		}
		
		//遍历学生数组
		for(int i = 0;i <stus.length;i++){
//			System.out.println(stus[i].number + "," + stus[i].state 
//					+ "," + stus[i].score);
			
			System.out.println(stus[i].info());
		}
		
		System.out.println("********************");
		
		//问题一：打印出3年级(state值为3）的学生信息。
		for(int i = 0;i <stus.length;i++){
			if(stus[i].state == 3){
				System.out.println(stus[i].info());
			}
		}
		
		System.out.println("********************");
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		for(int i = 0;i < stus.length - 1;i++){
			for(int j = 0;j < stus.length - 1 - i;j++){
				if(stus[j].score > stus[j + 1].score){
					//如果需要换序，交换的是数组的元素：Student对象！！！
					Student temp = stus[j];
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}
		
		//遍历学生数组
		for(int i = 0;i <stus.length;i++){
			System.out.println(stus[i].info());
		}
		
	}
}

class Student{
	int number;//学号
	int state;//年级
	int score;//成绩
	
	//显示学生信息的方法
	public String info(){
		return "学号：" + number + ",年级：" + state + ",成绩：" + score;
	}
	
}

对象数组的内存解析

④方法的重载

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

*
 * 方法的重载（overload）
 * 
 * 1.定义：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
 * 
 * 	”两同一不同“：同一个类、相同方法名
 * 				参数列表不同：参数个数不同、参数类型不同
 * 
 * 2.举例：
 * 	 Arrays类中重载的sort（） /  binarySerach()
 * 
 * 3.判断是否是重载：
 * 	 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系
 * 
 * 4.在通过对象调用方法时，如何确定某一个指定的方法：
 * 		方法名--->参数列表
 * 
 * 
 * 
 * 
 */
public class MethodOverLoadTest {

	public static void main(String[] args) {
		
		MethodOverLoadTest test= new MethodOverLoadTest();
		test.getSum(1, 2);
		//把这个注释掉也不会出错（会有自动类型提升的）
//		public void getSum(int i,int j){
//			System.out.println("1");
//		}
	}
	
	//如下的4个方法构成了重载
	public void getSum(int i,int j){
		System.out.println("1");
	}
	
	public void getSum(double d1,double d2){
		System.out.println("2");
	}
	
	public void getSum(String s,int i){
		System.out.println("3");
	}
	
	public void getSum(int i,String s){
		System.out.println("4");
	}
	
	//如下的3个方法不能与上述4个方法构成重载
//	public int getSum(int i,int j){//返回值类型
//		
//	}
//	
//	public void getSum(int m,int n){//参数名
//		
//	}
//	
//	private void getSum(int i,int j){//权限修饰符
//		
//	}
}

⑤可变个数的形参

在这里插入图片描述
在这里插入图片描述

/*
 * 可变个数形参的方法
 * 
 * 1.jdk 5.0新增的内容
 * 2.具体使用：
 * 	2.1 可变个数形参的格式：数据类型 ... 变量名
 * 	2.2 当调用可变个数形参的方式时，传入的参数个数可以是：0个、1个、2个，。。
 * 	2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
 * 	2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载（本质是一样的）。
 * 	2.5 可变个数形参在方法的形参中，必须声明在末尾
 * 	2.6可变个数形参在方法的形参中，最多只能声明一个可变形参
 */
public class VariableNumberOfArguments {

	public void show(int i){
		
	}
	
	public void show(String s){
		System.out.println("show(String)");
	}
	
	public void show(String ... strs){
		System.out.println("show(String ... strs)");
		
		//可变参数的遍历
		for(int i=0;i<strs.length;i++){
			System.out.println(strs[i]);
		}
	}
	
	//不能与上一个方法同时存在
	//错误信息：Duplicate method show(String[]) in type VariableNumberOfArguments
	//可变参数的本质也是数组
	//如果传递多个参数用这种方法的话，调用的格式如下：
	//new VariableNumberOfArguments(new String[]{"aa","bb","cc"});
	//而用可变参数不用new了直接写就可以了
	//	public void show(String[] strs){
//		
//	}
	
	//必须是最后面
	//错误信息：The variable argument type String of the method show must be the last parameter
	//原因分析：这样的话，编译器会认为你的输入都是存在strs中了，而参数i就永远赋不了值）
//	public void show(String ... strs,int i){
//		
//	}
	
	public static void main(String[] args) {
		VariableNumberOfArguments test=new VariableNumberOfArguments();
		test.show(12);
		
		test.show();//不传参的话，会调用可变参数的show方法
		test.show("Hello");
		test.show("hello","world");
	}
}

⑥return关键字

  • 使用范围

    • 使用在方法体中

  • 作用

    • 结束方法
    • 针对于返回值类型的方法，使用"return 数据"返回所要的数据。

  • 注意点

    • return关键字后面不可以声明执行语句。

⑦方法的值传递机制

刘瘦瘦
基本数据类型值传递测试

package com.liuyongbin.oop;
/*
 * 方法的形参的传递机制：值传递
 * 
 * 1.形参：方法定义时，声明的小括号内的参数
 * 	  实参：方法调用时，实际传递给形参的数据
 * 
 * 2.值传递机制：
 * 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
 * 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
 */
public class ValueTransferTest1 {
	
	public void swap(int m , int n){
		int temp;
		temp=m;
		m=n;
		n=temp;
	}
	public static void main(String[] args) {
		
		int m=10;
		int n=20;
		
		System.out.println("m="+m+" n="+n);//m=10 n=20
		
		//交换两个变量的值的操作
//		int temp=m;
//		m=n;
//		n=temp;
		
		ValueTransferTest1 vtf= new ValueTransferTest1();
		vtf.swap(m, n);
		System.out.println("m="+m+" n="+n);//m=10 n=20详细见内存解析
		

	}
}

内存分析
在这里插入图片描述

程序的入口是main方法，所以当执行main方法时，首先会在栈中开辟一个main方法的栈帧，变量m和n都会在栈中分配内存（局部变量），当执行到swap方法时，又会开一个栈帧，并且开辟了m和n两个变量，由于m和n是基本数据类型，则直接把实参对应的值复制一份给了swap方法中的m和n变量，所以在swap中执行交换时，并不会改变main方法中的m和n的值。当swap方法执行完毕时，swap栈帧销毁，程序返回到main方法的swap方法，然后继续执行swap方法后的代码，main方法执行完毕main方法的栈帧销毁，程序结束。

引用数据类型值传递测试

/*
 * 引用型测试
 */
class Data{
	
	int m;
	int n;
}
public class ValueTransferTest2 {
	
	public void swap(Data data){
		int temp=data.m;
		data.m=data.n;
		data.n=temp;
	}
	public static void main(String[] args) {
		
		Data data = new Data();
		data.m=10;
		data.n=20;
		
		System.out.println("data.m="+data.m+" data.n="+data.n);//data.m=10 data.n=20
		
		ValueTransferTest2 vtf=new ValueTransferTest2();
		vtf.swap(data);
		System.out.println("data.m="+data.m+" data.n="+data.n);//data.m=20 data.n=10,详细见内存解析

	}
}

内存分析
在这里插入图片描述
面试题
在这里插入图片描述
解决方法：

public static void method(int a,int b){
		//在不改变原本题目的前提下，如何写这个函数才能在main函数
		//中输出a=100,b=200
		a*=10;
		b*=10;
		System.out.println(a);
		System.out.println(b);
		System.exit(0);//Terminates the currently running Java Virtual Machine.
		//输出后直接终止jvm
	}

⑧递归方法

在这里插入图片描述

package com.liuyongbin.oop;

import org.omg.Messaging.SyncScopeHelper;

/*
 * 递归方法的使用（了解）
 * 1.递归方法：一个方法体内调用它自身。
 * 2.方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
 * 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
 */
public class RecursionTest {
	
	//例题一：计算1-n之间所有自然数的和
	
		public int sum(int n){
			if(n==1){
				return 1;
			}
			return n+sum(n-1);
		}
		
		//例题2：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),其中n是大于0
		//的整数，求f(10)的值。
		public int f(int n){
			if(n==0){
				return 1;
			}else if(n==1){
				return 4;
			}
			return 2*f(n-1)+f(n-2);
			
		}
		
		//例题3：求n的阶乘
		public int factorial(int n){//factorial [fækˈtɔːriəl]  阶乘
			if(n==1){
				return 1;
			}
			return n*factorial(n-1);
		}
		
		//例题四：输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值
		//1 1 2 3 5 8 13 21 34 55
		//规律：一个数等于前两个数之和
		//要求：计算斐波那契数列(Fibonacci)的第n个值，并将整个数列打印出来
		public int fibonacci(int n){
			if(n<=2){
				return 1;
			}else{
				return fibonacci(n-1)+fibonacci(n-2);
			}
		}
		//例题五：
		//N个台阶，一次可以走一步或者两步
		//求走这N个台阶有多少种走法
		/*
		 *分析：思路：首先，这是一个斐波那契数列的应用，
		 *但是，这里我们不直接给出算法，而是给出算法的思路。
		 *走到第N个台阶，要么你是从第N-1层走一步到，
		 *要么你是从第N-2层走两步到。
		 *令走到第N-1层的方法数是an-1，
		 *走到第N-2层的方法数是an-2，
		 *走到第N层的方法数是an，
		 *我们有an=an-1+an-2，
		 *这个公式是斐波那契数列的通项公式。
		 *我们令a1=1,a2=2，使用迭代算法，可以求得an的值。
		 * 
		 */
	public static void main(String[] args) {	
		//例题一：计算1-100之间所有自然会的和
		//方式一：
		int sum=0;
		for(int i=1;i<=100;i++){
			sum+=i;
		}
		System.out.println(sum);//5050
		
		//方式二：
		RecursionTest rt= new RecursionTest();
		int val=rt.sum(100);
		System.out.println(val);//5050
		
		//例题2：
		System.out.println(rt.f(10));//10497
		//例题3：
		System.out.println(rt.factorial(4));//24
		//例题4：
		for(int i=1;i<=10;i++){
			int value=rt.fibonacci(i);
			System.out.print(value+" ");
		}
	}	
}
安慕希ai
关注
专栏目录
Java中类的成员之二：方法(method)
小贺想改变
09-05 1715
Java种方法的声明分析、return的使用等等
python中的数据成员有两类_彻底搞懂Python数据成员和成员方法
weixin_42208552的博客
01-29 2132
一、数据成员(属性)数据成员可以大致分为两类：属于对象的数据成员和属于类的数据成员。属于对象的数据成员一般在构造方法__init__()中定义，当然也可以在其他成员方法中定义，在定义和在实例方法中访问数据成员时以self作为前缀，同一个类的不同对象(实例)的数据成员之间互不影响；属于类的数据成员是该类所有对象共享的，不属于任何一个对象，在定义类时这类数据成员一般不在任何一个成员方法的定义中。二、成...
powermock跳过某方法_用PowerMockito来mock私有方法（转）
weixin_28773055的博客
12-23 2784
话说我们做的所谓的接口测试真的是不伦不类啊，测的是controller层，那叫接口木？？！！可是老大们说写的是接口测试，那就接口吧！自接手写这个接口测试不久，很多人，包括一个关系比较好的架构师就跟我说，写这个很麻烦啊，代码很乱，你得mock一堆。既然已经跳进去了，那就游一会儿吧。为了mock，可谓想尽了办法啊，从一般的mock工具mockito，到java的反射，最后发现一个强大的工具——Powe...
替换手机号中间4位（php，js）
mobeinight的专栏
12-24 1788
JS方法function hideMobile(num){ var mphone =num.substr(3,4); var lphone = num.replace(mphone,"****"); return lphone; } php方法 $phone=substr_replace($phone,'****',3,4);
java的重写
qq_39222456的博客
10-24 647
重写 与 重载 之间的区别: 都是方法的重写和重载 重载: 在同一个类中 多个方法组成,方法名相同 参数列表不同|方法签名不同 重写: 1.在不同的类中 2.继承|实现 3.方法签名相同 2.重写的作用: 子类存在从父类中继承的功能,但是子类对功能的实现,与父类不一样,可以对这个功能进行方法的重写 3.如何使用重写方法: 子类对象...
Java重写
qq_57399395的博客
01-07 418
Java重写
《UEFI内核导读》之ACPI编程入门 第4章：方法（Method）
业余电子爱好者的日常
11-18 2524
固件C字营·版权所有 敬请关注微信公众号：“固件C字营” 第4章：方法（Method） Control Method是ACPI/ASL预定义的一种对象类型（ObjectType）为8的对象。它可以调用或者被其他的Method调用，在调用过程中可以被阻塞但不能被抢占，当一个Method被阻塞时OSPM可以转而执行其他的Method。以下称之为...
Java-类、对象、成员、成员方法
追求灵魂代码
09-20 1657
目标 编写一个圆环类 Ring 的 Java 程序。圆环类有 3 个数据成员 , 分别是内半径 innerRadius, 外半径 outerRadius 和颜色 color, 这些属性可以查看 get 也可以重新设置 set, 另外 , 圆环还可以返回其面积 area 。 第1题中增加两个static 成员 ：圆周率和圆对象个数, 增加两个 static 方法，分别是设置圆周率和显示当前圆对象个...
设计模式之“工厂方法模式[Factory Method Pattern]”
03-19
今天我们要探讨的是设计模式中的一个经典成员——工厂方法模式（Factory Method Pattern）。工厂方法模式是创建型设计模式的一种，它提供了一种创建对象的最佳方式。 ### 一、什么是工厂方法模式？ 工厂方法模式...
java重写方法
热门推荐
m0_62476684的博客
04-07 2万+
文章目录一.重写二.重写和重载的区别1.重载2.重写3.代码举例 一.重写 重写（override）：也称覆盖。重写是子类对父类非静态，非private，非final方法的实现过程进行重新编写，返回值（JDK7以后，被重写的方法返回值类型可以不同，但是必须是具有父子关系的）和形参都不能改变。即外壳不变，核心重写。 【方法重写的规则】： 1.子类在重写父类的方法时，一般必须与父类方法原型一致：修饰符 返回值类型 方法名(参数列表) 要完全一致 2.JDK7以后，被重写的方法返回值类型可以不同，但是必须是具有父
JDK8新特性之接口
weixin_30399871的博客
05-02 188
在JDK7及以前的版本中，接口中都是抽象方法，不能定义方法体，但是从jdk8开始，接口中可以定义静态的非抽象的方法，直接使用接口名调用静态方法，但是它的实现类的类名或者实例却不可以调用接口中的静态方法。也可以定义普通的非抽象的方法，普通的非抽象方法要在返回值前加上default，对于普通的非抽象方法必须使用子类的实例来调用。如果有多个接口定义了相同的默认方法，实现多个这些接口时...
Java方法重写
最新发布
2301_76161469的博客
08-07 4675
重写override，也称为覆盖）：在子类中对父类中允许访问的方法的实现过程进行重新编写，子类中方法的名称、返回值类型、参数列表与父类相同，只有方法体中的实现不同。
Java中的重写(Override)
weixin_68105699的博客
08-21 2014
Java中的重写(Override)
java 重写
qq_54250695的博客
07-10 305
学习
Java：重写
龙雪的博客
09-05 1707
1.子类可以继承父类方法，但有时从父类继承的方法在子类中必须进行修改以适应新类的需要，这种对父类方法进行改写或改造的现象称为方法重写或方法覆盖。父类方法在子类中重写使继承更加灵活。 2.子类重写了父类的方法，则使用子类创建的对象调用该方法时，调用的是重写后的方法，即子类中的方法： Father.java文件中的代码： 程序运行结果： Son.java文件中的代码 ： ...
powermock跳过某方法_Powermock-如何模拟特定方法并使对象的其余部分保持原样
weixin_40004057的博客
12-23 406
I have a Person class with get set for FirstName, LastNameA TestClass to execute TestCase1Can we just only mock a specific method (getLastName) and leave every thing else (other internal fields, funct...
Java重写（Override）
m0_46383618的博客
03-06 265
一、Java重写的定义 对父类的函数进行重新定义，且重写发生在父类与子类之间，子类对从父类继承来的方法的实现细节进行修改，即不能改变方法的返回值和方法的参数列表，仅仅对方法内部的细节进行修改。 二、Java重写的意义 1、为了更准确的描述子类的行为特征 2、如果子类型重写了父类型的同名方法，那么只知道父类型的定义就可以调用子类型的方法了 三、Java重写注意事项 1、重写后...
Java内部类详解：成员与局部内部类解析
局部内部类只存在于某个方法或作用域之内，它的生命周期与该方法或作用域绑定。这意味着局部内部类只能在其定义的范围内使用，并且可以访问该范围内的所有局部变量和方法。例如： ```java public class Outer { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值