Java基础-类与对象（中）_java 中构造方法用什么关键字-CSDN博客

类中的方法定义对象的行为。

方法是一个命名的代码块。

调用方法的代码是方法的调用者。

可选地，方法可以接受来自呼叫者的输入值，并且它可以向呼叫者返回值。

输入值的列表称为参数。方法可以具有零参数。如果一个方法有零个参数，我们说该方法没有任何参数或方法不采取任何参数。

方法总是在类的主体内定义。

方法声明的一般语法是形式
<modifiers> <return type> <method name> (<parameters list>) <throws clause>{
    // Body of the method goes here
}
<modifiers>是修饰符的可选列表；

<return type>是从方法返回的值的数据类型；

<method name>是方法的名称。

方法参数

方法名称后面是一对开头和结尾的括号。

或者，我们可以在括号内为方法指定一个或多个参数。

多个参数用逗号分隔。

右括号可以后跟一个throws子句。

最后，我们为方法的开头和结尾括号指定代码。

方法声明中的四个部分是必需的：

返回类型，

方法名称，

一对开和关括号，和

一对开和关大括号。

以下是一个方法的示例：

它被命名为add；

它需要两个参数类型int命名为n1和n2，和

它返回它们的和：
int add(int n1, int n2)  { 
   int sum = n1  + n2; 
   return  sum;
}
有时，方法不会向其调用者返回值。如果方法不向调用者返回任何值，则使用关键字void作为返回类型。

方法名称必须是有效的Java标识符。

通常，Java方法从小写开始，随后使用字冠。

例如，getName，setName，getDogCount和createDog是有效的方法名称。

方法可以从其调用者获取输入值。参数用于从调用者获取输入值。

参数由两部分组成：数据类型和变量名称。方法参数是变量声明。

变量用于保存从方法的调用者传递的输入值。逗号分隔方法的两个参数。

在以下示例中，add方法声明两个参数n1和n2。两个参数都是int数据类型
int add(int n1, int n2)  { 
   int sum = n1  + n2; 
   return  sum;
}
当调用add方法时，调用者必须传递两个int值。

从调用者传递的第一个值存储在n1中，从调用者传递的第二个值存储在n2中。

参数n1和n2也称为形式参数。

方法通过其在特定上下文中的签名唯一地标识。方法的签名是其名称及其参数的数量，类型和顺序的组合。

参数传递

Java支持两种数据类型：基本数据类型和引用数据类型。

原始数据类型是一个简单的数据结构，它只有一个与之相关的值。引用数据类型是一个复杂的数据结构，它表示一个对象。

原始数据类型的变量将该值直接存储在其存储器地址处。

使用对象和引用变量时，事情会有所不同。

Java中的所有参数都通过值传递。

当参数是原始数据类型时，实际参数的值将复制到参数中。

对方法主体中的参数值进行的任何更改只会更改形式参数的副本，而不会更改实际参数的值。

当参数通过参考值传递时，存储在实际参数中的参考被复制到形式参数。实际参数和形式参数都指向内存中的相同对象。

您可以将另一个对象的引用分配给方法主体中的形式参数。

下面的代码演示了Java中的引用传递机制。

class Phone {
  public String model = "Unknown";
  public int year = 2014;
  public double price = 0.0;
}

public class Main {
  public static void main(String[] args) {
    Phone myPhone = new Phone();

    myPhone.model = "iPhone";
    myPhone.year = 2009;
    myPhone.price = 16000.0;

    System.out.println("#1: model  = " + myPhone.model + ", year   = "
        + myPhone.year + ", price = " + myPhone.price);

    Main.test(myPhone);

    System.out.println("#4: model  = " + myPhone.model + ", year   = "
        + myPhone.year + ", price = " + myPhone.price);
  }

  public static void test(Phone xPhone) {
    System.out.println("#2: model  = " + xPhone.model + ", year   = "
        + xPhone.year + ",  price = " + xPhone.price);

    // Let"s make xyCar refer to a new object
    xPhone = new Phone();

    System.out.println("#3: model  = " + xPhone.model + ", year   = "
        + xPhone.year + ", price = " + xPhone.price);
  }
}

上面的代码生成以下结果。

注意

当引用类型参数传递给方法时，形式参数可以访问对象，实际参数可以访问该对象。

形式参数可以通过直接更改实例变量的值或通过调用对象上的方法来修改对象。

通过形式参数对对象进行的任何修改都可以通过实际参数立即可见，因为它们都保存对内存中同一对象的引用。

形式参数本身可以被修改以引用方法内的另一个对象。

要禁用将引用类型形式参数更改为引用不同对象的方法，请在引用类型形式参数声明中使用关键字final 。

二、构造方法的定义

声明构造函数

构造函数声明的一般语法是
<Modifiers> <Constructor Name>(<parameters list>) throws <Exceptions list> {

}
构造函数的声明以修饰符开头。

构造函数可以将其访问修饰符作为public，private，protected或package-level（无修饰符）。

构造函数名称与类的简单名称相同。

构造函数名称后面是一对括号，可能包括参数。

可选地，右括号后面可以是关键字throws，其后面是逗号分隔的异常列表。

以下代码显示了声明类Test的构造函数的示例。类的名称和构造函数的名称必须匹配。
public class Test {

  public Test() {
    // Code goes here

  }
}
与方法不同，构造函数没有返回类型。

默认构造函数

具有包级访问权限的构造函数可以在声明其类的同一个包中使用。

编译器添加的构造函数称为默认构造函数。

默认构造函数没有任何参数。

默认构造函数也称为无参数构造函数。

如果类已经有一个构造函数，编译器不会添加任何构造函数。

使用构造函数

我们使用一个带有new操作符的构造函数来在创建新实例之后初始化类的实例。

new运算符创建一个对象，构造函数初始化该对象。

以下语句使用Test类的构造函数来初始化Test类的对象：
Test t = new Test();
以下代码显示了如何使用构造函数
class Cat {
  public Cat() {
    System.out.println("in constructor...");
  }
}

public class Main {
  public static void main(String[] args) {
    // Create a Cat object and ignore its reference
    new Cat();
    // Create another Cat object and store its reference in c
    Cat c = new Cat();
  }
}

三、this关键字

什么是 this？

Java有一个名为 this 的关键字。它是对类的当前实例的引用。

它只能在实例的上下文中使用。

以下代码显示如何使用this关键字。
public class Main {
  int varA = 1;
  int varB = varA; // Assign value of varA to varB
  int varC = this.varA; // Assign value of varA to varC
}
当实例变量或类变量被具有相同名称的另一个变量隐藏时，我们需要使用关键字this限定一个实例变量，并使用类名称定义一个类变量。

下面的代码显示了如何使用this关键字来引用一个实例变量，它的名字被一个局部变量隐藏。
public class Main {
  int num = 2014; // An instance variable

  void printNum(int num) {
    System.out.println("Parameter num: " + num);
    System.out.println("Instance variable num: " + this.num);
  }

  public static void main(String[] args) {
    Main tt6 = new Main();
    tt6.printNum(2000);
  }
}
上面的代码生成以下结果。

this关键字的三种常见用法

1.通过this关键字调用成员变量，解决与局部变量名称冲突问题。
class Person {
    int age;                            // 成员变量age
    public Person(int age) {   // 局部变量age
        this.age = age;          // 将局部变量age的值赋给成员变量age
    }
}
说明：在上面的代码中，构造方法的参数被定义为age，它是一个局部变量，在类中还定义了一个成员变量，名称也是age。在构造方法中如果使用“age”，则是访问局部变量，但如果使用“this.age”则是访问成员变量。

2.通过this关键字调用成员方法。
class Person {
    public void openMouth() {
        ...
    }
    public void speak() {
        this.openMouth();
    }
}
说明：在上面的代码中，使用this关键字调用了openMouth()方法。需要注意的是，此处的this关键字可以省略不写，也就是说上面的代码中，写成“this.openMouth()”和“openMouth()”效果是完全一样的。

3.通过this关键字调用构造方法。
class Person {    
    public Person() {
    }
    public Person(int age) {
        this();                  // 调用无参的构造方法
    }
}
说明：构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调
用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this([参数1,
参数2…])”的形式来调用其他的构造方法。