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

Levana ·

更新时间:2024-11-13

· 734 次阅读

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) {
    }
}

作者：嘻哈骇客

this final 抽象对象面向对象抽象类接口