JavaSE(12)-方法

方法

方法的定义

概述：

• 方法是语句的集合，它们在一起执行一个功能
• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或者对象中
• 方法在程序中被创建，在其他地方被引用

设计方法的原则：

• 方法的本意是功能模块，就实现某个功能的语句块的集合
• 我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，利于后期的扩展

语法：

修饰符	返回值类型	方法名(参数类型 参数名){
	...
	方法体
	...
	return 返回值;
}

• 修饰符：定义了该方法的访问类型
• 返回值类型：
  • 有返回值：returnValueType是方法返回值的数据类型
  • 没返回值：returnValueType的默认关键字是void
• 方法名：方法的实际名称。方法名和参数表共同构成方法签名
• 参数类型：参数像一个占位符，当一个方法被调用时，传递值给参数。这个值被称为实参数或者变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法也可以包含参数。
  • 形式参数：在方法被调用时候用于接收外界输入的数据
  • 实参：调用方法时实际给方法的数据
• 方法体：方法体包含具体的语句，定义该方法的功能

修饰符

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

值传递与引用传递

• 值传递：实参传递给形参的是值 形参和实参在内存上是两个独立的变量 对形参做任何修改不会影响实参

• 引用传递：实参传递给形参的是参数对于堆内存上的引用地址实参和形参在内存上指向了同一块区域对形参的修改会影响实参

静态方法和实例方法的区别

静态方法：

• 属于整个类所有，因此调用它不需要实例化
• 静态方法只能访问静态成员，不能访问实例成员
• 在程序运行期间，静态方法是一直存放在内存中，因此调用速度快，但是却占用内存

实例方法：

• 实例方法必须先实例化，创建一个对象，才能进行调用（对象.实例方法（））

• 实例方法可以访问静态成员和实例成员

• 实例方法是使用完成后由回收机制自动进行回收，下次再使用必须再实例化

构造方法

概述：

• 类构造对象时调用的方法，主要用来实例化对象。构造方法分为无参构造方法、有参构造方法
• 类中默认有无参构造

作用：

• 一般用来初始化成员属性和成员方法的，即new对象产生后，就调用了对象了属性和方法

注意：

• 构造方法不能被static、final、synchronized、abstract和native修饰。
• 构造方法可以重载，方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法
• 构造方法是不被继承的

代码演示：

• 无参数构造和有参数构造

public class Person {
    private String name;
    private int age;

  	 public Person() {   //默认无参数构造
    }
    
    public Person(String name, int age) {  //有参数构造
        this.name = name;
        this.age = age;
    }
}

this关键字

概述：

• this 关键字用来表示当前对象本身，或当前类的一个实例，通过 this 可以调用本对象的所有方法和属性
• this 只有在类实例化后才有意义

作用：

• 当成员变量与局部变量同名时，用来区分成员变量和局部变量
• 在一个构造函数中可以调用另外一个构造函数初始化对象

代码演示：

public class Demo01 {

    public static void main(String[] args) {

        Animal animal = new Animal();
        animal.eat();
    }

}

class Animal{
    String name = "狗"; //成员变量
    String color;

    public void eat(){
        String name = "猫"; //局部变量
        System.out.println("我养了一只："+this.name);
    }
}

输出：
我养了一只：狗 

方法的调用

• 调用方法：对象名.方法名(实参列表)

Java支持两种调用方法的方式，根据方式否返回值来选择

• 当方法返回要一个值的时候，方法调用通常被当作一个值

• 当方法返回值时void，方法调用一定是一条语句

代码演示：

public static void main(String[] args) {

    //比大小
    int result = max(30, 40);
    System.out.println(result);
}

public static int max(int num1,int num2){

    int result = 0;

    if (num1==num2){
        System.out.println("num1==num2");
        return 0;
    }

    if (num1>num2){
        result = num1;
    }else {
        result = num2;
    }

    return result;
}

输出：
40  

方法的重载

简述：

• 在一个类中，我们可以定义多个方法。如果有一系列方法，它们的功能都是类似的，只有参数有所不同，那么，可以把这一组方法名做成同名方法
• 重载就是在一个类中，有相同的函数名称，但形参不同的函数

方法的重载的规则：

• 方法名称必须相同
• 参数列表必须不同（个数不同、或类型不同、参数列表排序不同等）
• 方法的返回类型可以相同也可以不同
• 仅仅返回类型不同不足以成为方法的重载

实现理论：

• 方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错

代码演示：

public class Demo02 {
    
    public static void main(String[] args) {

        Hello hello = new Hello();
        hello.hello();
        hello.hello("codepigpig");
        hello.hello("codepigpig",22);
    }
}
class Hello{
    public void  hello(){
        System.out.println("Hello,world");
    }

    public void hello(String name){
        System.out.println("Hello,"+name);
    }

    public void hello(String name,int age){
        if (age>18){
            System.out.println("Hi,"+name+",你已经成年了");
        }else {
            System.out.println("Hi,"+name+",你是未成年");
        }
    }
}    

输出：
Hello,world
Hello,codepigpig
Hi,codepigpig,你已经成年了  

可变参数

简述：

• 从JDK1.5开始，Java支持传递同类型的可变参数给了一个方法
• 本质是一个数组

用法：

• 在方法声明中，在指定参数类型后加一个省略号(…)
• 一个方法中只能制定一个可变参数，他必须是方法的最后一个参数。任何普通参数必须在它之前声明

代码演示：

public class Demo03 {

    public static void main(String[] args) {
        printMax(1,20,30,5,46,3,4);
    }

    public static void printMax(double... numbres){
        if (numbres.length == 0){
            System.out.println("No argument passed");
            return;
        }

        double result = numbres[0];

        //找最大值
        for (int i = 1; i < numbres.length; i++) {
            if (numbres[i]>result){
                result = numbres[i];
            }
        }

        System.out.println("The max value is "+result);
    }
}

输出：
The max value is 46.0  

递归

简述：

• 递归就是A方法调用A方法，自己调用自己

用处：

• 利用递归可以用简单的程序来解决一些复杂的问题。它通常吧一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。
• 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大减少了程序的代码量
• 递归的能力在于用有限的语句来定义对象的无限集合

递归的结构：

• 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
• 递归体：什么时候需要调用自身方法

注意：

• 能不能用递归就不能递归，重要递归的思想
• 基数小的时候可以用递归，基数大其他算法代替

代码演示：

public class Demo04 {

    public static void main(String[] args) {
        int f = f(5);
        System.out.println(f);
    }

    public static int f(int n){

        if (n == 1){
            return 1;
        }else {
            return n*(f(n-1));
        }
    }
}

输出：
120