面向对象(四)：this关键字，final关键字，抽象类，接口

this关键字

Java中提供了 this 关键字来指代当前对象，用于在方法中访问对象的其他成员。

• 通过 this 关键字调用成员方法，解决与局部变量名称冲突问题

package com.wang.demo1;

public class Person {
    int age;              //成员变量 age

    public Person(int age) {  //局部变量 age
        this.age = age;    //将局部变量 age 的值赋给成员变量 age
    }
}

以上代码，构造方法的参数被定义为 age，是一个局部变量，在类中还定义了一个成员变量，名称也是 age，使用“ this.age ”是访问成员变量

• 通过 this 关键字调用成员方法

package com.wang.demo1;

public class Person {
    public void say() {
        System.out.println();
    }
    
    public void go() {
        this.say();
    }
}

在上面的 go() 方法中，使用 this 调用了 say() 方法。需要注意的是，此处的 this 关键字可以省略不写。

• 通过 this 关键字调用构造方法

package com.wang.demo1;

public class Person {
    //无参构造方法
    public Person() {
        System.out.println("无参构造被调用了");
    }
    //有参构造方法
    public Person(int age) {
        this();               //调用无参构造方法
        System.out.println("有参构造被调用了");
    }

    public static void main(String[] args) {
        //实例化 Person 对象
        Person person = new Person(18);
    }
}

以上代码中，在实例化 Person对象时，调用了有参的构造方法，在有参构造方法中又通过 this() 调用了无参的构造方法，运行结果中显示两个构造方法都被调用了。

this调用类的构造方法的注意点：

• 只能在构造方法中使用 this 调用其他的构造方法，不能在成员方法中使用
• 在构造方法中，使用 this 调用构造方法的语句必须是该方法的第一条执行语句，且只能出现一次
• 不能在一个类的两个构造方法中使用 this 互相调用

final 关键字

final 关键字用于修饰类，变量和方法，它有 “不可更改” 或者 “最终” 的含义，它有以下特点：

• final 修饰的类不能被继承
• final 修饰的方法不能被子类重写
• final 修饰的变量（成员变量和局部变量）是常量，只能赋值一次

注意： 当局部变量使用 final 关键字时，可以在声明变量的同时对变量进行赋值，也可以先声明变量然后再进行有且只有一次的赋值。 当成员变量使用 final 关键字时，在声明变量的同时必须进行初始化赋值，否则程序编译报错。

抽象类

• abstract 修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
• 抽象类中可以没有抽象方法，它可以有普通方法；但是有抽象方法的类，一定要声明为抽象类
• 抽象类，不能使用 new 关键字来创建对象，不可以被实例化，它是用来让子类继承的
• 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
• 子类继承抽象类，就必须要实现抽象类中没有实现的抽象方法，否则该子类也要声明为抽象类

抽象类及抽象方法的格式：
    //定义抽象类
    修饰符 abstract class 类名 {
        //定义抽象方法
        public abstract 返回值类型 方法名();
        
        //其他方法或属性
    }

package com.wang.demo2;
//定义抽象类
public abstract class Animal {
    //定义抽象方法
    public abstract void shout();
}
============================
package com.wang.demo2;
//定义 Dog类继承抽象类 Animal
public class Dog extends Animal {
    //实现抽象方法 shout()，编写方法体
    @Override
    public void shout() {
        System.out.println("汪汪。。。");
    }
}
============================
package com.wang.demo2;

public class Application {
    public static void main(String[] args) {
        Dog dog = new Dog(); //创建 Dog类实例对象
        dog.shout();
    }
}

接口

​如果一个抽象类中的所有方法都是抽象的，则可以将这个类定义为接口。接口就是规范，定义一组规范。接口是种特殊的抽象类，它不能包含普通方法，里面的所有方法都是抽象方法，它将抽象进行的更为彻底。在 JDK 8 中，重新对接口定义，接口中除了抽象方法外，还可以有默认方法和静态方法(也叫类方法)。默认方法使用 default 修饰，静态方法使用 static 修饰，这两种方法都允许有方法体。定义接口使用 interface 关键字。

​定义接口时，可以同时继承多个父接口，实现多继承。在接口内部可以定义多个常量和抽象方法，定义常量时必须进行初始化赋值。在接口中定义常量时可以省略 “public static final” 修饰符，在接口中定义抽象方法时可以省略 “public abstract” 修饰符。

​接口中可以包含三类方法：抽象方法，默认方法，静态方法。静态方法可以通过 “接口名.方法名” 调用，而抽象方法和默认方法只能通过接口实现类的实例对象类调用。需要定义一个接口的实现类，该类通过 implements 关键字实现当前接口，并实现当前接口的所有抽象方法，需要注意的是，一个类可以在继承另一个类的同时实现多个接口，并且多个接口之间使用英文逗号分隔。

定义接口的实现类的语法格式：
    修饰符 class 类名 implements 接口名 {
        ...
    }

接口特点的归纳：

• 在 JDK 8之前，接口中的方法必须都是抽象的，不能包含方法体。在调用抽象方法时，必须通过接口的实现类的对象才能调用实现方法。从 JDK 8开始，接口中的方法除了包含抽象方法以外，还包含默认方法和静态方法，都可以有方法体，且静态方法可以就直接通过 “接口名.方法名” 调用。
• 一个类可以通过 implements 关键字同时实现多个接口，被实现的多个接口之间用英文逗号隔开。
• 接口之间可以通过 extends 关键字实现继承，一个接口可以同时继承多个接口
• 一个类在继承一个类的同时还可以实现接口，此时， extends 关键字必须位于 implements 关键字之前。

package com.wang.demo3;

//接口使用 interface 关键字,接口都需要有实现类
public interface UserService {
    //接口中所有的方法都是抽象的，
    //方法修饰符 public abstract 可以省略

    public void add(String name); //增
    public void delete(String name); //删
    public void update(String name); //改
    public void query(String name); //查
}
==================================
package com.wang.demo3;

//定义一个接口实现类 使用关键字 implements
public class UserServiceImpl implements UserService {
    //需要重写接口里面的抽象方法
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}