Java面向对象——构造方法和关键字（static、this、final、super）

1 构造方法(Constructor)

  1.构造方法和字段、方法一样，都是类中的成员之一；
  2.构造方法的结构和普通方法类似，除了下面几点：
  a.构造方法的名字和类名一致（包括大小写）；
  b.构造方法没有返回值类型（返回值类型就是这个类型本身）；
  c.构造方法内部不需要返回任何的数据（实际效果是调用后把创建好的对象返回）。

1.1 构造方法的特点

  1.每一个类中至少有一个构造方法；
  2.如果没有显示的构造方法，那么存在一个隐式的无参数的构造方法；
  3.如果一个类中有显示的构造方法，那么隐式的就不存在了。

public class Student1 {    String name;    int age;    // 显示的构造方法    Student1() {        System.out.println("构造方法");    }}

public class StudentTest1 {     public static void main(String[] args) {        // 创建一个对象        Student1 s = new Student1(); // 输出结果为构造方法    } }

1.2 构造方法的作用

  1.调用构造方法就可以创建一个对象；
  2.可以在创建对象的时候给对象中的字段初始化值。

public class Student2 {    String name;    int age;    Student2() {        System.out.println("显示的构造方法");    }    // 有参构造方法    Student2(String s, int a) {        name = s;        age = a;    }}

public class StudentTest2 {    public static void main(String[] args) {        // 字段初始化方式一        Student2 s = new Student2();         s.name = "小王";        s.age = 20;        System.out.println(s.name + "今年" + s.age + "岁"); // 小王今年20岁        // 直接在创建对象时赋值        Student2 s1 = new Student2("小明", 20); // 调用了有参数的构造方法        System.out.println(s1.name+"今年"+s1.age+"岁"); // 小明今年20岁    }}

2 static关键字

  static是Java的一个关键字，也是一个修饰符；可以修饰字段和方法，不能修饰外部类和局部变量。被static修饰的字段和方法在jvm加载类的过程中就会被初始化，并且只会初始化一次。
  static修饰的方法中，不能有this出现。

2.1 静态和非静态成员（字段，方法）的访问方式

  字段
  1.静态字段：（字段所在的类）类名.字段名

public class Student {    static int age = 10;}

public class StudentTest {    public static void main(String[] args) {        System.out.println(Student.age);    }}

  2.非静态字段：（字段所在的类的对象）对象名.字段名

public class Student {    int age = 10;}

public class StudentTest {    public static void main(String[] args) {        System.out.println(new Student().age);    }}

  方法
  1.静态方法：（方法所在的类）类名.方法名()

public class Student {    static void eat() {};}

public class StudentTest {    public static void main(String[] args) {        Student.eat();    }}

  2.非静态方法：（方法所在的类的对象）对象名.方法名(….)

public class Student {    void eat() {};}

public class StudentTest {    public static void main(String[] args) {        new Student().eat();    }}

2.2 static的应用

  1.静态字段：定义全局常量时使用。
  用public static final修饰的一个成员变量
  例如：Math.PI，Integer.MAX_VALUE等常量。

  2.静态方法：工具类中的工具方法。
  例如：Arrays中的所有方法全部都是静态修饰。

3 this关键字

  this：表示对调用方法的对象的引用，哪个对象调用this所在的成员，this就表示谁。this只能在方法内部使用。

public class Person {    private String name;    public void setName(String name) {         // this代表new Person()对象，将name值("小明")赋给这个对象的name        this.name = name;    }    public String getName() {        // 也可以this.name        return name;     }}

public class PersonTest {    public static void main(String[] args) {        // 创建对象        Person person = new Person();         // 赋值        person.setName("小明");         System.out.println(person.getName());    }}

  this的用法
  1.决成员变量和参数之间的二义性，如get、set方法中使用；
  2.同类中构造方法重载的互调，this()必须写在第一行；

public class Person {    private String name;    private int age;    // 构造方法    public Person(String name) {         this.name = name;    }    public Person(String name, int age) {        // this(参数)调用上面的构造方法        this(name);         this.age = age;    }}

  this()：表示调用同类中无参的构造方法
  this(…)：表示调用同类中具有指定参数的构造方法

  3.作为返回值返回当前对象的引用；

public class Leaf{    int i = 0;    Leaf increment(){        i++;        // 返回当前对象的引用        return this;    }    // 打印i    void  print(){        System.out.println(i);    }    public static void main(String[] args) {        Leaf l =new Leaf();        // 返回当前对象的引用，可以重复调用方法        l.increment().increment().increment().print();// 结果为3    }}

  4.作为参数传递。

class A {    static B a(B b){        return b;    }}

// B类中需要调用A类中的a方法，并且参数为自身，可以用this来传递。class B {    B getA(){        return A.a(this);    }}

4 final关键字

  final：java中的关键字，表示不可变的。final也是一个修饰符，可以修饰类、方法、成员变量和局部变量。

  final修饰类
  使用final修饰类，表示该类是不可被继承的类，比如String，Integer等包装类。

public final class A {} // 类用final修饰，不能再有子类继承

public class B extends A {} // 编译报错The type B cannot subclass the final class A 

  final修饰的类中的方法都隐式的指定为final，因为无法继承覆写它们。

  final修饰方法
  父类中final修饰的方法不可被覆写。

public class A {    final void t(){} // 方法用final修饰，不能被覆写    }

public class B extends A {     void t(){} // 编译报错Cannot override the final method from A}

  final修饰变量
  1.修饰基本类型变量：表示该变量的值不能改变，不能用等号重新赋值；
  2.修饰引用类型变量：表示该变量的引用地址不能变，而不是引用地址中的内容不能变。

public class Dragon {    String name;    Dragon(String name) {        this.name = name;    }}

public class Test {    public static void main(String[] args) {        // 对象中d地址不能被改变        final Dragon d = new Dragon("小龙");         // 对象中的内容可以改变        d.name = "纳什男爵";         System.out.println(d.name);//纳什男爵    }}

  3.全局静态常量：用 public static final修饰的。
  如Math类中：public static final double PI = 3.141592653。

  4.修饰参数：如果参数为基本数据类型，表示参数值无法修改，只能读取；如果参数为引用类型，表示参数的引用地址不能改变。

class FinalTest{    // 修饰基本数据类型参数    public void testInt(final int param1) {        param1 = 100;// 编译报错：The final local variable param1 cannot be assigned    }    // 修饰引用数据类型参数    public void testFinal(final Object param2) {        param2 = new Object();// 编译报错：The final local variable param2 cannot be assigned    }}

5 super关键字

  super：表示当前对象的父类对象。

  super的使用
  1.通过super访问父类对象中的非私有的字段和方法。

// 父类public class User {     String name = "大龙";}

public class Student extends User {    String name = "小龙";    Student() {        System.out.println(this.name);        // 访问了父类中的字段name        System.out.println(super.name);     }}

public class SuperTest {    public static void main(String[] args) {        Student s = new Student();// 小龙 大龙}

  2.在子类构造方法中访问父类的构造方法：
  super()：调用父类中的无参构造方法;
  super(…)：调用父类中有一个有参数的构造方法;
  该方法必须放在子类构造方法的第一句。

public class User { // 父类    String name;    User(String name) {        this.name = name;    }}

public class Student extends User {    int age;    Student(String name, int age) {        // 调用了父类中User(String name)方法，从而赋值        super(name);         this.age = age;    }}

public class SuperTest {    public static void main(String[] args) {        User u = new User("大龙");        Student s = new Student("小龙", 20);        System.out.println(u.name + "," + s.name + "," + s.age); // 大龙,小龙,20    }}

  3.特殊情况：在子类中的构造方法里面存在默认（隐式）的调用父类的无参数构造方法super()。

public class User {    // 无参构造方法，被子类中隐式构造方法super()调用    public User() {         System.out.println("大龙");    }    // 有参构造方法，若调用此方法，则取消调用无参构造方法    public User(int i) {         System.out.println("小龙");    }}

public class Student extends User {    Student() {        // 子类的构造方法中存在隐式调用父类无参构造方法super()        System.out.println("纳什男爵");         }}

public class SuperTest {    public static void main(String[] args) {        new Student();// 会创建一个父类和一个子类(大龙,纳什男爵)    }}

  与this比较
  一个构造方法中调用另一个构造方法用this；子类构造方法中调用父类构造方法用super。