初识Java之方法参数篇
无论是在c里面编程还是在Python里面写代码，我们都会遇到函数这个概念，但是在Java中我们用“方法”这个概念，和函数其实是差不多的，因为他们指代的内容差不多，Java成为全世界最广泛的语言之一，就是因为它有大量的方法。
Java方法
什么是方法呢？在之前的程序里面我们看到了println（）这个打印的，其实它就是一个方法
System.out.println();
- 1
println() 是一个方法。
System 是系统类。
out 是标准输出对象。
- 1
- 2
- 3
Java方法是语句的集合，它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用
- 1
- 2
- 3
方法的优点
1. 使程序变得更简短而清晰。
2. 有利于程序维护。
3. 可以提高程序开发的效率。
4. 提高了代码的重用性。
- 1
- 2
- 3
- 4
方法的命名规则
方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符（驼峰式命名）
修饰符 返回值类型 方法名(参数类型 参数名){ ... 方法体 ... return 返回值;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
package Java方法;
public class 方法参数 { static void printName(String name){ System.out.println("hello everyone! my name is "+name); } public static void main(String[]args){ printName("王小王"); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
其实说到底，和函数的调用有异曲同工之妙，我们首先按照格式定义一个方法，方法里面要有打印的东西，还要在方法体里面写出具体的方法，至于修饰符我们通常选用static，返回值类型一般void，最后在main方法里面调用的时候我们直接把之前定义好的方法加上参数即可。也可以定义多个参数！
package Java方法;
public class 方法参数 { static void printName(String name,int age ,float x){ System.out.println("hello everyone! my name is "+name+",我今年："+age+",我的薪水是："+x); } public static void main(String[]args){ printName("王小王",20,10000); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
方法体：方法体包含具体的语句，定义该方法的功能。
- 1
- 2
- 3
- 4
- 5
方法有返回值
package Java方法;
public class 返回值参数 {
// 这里定义了一个有返回值的方法体，所以类型为int static int ageY(int age2,int age1){
// 注意返回值的参数前面要加数据类型 int age3=age2+age1;
// 和我们Python语言一样return return age3; } public static void main(String[]args){
// 调用即可 System.out.println(ageY(10,12)); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
当然在一个方法体里面可以有多个方法
不在同一窗口的类调用
package Java方法;
public class 方法参数调用 { public static void main(String[]args){ 方法参数.printName("王小王",20,10000); System.out.println(方法参数.getMK(10)); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
这里我们新建了一个类，我们调用了之前写的那个方法，而调用方法就是类名.方法（参数）
按值传递参数
package Java方法;
public class 传递参数 { public static void nPrintln(String message, int n) { for (int i = 0; i < n ; i++) { System.out.println(message); } } public static void main(String[]args){ nPrintln("hello",100); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
这里通过for循环打印了100次，通过按值传递的参数方法，把后面main方法里面的实参传入方法体内，进行形参转换，这样就达到了，总的来说和函数差不多的。
方法的重载
public static double max(double num1, double num2) {
if (num1 > num2) return num1;
else return num2;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；
如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；
就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。
Java编译器根据方法签名判断哪个方法应该被调用。
方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。
重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。
构造方法
当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。
不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，默认构造方法的访问修改符和类的访问修改符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。一旦你定义了自己的构造方法，默认构造方法就会失效。
// 一个简单的构造函数
class MyClass {
int x; // 以下是构造函数
MyClass() { x = 10;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
可变参数
typeName... parameterName
- 1
- 2
- 3
在方法中，指定参数类型后加一个省略号(…)一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
package Java方法;
public class 可变参数 { public static void main(String args[]) { // 调用可变参数的方法 printMax(34, 3, 3, 2, 56.5); printMax(new double[]{1, 2, 3}); } public static void printMax( double... numbers) { if (numbers.length == 0) { System.out.println("No argument passed"); return; } double result = numbers[0]; for (int i = 1; i < numbers.length; i++){ if (numbers[i] > result) { result = numbers[i]; } } System.out.println("The max value is " + result); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
从编译结果来看我们知道这个的功能是把两个列表里面进行比较大小，最后得出最大的值，这里运用了可变参数的概念
另外的可变参数还有一个固定参数，一般是先执行固定参数，后执行可变参数，通过反复的方法重载我们有把可变参数按照固定参数进行执行。
我们来看看这个代码
package Java方法;
public class 方法重载 {
// 定义一个可变参数，按照格式 public static void test(String...args){ System.out.println("这是可变参数的入参方法！");
// 利用for循环遍历参数，首先声明变量 for (String arg :args){ System.out.println("入参为："+arg); } } public static void main(String[]args){
// 这里有方法重载 test(); test("A"); test("a","n","l"); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
finalize() 方法
Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象
protected void finalize()
{ // 在这里终结代码
}
- 1
- 2
- 3
- 4
- 5
- 6
关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用
public class FinalizationDemo { public static void main(String[] args) { Cake c1 = new Cake(1); Cake c2 = new Cake(2); Cake c3 = new Cake(3); c2 = c3 = null; System.gc(); //调用Java垃圾收集器
}
} class Cake extends Object { private int id; public Cake(int id) { this.id = id; System.out.println("Cake Object " + id + "is created"); } protected void finalize() throws java.lang.Throwable { super.finalize(); System.out.println("Cake Object " + id + "is disposed"); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
这个里面就是经常用到语法知识点，代码可能对于现在的你有点陌生，但是后面我们慢慢了解就会越来越熟悉了！
每文一语
如果让你重新选择一次，那么你还会去抱怨你现在的生活吗？一切都是最好的安排，莫过于失败里找成功！
文章来源: blog.csdn.net，作者：王小王-123，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/weixin_47723732/article/details/108314431
- 点赞
- 收藏
- 关注作者
评论（0）