java基础学习笔记——day07（方法、方法的重载、递归、成员变量、局部变量）

java基础学习笔记——day07

1. 方法

1.1 什么是方法

• 方法就是一个功能米快的集合，将不同用处的代码放置在一组 { } 中，形成一个代码块

• 方法的好处

  1. ·方法可以提高代码的复用性
  2. 可以提高代码后期的扩展性/延展性
  3. 方面代码后期的维护

1.2 如何使用方法

1.2.1 方法的声明及使用

• 格式及使用

public class Text{
	[修饰符] [static] {void或数据类型} 方法名(){
    	功能代码；
	}
}
例；
public class Text{
	public static vopid main(String[] args){
	method();//调用方法
	}
	public static void method(){
		Systrm.out.println("这是我的第一个方法");
	}
}

• 注意：

  • 修饰符和static 可以不写
  • void和数据类型二选一
    • void表示该方法没有返回值
    • 如果有返回值则要选择数据类型
  • 方法要声明在类中，main方法的外

• **调用：**在main方法中通过方法的名称进行调用

1.3 参数列表

• 参数列表声明在方法名后面的小括号中，可以声明0~多个,用逗号隔开

public class Text{
    public static void main(String[] args){
        methopd(40，20);//40对应num1  20对应num2
    }
    public tatic void method(int num1,int num2){
        result =num1+num2;
        System.out.println(resulr);
    }
}

• 注意事项：
  1. 将方法声明是的参数列表称之为形式参数 形参
  2. 对于调用者而言，传入的具体的参数的值称之为实际参数 实参
  3. 方法声明的参数列表只需要声明，不需要初始化就可以使用，因为该方法被调用之后一会将实际参数进行赋默认值
     1. 整数的默认值是 0
     2. 小数的默认值是 0.0
     3. boolean的而默认值是 false
     4. 字符串的默认值是 null
     5. 字符型的默认值是 一个空格
  4. 方法调用者而言，在调用方法的时候不能只看方法的名称，而且还要看方法的参数列表，这样才可以正确的找到需要被调用的方法
  5. 在一个类中，确定方法通过方法签名完场
     • 方法签名： 方法名称+参数列表
  6. 对于参数列表而言，具体的参数类型，个数，顺序都有一定的要求，要求取决于业务逻辑

1.4 变量的分类

• 变量可以分为成员变量和局部变量

变量的分类	声明的位置	作用范围	注意事项
局部变量	声明在方法或代码块中。方法参数列表是属于该方 法的局部变量。	在当前方法或代码块中都有效	声明后一定要赋值
成员变量	声明在类中，方法外	当前类中都有效	无需初始化调用时需要：要么将当前的成员变量前加 static修饰；要么就是通过创建当前类的所属 对象，通过对象访问。 无需初始化，每个不同类型的变量都存在默认 值。

i 成员变量

• 声明在类中，方法外的变量称之为成员变量。

public class Text{
    static int num =10;
    int t=20;
    public static void main (String[] args){
        System.out.println("访问1："+num);   
        int num = 20;        
        System.out.println("访问2："+num);    
        Test02 t = new Test02();        						System.out.println(t.rt);
    }
     public static void method(){
          System.out.println(num);
     }
}

ii 局部变量

• 定义在方法中或者是代码块中的变量，称之为局部变量，局部变量的生命周期只能在声明的 {} 中有 效。出了这个位置就没有任何效果。方法的参数列表中的变量属于当前方法的局部变量

public class Test {   
    public static void main(String[] args) {      
        //int num = 10;        
        //System.out.println("main"+num);     
        {            int num = 10;           
         System.out.println("代码块"+num);     
        }        int num = 10;        
        System.out.println("访问代码块"+num);   
    }
}

• 代码块而言，通过一组大括号括起来 {} 代码块也分为：局部代码块、初始化块、静态代码块。
  局部代码块：声明在方法中的代码块。局部代码块中声明的变量只能在当前局部代码块中有效。
• 局部代码块的优势：
  1. 缩减了变量的生命周期。
  2. 提高内存的使用率，降低内存开销

1.5 返回值

• 被调用的方法可以将自己后的计算结果返回给调用处，方便后续的业务逻辑执行。返回值对于某些方 法而言是极其有必要的。

public class Method06 {  
    public static void main(String[] args) { 
        int r = 10;//1：    
        double area = getCircleArea(r);//2 //8  
    }    
    public static double getCircleArea(int r) {//3
        double pi = 3.14;//4     
        double area = pi*r*r;//5
        return area;//7    
    } 
}

• 注意事项
  1. void 的方法没有返回值
  2. 一个方法可以不存在void，但是一定要有内容去填充void所在的位置
  3. 如果一个方法存在返回值，则该方法最后一行代码一定是return语句，return功能是返回具体的值
  4. main方法中，在调用完成某个具有返回值的方法之后，可以通过变量接收该值

1.6 方法的重载

• 在同一个类中，同名的两个或者是多个方法，参数列表不同，我们称该多个方法为方法重载。

public class Method08 {  
    public static void main(String[] args) {  
        add(1,2);   
    }       
    //计算10和20的和   
    public static void add() {   
        int num1 = 10;     
        int num2 = 20;   
        System.out.println(num1+num2);  
    }   
    //计算传入的两个参数的和  
    public static void add(int num1,int num2){ 
        System.out.println(num1+num2);  
    }        public static void add(int num1){  
        System.out.println(num1+20); 
    }    
    public static void add(int num1,byte num2){
        System.out.println(num1+num2);   
    }       
    public static void add(byte num1,int num2){    
        System.out.println(num1+num2); 
    }
}

• 注意事项
  1. 重载在编码过程中是有意义的，针对于不同的参数做相同的功能。
  2. 两同三不同
     • 两同：：同类 同名
     • 三不同：参数列表不同(个数、类型、顺序)
  3. 注意返回类型和重载无关
  4. 在jvm中确定一个方法的方式是：返回值类型+方法名称+参数列表。java编程规范和JVM规 范

1.7 递归

• 递归是一种编程技巧，程序中自己调用自己。在递归程序中重要的问题是：何时出递归程序
• 在递归程序中存在一个出口–>递归头。
• 递归程序的大优势在于编写时简单。

i 计算一个数的阶乘和斐波那契数列

import java.util.Scanner;
public class recursion {
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num =input.nextInt();
        long x = System.currentTimeMillis();
        long a =method(num); // 用递归方法计算一个数的阶乘
        System.out.println("计算的阶乘是："+a);
        long y =System.currentTimeMillis();
        System.out.println("所用的时间是："+(y-x));

        x= System.currentTimeMillis();
        a=method1(num);//用递归计算斐波那契数列
        System.out.println("计算数列的值是："+a);
        y =System.currentTimeMillis();
        System.out.println("所用的时间是："+(y-x));
}
	 // 用递归方法计算一个数的阶乘
    public static int method(int num) {
        if (num==1){
            return 1;
        }
        return method(num-1)*num;
    }
    //用递归计算斐波那契数列
    public  static  int method1(int num){
        if(num==1||num==2){
            return 1;
        }
        return method1(num-1)+method1(num-2);
    }
}

• 输入50的输出结果

请输入一个数：
50
计算的阶乘是：-3258495067890909184//超过了long的范围
所用的时间是：0
计算数列的值是：12586269025
所用的时间是：43252 // 43秒

• 结论：
  • 递归虽然简单，但是特别慢！
  • 递归程序不光耗时，而且极其吃内存。