java的方法详解和总结

标签：固定   lock   就会   影响   cte   重用   而且   修饰符   设计   

一、什么是方法

在日常生活中，我们所说的方法就是为了解决某件事情，而采取的解决办法

java中的方法可以理解为语句的集合，用来完成解决某件事情或实现某个功能的办法

方法的优点：

• 程序变得更加简短而清晰
• 有利于程序的维护
• 可以提高程序开发的效率
• 提高了代码的重用性

方法的命名规则：

• 必须以字母、下划线、$开头
• 可以包含数字，但不能以数字开头

二、方法的定义并调用

访问修饰符  返回值类型   方法名（参数列表）{
    方法体
}

（1）返回值：

• 可以理解为方法是做了一件事情，这件事情做完了，留下的一个结果，返回值只有一个结果

• 若方法的设计规定了返回值类型，方法内必须通过return关键字返回一个值

• 方法定义的返回值类型 return就必须返回方法定义的返回值的类型 比如返回值是String类型的 return的值也必须是String类型的

（2）参数：参数分为形参和实参

• 形参：可以理解为是方法执行时的临时变量空间（定义方法括号后面的参数）
• 实参：可以理解为是方法调用时传递进去的参数 （调用方法的时候穿进去的参数）

（3）访问修饰符：

• public：公共的
• protected： 受保护的
• 默认不写： 默认的
• private ：私有的

实例：

1.无参数 无返回值

//无参数  无返回值	
public void medth(){
   	System.out.println("这是无参数 无返回值的方法")
}
public static void main(String[] args){
    //因为这里的medth没有参数也没有返回值 直接调用也不用接收
    //调用medth会输出  "这是无参数 无返回值的方法"
    medth();
}

2.无参数 有返回值

//无参数  有返回值  返回值类型是String 所有return也必须是String类型的
public String medth(){
    String a="我是String类型的变量 可以被返回出去";
    return a;
}
public static void main(String[] args){
    String b=medth();
    //这里的b会输出 "我是String类型的变量 可以被返回出去"
    System.out.println(b);
}

3.有参数 无返回值

//有参数  无返回值  这里的的a是形参  可以在方法中拿来用
public void medth(String a){
    //这里会输出传递进来的值 "我调用medth方法并将这段话传递给medth"
    System.out.println(a)
}
//在这里定义一个main方法 并调用medth方法传递参数
//这里的a是实参
public static void main(String[] args){
    String a="我调用medth方法并将这段话传递给medth";
    medth(a);
}

4.有参数 有返回值

//有参数  有返回值  这里的的a是形参  可以在方法中拿来用
public String medth(String a){
    System.out.println(a);
    //将传递进来的a return出去
    return a;
}
//在这里定义一个main方法 并调用medth方法传递参数
//这里的a是实参
public static void main(String[] args){
    String a="我调用medth方法并将这段话传递给medth";
    String b= medth(a);
    //这里会输出"我调用medth方法并将这段话传递给medth"
    System.out.println(b);
}

三、方法重载

如果有两个方法的方法名相同，但参数不相同，就可以说一个方法就是另一个方法的重载

方法重载的具体说明

• 方法名相同
• 方法的参数类型、参数个数不一样
• 方法的返回类型可以不相同
• 方法的修饰符可不相同
• main方法也可以被重载

实例：

//只要参数列表的类型或个数不同 就形成重载 与返回值和访问修饰符无关
public class Test(){
    public void medth(){
        System.out.println("我是没有被传进来参数的，所以被调用的时候会输出这句话")
    }
    private void medth(int a){
        System.out.println(a)
    }
    int medth(String a){
         System.out.println(a)
    }
    protected String medth(String a,int b){
         System.out.println(a+"---"b)
             
    }
    public static void main(String[] args) {
     test t=new test();
      t.medth();
      t.medth(1);
      t.medth("我是String类型的参数");
      t.medth("我是String类型的参数",1);
      }
}

以上程序执行结果：

我是没有被传进来参数的，所以被调用的时候会输出这句话
1
我是String类型的参数
我是String类型的参数---1

四、可变长参数

在java5提供了可变长参数，也就是在方法定义中可以使用个数不明确的参数，对于同一个方法可以使用不同个数的参数调用

语法：

访问修饰符 返回值 方法名(参数类型... 参数名称){
    方法体
}

实例：

public class Test(){
public void medth(String... args){
     for(int i=0;i< args.length;i++){
          System.out.println(args[i]);
      }
}
public static void main(String[] args){
    Test t=new Test();
    t.medth("这是第一个参数","这是第二个参数");
	}
}

以上程序执行结果为:

这是第一个参数
这是第二个参数

注：

• 一个方法只能有一个可变参数，否则会报错，而且可变参数应该为左后一个参数
• 可变参数的前面可以定义固定参数，会优先使用固定参数方法

五、递归（了解）

递归是一种调用自身的算法

打个生动的比喻：我们可以把” 递归 “比喻成 “查字典 “，当你查一个词，发现这个词的解释中某个词仍然不懂，于是你开始查这第二个词。可惜，第二个词里仍然有不懂的词，于是查第三个词，这样查下去，直到有一个词的解释是你完全能看懂的，那么递归走到了尽头，然后你开始后退，逐个明白之前查过的每一个词，最终，你明白了最开始那个词的意思。（摘自知乎的一个回答）

实例：
之前我们在打印九九乘法表的时候用的是嵌套for循环，这里我们将使用递归的方法来实现九九乘法表

public class Test(){
    //定义一个方法用来实现递归  
    public void medth(int i){
        if(i==1){
			System.out.println("1*1=1");
        }else{
            medth(i-1);
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            System.out.println();
        }
    }
    public static void main(String[] args){
        Test t=new Test();
        t.medth(9);
    }
}

以上程序执行结果：

1*1=1
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	

优点：

• 代码简洁，清晰，并且容易验证正确性

缺点：

• 它的运行需要较多次数的函数调用，如果调用层数比较深，需要增加额外的堆栈处理
• 栈主要是用来存放栈帧的，每执行一个方法就会出现压栈操作，所以采用递归的时候产生的栈帧比较多，递归就会影响到内存，非常消耗内存

java的方法详解和总结

标签：固定   lock   就会   影响   cte   重用   而且   修饰符   设计   

原文地址：https://www.cnblogs.com/wyuanStudy/p/13617834.html