Java学习笔记(温故知新)2——方法、方法的重载、递归结构、new对象(实例化对象)

Java学习笔记(温故知新)2

一、方法

方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法声明格式：

 public static int add(int n1, int n2) {
 	int sum = n1 + n2;
    return sum;//使用return返回计算的结果
}
[修饰符1  修饰符2  …]   返回值类型    方法名(形式参数列表){
    Java语句；… … …
 }

方法的调用方式：

int sum = add(num1, num2);//调用求和的方法：将num1与num2的值传给add方法中的n1与n2
System.out.println("sum = " + sum);//调用打印的方法：该方法没有返回值

​ 对象名.方法名(实参列表)

​ 方法的详细说明

​ 1. 形式参数：在方法声明时用于接收外界传入的数据。

​ 2. 实参：调用方法时实际传给方法的数据。

​ 3. 返回值：方法在执行完毕后返还给调用它的环境的数据。

​ 4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。

注意事项

​ 1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。

​ 2. return 语句终止方法的运行并指定要返回的数据。

​ 3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：

​ 4. 基本类型传递的是该数据值的copy值。

​ 5. 引用类型传递的是该对象引用的copy值，但指向的是同一个对象。

方法调用的分类：
（1）静态方法 直接使用 类名.方法名 调用
（2）普通方法 通过new创建对象 然后使用 对象.方法 调用
（3）直接使用方法名调用的情况有两种：

• 在main函数中，只能调用main方法所在类的方法，并且该方法必须是静态的才可以
• 在自定义类中，不是静态也可以，直接方法名也能调用，因为默认省略this
  method();其实就是this.method();
• 同一类的方法直接可以直接调用
• 当前的类是一个子类的时候,可以直接调用父类的方法，用this.方法名(用this调用所在方法不能与父类的方法重名否则造成无限递归)或者super.方法名调用父类方法

二、方法的重载

方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。

重载的方法，实际是完全不同的方法，只是名称相同而已!

​ 构成方法重载的条件：

​ 1.不同的含义：形参类型、形参个数、形参顺序不同

​ 2.只有返回值不同不构成方法的重载

​ 3.只有形参的名称不同，不构成方法的重载

 /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数个数不同，构成重载
    public static int add(int n1, int n2, int n3) {
        int sum = n1 + n2 + n3;
        return sum;
    }
    // 方法名相同，参数类型不同，构成重载
    public static double add(double n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数顺序不同，构成重载
    public static double add(int n1, double n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有返回值不同，不构成方法的重载
    public static double add(int n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有参数名称不同，不构成方法的重载
    public static int add(int n2, int n1) {
        double sum = n1 + n2;         
        return sum;
    }  

三、递归结构

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。

递归的三个条件：

1.边界条件

2.递归前进段

3.递归返回段

当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

/*
 * 实现5的阶乘
 */
public class DiGuiDemo {
    public static void main(String[] args) {
        System.out.println(JieCheng(5));
    }
    
    //递归计算阶乘
    public static int JieCheng(int n){
        if(n == 1){
            return 1;
        }else {
            return n*JieCheng(n-1);  //自己调用自己
        }
    }
}

四、谈谈new对象

Test a = new Test();
类名 对象名=new 类名();

这里Test是类名，a是对象(引用变量)，new指一个实例化对象，Test()是构造方法；

连起来就是创建一个名称为a的Test类的以Test()构造方法初始化的实例化对象。

“=”操作符使对象a引用指向刚new的那个Test对象。所以这里有两个实体：a是对象引用变量，右边的“new Test”，是以Test类为模板，在堆空间里创建一个Test类对象（也简称为Test对象）即对象本身。

之所以会有引用变量，是因为我们可以创建无数个Test对象，而我们不可能都叫做Test，而且Test是类名，所以我们用引用变量a来指向这个新创建的Test类的对象，建立它们之间的联系。

• 类名 对象名 创建名称为“对象名”的“类名”类引用变量
  new ; 1.分配内存，创建对象。2.调用构造方法，完成对象的初始化工作。
  类名() 无参数构造方法；
  new 类名(); 以无参数构造方法实例化对象；
  类名 对象名=new 类名(); ** 用指针的解释就是以无参数构造方法实例化对象并将这个对象的内存引用**赋给“类名”类的“对象名”引用变量

Java中创建对象，通常会跟一个new的关键字，表示生成一个对象。后面的构造方法其实是为了完成对象中变量的初始化工作。如果你的类中没有构造方法，系统会自动给你添加一个无参的构造方法，但如果你创建了一个有参的构造方法，必须手动加一个无参的构造方法，才能使用无参的构造方法。

就和String a = “123”;一样String是数据类型，a是变量名也是一个对象，123即给对象a初始化。

Java初始化对象可以有很多种，比如new一个对象、或者通过clone来克隆一个对象。类都提供了一个默认的构造方法，里面为空，用户是可以自己编写构造方法，用来初始化变量。

有人可能会问，构造方法是如何初始化的？

举个例子，

public class Test {
	String name;
	int age;
	public Test(){//无参构造方法
        
	}
	
	public Test(String name,int age) {//有参构造方法
        this.name = name;
		this.age = age;
	}
    
	public void name(String name) {
        this.name = name;
	} 
    
    public void age(int age) {
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public static void main(String[] args) {
        Test t1 = new Test();
        t1.name("小明");
        t1.age(18);
        System.out.println(t1.getName() + " " + t1.getAge());
        Test t2 = new Test("小红",17);
        System.out.println(t2.getName() + " " + t2.getAge());
    }
}

运行结果：

小明 18
小红 17

从中我们可以看到在new Test()时，构造方法对对象t1中的String name;int age;初始化为空，而new Test(“小红”,17)时，我们初始化了t2中的name="小红"和age=17。所以构造方法的初始化是对 对象中的变量进行初始化。

对象的初始化顺序
它首先去看父类里面有没有静态代码块，如果有，它先去执行父类里面静态代码块里面的内容，当父类的静态代码块里面的内容执行完毕之后，接着去执行子类(自己这个类)里面的静态代码块，当子类的静态代码块执行完毕之后，它接着又去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法，这个就是一个对象的初始化顺序。

Java中变量就是指向一个对象或包含一个值的标识符，而变量的内容可以是一个值也可以是一个对象的引用。引用变量我们可以类比C中的指针，但Java中并没有指针。

当变量的类型是一个类时，则对象的内容是指向一个对象的引用。如果变量的类型是基本数据类型（如int、double等八种数据类型），则变量的内容是一个值。

大家觉得有用麻烦点个赞，我研究了好久呢?