//JAVA方法
/* 在前面几个章节我们用到的System.out.println()到底是什么呢？
* println()是一个方法
* System 是系统类
* out 是标准输出对象
* 综上所述，这句话的整合意思是：调用系统类System中的标准输出对象out中的方法println()
*
* 那么，在JAVA中到底什么是方法呢？
* JAVA方法是语句的集合，他们在一起执行一个功能。
* 方法是解决一类问题的步骤的有序组合。
* 方法包含于类或对象中。
* 方法在程序中被创建，在其他地方被引用。
*
* 方法的优点：
* 使程序变得简短而清晰。
* 有利于程序的维护。
* 可以提高程序开发的效率。
* 提高了代码的重（chong)用性。
*
* 方法的命名规则：
* 方法的名字的第一个单词的 首字母应小写，后面的单词则以大写开头 eg:addPerson（与类不同，类的名字的首字母应该大写）
*
* 方法的定义：
* 一般情况下，定义一个方法包含以下语法：
* 修饰符 返回值类型 方法名（参数类型 参数名）{
* ...
* 方法体
* ...
* return 返回值;
* }
*
* 方法包含一个方法头和方法体，下面是一个方法的各个部分的说明：
* 修饰符：修饰符，可选，告诉编译器如何调用该方法，定义了该方法的访问类型
* 返回值类型：方法可能会返回值，returnValueType是方法返回值的数据类型，有些方法执行所需的操作但没有返回值，此种情况下returnValueType的关键字的void.
* 方法名：是方法的实际名称，方法名和参数表共同构成方法签名。
* 参数类型：参数相当于一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或者变量。参数列表是值方法的参数类型，顺序和参数的个数，参数是可选的，方法可以不包含任何参数。
* 方法体：方法体包含具体的语句来定义方法的功能。
* eg:public //修饰符 static //修饰符 int //返回值类型 age //方法名 (int //参数类型 birthday //变量名){ 方法体 } //参数可以有多个，合在一起统称参数列表
*/
//实例： 返回两个参数num1,num2中的较大值。
public static int max(int num1,int num2){
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
//更简略的写法：
public static int max(int num1,int num2){
return num1>num2 ? num1:num2; //此处穿插一个问号（？）运算符的用法，JAVA提供的特别三元运算符，用来取代某个类型的if-then-else语句，expr1 ? expr2:expr3
//其中,expr1是一个布尔表达式，如果expr1为真，则expr2被求值否则expr3被求值。expr1,expr3数值类型必须相同
}
//方法调用
/* JAVA支持两张调用的方式，根据方法是否返回值来选择。
* 在程序调用一个方法时，程序的控制权交给了被调用的方法，当被调用的方法的返回语句执行或者到达方体闭括号时候交换控制权给程序。
* 当方法返回一个值的时候，方法调用通常被当作一个值：
* int larger = max(30,40); //larger为变量名，max为方法名
*
* 如果方法返回值是void,方法调用一定是一条语句，例如方法Prinln返回void，下面调用的是一个语句(这个地方还有点不理解，以后再回来看看)
* System.out.println("Hello World");
*/
// How to define a method?
public class TestMax{
//主方法
public static void main(String[] args){
int i = 5;
int j = 2;
int k = max(i,j);
System.out.println(i + "and" + j + " the larger one is " + k);
}
//return the larger number
public static int max(int num1,int num2){
int result;
return num1>num2 ? num1:num2;
}
}
//void关键字
public class TestVoidMethod{
public static void main(String[] args){
printGrade(78.5); //一个void方法的调用一定是一个语句，所以它再被main方法第三行以语句的形式调用。
}
public static void printGrade(double score){
if (score >= 90.0){
System.out.println('A');
}
else if (score >= 80.0){
System.out.println('B')；
}
else if (score >= 70.0) {
System.out.println('C');
}
else if (score >= 60.0) {
System.out.println('D');
}
else {
System.out.println('F');
}
}
} //这里的printGrade方法是一个void类型方法，它不返回值。
//通过值传递参数
public static void nPrintln(String message,int n){
for (int i = 0; i < n; i++){ //连续n此打印一个消息
System.out.println(message);
}
}
//eg:
public class TestPassByValue{
public static void main(String[] args){
int num = 1;
int num2 = 2;
System.out.println("the value of num before swapping: " + num1 + "and that of num2:" + num2);
//调用swap方法
swap(num1,num2);
System.out.println("the value of num 1 after swapping :"+ num1 + "and that of num2:" + num2);
}
//交换两个变量的方法
public static void swap(int n1, int n2){
System.out.println("\t进入swap方法")；
System.out.println("the value of n1 and n2 before swapping are relatively:" + n1 + n2);
//swap the value of n1 and n2
int temp = n1; //此处temp算是一个n1的中转站
n1 = n2;
n2 = temp;
System.out.println("\t\t the value of n1 and n2 after swaping are relatively"+ n1 + n2);
}
}
/*
*方法的重载
*上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点类型数据的最大值呢？
*解决方法是创建另一个有相同名字但参数不同的方法，如下面代码所示：
*/
public static double max(double num1, double num2) {
if (num1 > num2)
return num1;
else
return num2;
}
/*如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；
*
*如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；
*
*就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。
*
*Java编译器根据方法签名判断哪个方法应该被调用。
*
*方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。
*
*重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。
/*
/*变量作用域
*变量的范围是程序中该变量可以被引用的部分。
*
*方法内定义的变量被称为局部变量。
*
*局部变量的作用范围从声明开始，直到包含它的块结束。
*
*局部变量必须声明才可以使用。
*
*方法的参数范围涵盖整个方法。参数实际上是一个局部变量。
*
*for循环的初始化部分声明的变量，其作用范围在整个循环。
*但循环体内声明的变量其适用范围是从它声明到循环体结束。它包含如下所示的变量声明：
//命令行参数的使用
/* 有时候你希望运行一个程序的时候再传递给它消息，这要靠传递命令行参数给main()实现
* 命令行参数是再执行程序的时候紧跟在程序后面的信息
*/
public class CommandLine{
public static void main(String[] args){
for(int i =0; i<args.length;i++){
System.out.println("args[" + i + "]:" + args[i]);
}
}
}
//构造方法
/* 当一个对象被创建的时候，构造方法用来初始化该对象，构造方法和它所在的子类名字相同，但构造方法没有返回值。
* 通常会使用构造方法给一个类的实例变量赋初值，或者执行其他必要步骤来创建一个完整的对象
* 不管你是否定义构造方法，所有的类都有构造方法，因为JAVA默认提供了一个构造方法，默认构造方法的访问修饰符和类的访问修饰符相同（类为Public,构造函数也为public)
* 一旦你定义了自己的构造方法，默认构造方法就会失效。
* 下面是一个构造方法的例子 */
//一个简单的构造函数
class myClass{
int x;
//以下是构造函数
myClass(){
x = 10;
}
}
//也可以像下面这样调用构造方法来初始化一个对象
public class ConsDemo{
public static void main(String[] args){
myClass t1 = new MyClass();
myClass t2 = new MyClass();
System.out.println(t1.x + " " + t2.x);
}
}
//可变参数
//JDK1.5开始，JAVA支持传递同类型的可变参数给一个方法
public class VarargsDemo{
public static void main(String[] args){
//调用可变参数的方法
printMax(34,3,3,2,56.5); //除了56.5本来都是int
printMax(new double[]{1,2,3});
}
public static void printMax(double... numbers){ //一个方法只能指定一个参数，它必须的方法的最后一个参数，任何普通的参数必须在它之前声明。
if(numbers.length == 0){
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for ( int i = 1;i<numbers.length;i++){
if(numbers[i] > result){
result = numbers[i];
}
}
System.out.println("The max value is " + result);
}
}
//finalize()方法
/*
* JAVA允许定义这样的方法，它在对象被垃圾收集器回收之前调用，这个方法叫做finalize()，它用来清除回收对象。
* 例如你可以使用finalize()来确保一个对象打开的文件被关闭了
* 在finalize()里，你必须指定在对象销毁的时候要执行的操作
*/
//finalize()格式：
protected void finalize(){ //protected是一个限定符，它确保finalize方法不会被该类以外的代码使用。 当然JAVA的内存回收可以由JVM来自动完成。
//终结代码
}
public class FinalizationDemo{
public static void main(String[] args){
Cake c1 = new Cake(1);
Cake c2 = new Cake(2);
Cake c3 = new Cake(3);
c2 = c3 = null;
System.gc(); //调用JAVA垃圾收集器
}
}
class Cake extends Object{
private int id;
public Cake(int id){
this.id = id;
System.out.println("Cake Object" + id + "is created");
}
protected void finalize() throws java.lang.Throwable{
super.finalizee();
System.out.println("Cake Object" + id + "is disposed");
}
}
D53C92B3-9643-4871-8A72-33D491299653.jpg
