Java学习-方法

一、基本概念

项目	含义
含义	解决一类问题的步骤的有序组合。
位置	类或对象中
引用	程序中被创建，在其他地方被引用
优点	简短、清晰、易于维护、开发效率高、重用性高

二、构造方法

2.1 基本含义

语法：public 类名(参数列表){ 方法体 }

项目	含义
名字	与所在类的类名相同。
作用	创建对象。初始化实例变量（成员变量、非静态变量）。
别名	构造函数、构造器
数量	未创建时，Java自动创建一个无参数列表和方法体的构造器。
调用	构造函数所在类名 对象名 = new 构造函数名(实参列表);
this	可使用

注意：
调用空构造器创建对象时，系统会给对象设置默认值。

实例变量	值
数值型	0
布尔型	false
char类型	\u0000
引用类型	null

2.2 构造器的重载

含义：参数列表不同的构造函数。
注意：
构造器中调用构造器时：

1. 本构造器中，必须使用“this(参数)”结构。
2. 本构造器中，“this(参数)”必须放在有效执行第一行。
3. 本构造器中，“this(参数)”只能出现一次。

public calss Student{
  // 构造器：无参。
  public Student(){
  }
  // 构造器： 三个参数。
  public Student(String name, int age, String sex){ 
    /* 
     * 目的：调用一个参数的构造器。
     * 注意事项：
     * 1. 语法：this(参数列表);
     * 2. 位置：本构造器有效执行首行。
     * 3. 唯一性：只能调用一次。
     */
    this(age); // 本构造器有效执行首行。
    this.name = name;
  }
  // 构造器：两个参数。
  public Student(int age){
    if(age > 120 || age < 0){
      System.out.println("输入的年龄不合法！");
    }else{
      this.age = age;
    }
  } 
  // 构造器：一个参数。
  public Student(String name){
    this.code = code;
  }
  
}

2.3 示例

主函数入口源文件：

public class Test{
  public static void main(String[] args){
    // 创建对象：调用构造函数。
    ConstructorDemo stu = new ConstructorDemo(3,"张三");
    System.out.println(stu.name + "是" + stu.clazz + "班的学生");
  }
}

引用类源文件

public class ConstructorDemo{
  // 创建构造函数
  public ConstructorDemo(int c, String n){
    this.clazz = c;
    this.name = n;
  }
  int clazz;
  String name;  
}

三、类方法

语法：public static 返回值数据类型 方法名(形参列表){ 方法体 }

项目	含义
名字	自定义。
作用	一般引用。
别名	静态方法
数量	不限。
调用	类名.方法名(实参列表);
this	不可使用

注意：

1. 直接调用时：本类中，静态方法只能调用静态成员（静态变量+静态方法）。
2. 间接调用时：同包类中，对象名.非静态方法名。

四、对象方法

语法：public 返回值数据类型 方法名(形参列表){ 方法体 }

项目	含义
名字	自定义。
作用	一般引用。
别名	非静态方法、普通方法
数量	不限。
调用	对象名.方法名(实参列表);
this	可使用

注意：

1. 直接调用时：本类中，非静态方法可以调用任何成员。
2. 间接调用时：同包类中，对象名.非静态方法名。

主函数入口源文件：

public class TestPassByValue {
  // 静态方法
  public static void main(String[] args){	 
  	 /* 
  	 * 调用非静态成员时,对象名.非静态成员。
     * 调用静态成员时,所在类名.静态成员。
     */ 
	  ConstructorDemo stu = new ConstructorDemo(4,"张三1");
	  stu.introduce();	// 静态方法调用非静态方法  
	  System.out.println(stu.name); // 静态方法调用非静态变量。
	  ConstructorDemo.swap(5,3); // 静态方法调用静态方法 
	  System.out.println(ConstructorDemo.PI); // 静态方法调用静态变量。
  }
  // 非静态方法
  public void fun1(){
     /* 
  	 * 调用非静态成员时,对象名.非静态成员。
     * 调用静态成员时,所在类名.静态成员。
     */
	  ConstructorDemo stu2 = new ConstructorDemo(3,"张三");
	  stu2.introduce(); // 非静态方法调用非静态方法 
	  System.out.println(stu2.name); // 非静态方法调用非静态变量。
	  ConstructorDemo.swap(5,3); // 非静态方法调用静态方法 
	  System.out.println(ConstructorDemo.PI); // 非静态方法调用静态变量。
  }
}

引用类源文件

public class ConstructorDemo {
	public ConstructorDemo(int clazz, String name){
		this.clazz = clazz;
		this.name  = name;
	}
	int clazz;
	String name;
	public static double PI =3.1415;
    // 数字交换。
	public static void swap(int n1, int n2){
		System.out.println("交换前：n1 = " + n1 + " , n2 = " + n2);
		int temp = n1;
		n1 = n2;
		n2 = temp;
		System.out.println("交换后：n1 = " + n1 + " , n2 = " + n2);	
	}
	// 自我介绍
	public void introduce(){
		System.out.println(this.name + "是" + this.clazz + "班的学生"); 
		swap(2,3);
	}
	// 静态方法
    public static void fun1(){
       /* 
  	   * 调用非静态成员时,对象名.非静态成员。
       * 调用静态成员时,静态成员。
       */
		ConstructorDemo stu3 = new ConstructorDemo(4, "王五");
		stu3.introduce();// 静态方法调用非静态方法。
		System.out.println(stu3.clazz);// 静态方法调用非静态变量。
		swap(5,3); // 静态方法调用静态方法 
		System.out.println(pi); // 静态方法调用静态变量。
	}
   // 非静态方法	
	public void fun2(){
	    /* 
  	     * 调用非静态成员时,非静态成员。
         * 调用静态成员时,静态成员。
         */
		introduce(); // 非静态方法调用非静态方法 
		System.out.println(name); // 非静态方法调用非静态变量。		  
		swap(5,3); // 非静态方法调用静态方法 
		System.out.println(pi); // 非静态方法调用静态变量。
	}
}

五、方法的重载——本身

项目	含义
方法名	相同
参数列表	不同
访问控制修饰符	不限
非访问控制修饰符	不限
返回值类型	不限

六、方法的重写——父类

项目	含义
目的	继承父类时，展现特性。
别名	覆盖（override）
方法名	与父类相同
参数列表	与父类相同
访问控制修饰符	不小于父类
非访问控制修饰符	不限
返回值类型	不大于父类
抛出的异常类	不大于父类

七、可变参数

语法： 可变参数数据类型… 可变参数名
注意：

1. 一个方法只有一个可变参数。
2. 必须是参数列表的最后一个参数。

public class Test{
  public static void main(String[] args){
    printMax(2,3,5,1,2,5,6);
    printMax(new double[]{1,3,5,2});
  }
  public static void printMax(double... numbers){
   if(numbers.length == 0){
     System.out.println("没有传入数字！");
     return; // 直接结束该方法，后面语句不执行。
   }
   double result = numbers[0];
   for(int i = 1; i < numbers.length; i++){
     result = numbers[i] > result ? numbers[i] : result;
   }
   System.out.println("最大值为：max = " + result);
  }
}

八、finalize() 方法

作用：用来清除回收对象。即Java垃圾收集器。
一般语法：

// Java的内存回收——手动法
protected void finalize(){
  // 必须指定在对象销毁时候要执行的操作。
}
// Java的内存回收——自动法
// 由JVM来自动完成。