方法
何为方法
JAVA方法是语句的结合,组合在一起来实现某种功能。(可以理解为Python的函数)
本质是功能块,是实现功能的语句块的有序集合
- 方法包含在类和对象中
- 方法在程序中被创建,在其他地方被调用
在JAVA中,方法不能独立存在(必须在类里面建立方法)
方法定义的原则:
保持方法原子性(一个方法实现一个功能)
方法的定义和调用
- 修饰符:修饰符,这是可选的,告诉编译器如何调用该方法。定义了该方法的访问类型。
- 返回值类型 :方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作,但没有返回值。在这种情况下,returnValueType 是关键字void。
- 方法名:是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。
- 方法体:方法体包含具体的语句,定义该方法的功能。
例1
/**
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
*/
public class Demo {
public static void main(String[] args) { //main
int add = add (1, 2) ; //给方法的参数赋值
System.out.println(add); //调用方法使用
}
public static int add (int a, int b){
/*
修饰符public static
返回类型 int
方法名 add
数据类型是 int
数据名是 a , b
*/
int c = a + b ;
return c ; //返回c 值
}
}
例2
public class Demo {
public static void main(String[] args) {
int add = add (1, 2) ;
System.out.println( "add方法: " + add);
N(0);
}
public static int add (int a, int b){ //整数加法方法
int c = a + b ;
return c ;
}
public static int N (int a){ //循环输出数字方法,这里的a是形参
for (int b = 0 ; b <= 5 ; b++){ // 这里的b为实参
System.out.println(b);
a = b ; //将实参的值赋给形参
}
return a ; //返回a值
}
}
方法调用
对象名.方法名(实参列表)
如果返回是个值,方法调用一般是一个值。
int larger = max(30, 40);
如果是viod,返回值是个语句
System.out.println("Hello,World!");
例如下
public class Demo {
public static void main(String[] args) {
int add = add (1, 2) ;
System.out.println( "add方法: " + add);
System.out.println( "N方法: " + N(0));
Text( 2) ;
// Text() ;
}
public static int add (int a, int b){ ///add方法,返回值int
int c = a + b ;
return c ;
}
public static int N (int a){
for (int b = 0 ; b <= 2 ; b++){ //N方法,返回值int
a = b ;
}
return a ;
}
public static void Text(int a ){ //Text方法,返回值void,不用加return
if (a == 2){
System.out.println("Text:" + a);
}
}
// public static void Text(){
// System.out.println("Text");
// }
}
方法的重载
在一个类中方法名相同,但参数不一致的方法
重载规则
- 方法名相同
- 方法的参数类型,参数个不一样
- 方法的返回类型可以不相同
- 方法的修饰符可以不相同
- main 方法也可以被重载
实例
public class Demo {
public static void main(String[] args) {
double a = N(1) ;
int b = N(2) ;
System.out.println(a);
System.out.println(b);
}
//int
public static int N (int a){ //方法N,返回值 int
return a ;
}
//double
public static double N (double c){ //方法N,返回值 double
return c ;
}
}
可变参数
可以接受多个值的形参
- 在方法声明中,指定参数类型要加省略号( … )
- 可变参数只能作为函数的最后一个参数,但其前面可以有也可以没有任何其他参数
public class Demo1 {
public static void main(String[] args) {
Demo1 Demo1 = new Demo1() ; //定义一个demo1
Demo1.Text(1,2,3); //调用Text方法
}
public static void Text (int ...i){
System.out.println(i[0]);
System.out.println(i[1]);
System.out.println(i[2]);
}
}
递归
方法A调用方法A,自己调用自己
public class Demo1 {
int b = 0 ;
public static void main(String[] args) {
Text(1,0) ;
}
public static int Text (int i ,int b ){
if (b < 100){
System.out.println(i);
b ++ ;
}
return Text(i,b) ;
}
}
运行结果如下
对象之间相互引用,最终会导致栈溢出
所以就需要加入边界条件了。
递归结构包括两个部分:
递归头:什么时候不调用自身方法,没有递归头,会陷入死循环
递归体:什么时候需要调用自身方法
所以之前的代码是没有递归头,有递归体。
public class Demo {
public static void main(String[] args) {
// Text(0) ;
Text(9999);
}
public static int Text (int b ){
if (b <= 10){ //递归体
System.out.println(b);
return 10 ;
}else {
return Text(b-1) ;//递归头
}
}
修饰符 Static
static 修饰的变量
没加 static
public class MI{
int P = 10; //普通变量 P
public void BB (){
System.out.println(P);
}
}
调用输出
public class iiuiu {
public static void main(String[] args){
MI M1 = new MI();
M1.P = 100; //给实例 M1的变量 P 赋值
M1.BB();
MI M2 = new MI();
M2.BB();
}
}
输出的结果:
加入 static (在同一个类里面创建的所有对象共享一个值)
public class MI{
static int P = 10; //静态变量 P
public void BB (){
System.out.println(P);
}
}
调用输出
public class iiuiu {
public static void main(String[] args){
MI M1 = new MI();
M1.P = 100;
M1.BB();
MI M2 = new MI();
M2.BB();
}
}
输出结果:
static 修饰的方法
用 static 修饰的方法,不属于某一个对象,属于某一个类。
public class House {
static int A ; //静态变量A
public static void DDD(){ //静态方法DDD
A = 10;
}
}
在静态方法中只能使用静态变量,而普通方法中可使用普通变量和静态变量