this，super，final关键字

最新推荐文章于 2024-01-01 16:16:57 发布

Xc_.xC

最新推荐文章于 2024-01-01 16:16:57 发布

阅读量138

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_52215881/article/details/126873332

版权

this：

1，this是一个关键字，是一个引用，保存内存地址指向本身。

2，this可以使用在实例方法中，也可以使用在构造方法中。

3，this出现在实例方法中其实代表的是当前对象。

4，this不能使用在静态方法中。

5，"this." 大部分情况可以省略，但是用来区分局部变量和实例变量的时候不能省略。

6，this（）这种语法只能出现在构造方法的第一行，表示当前构造方法调用本类其他的构造方法，目的是代码的复用。

格式： this（实际参数列表）;

通过构造方法1去调用构造方法2，两个构造方法得是在一个类中。

this代码示例：

在实例方法中：

public class Student {
    private int id;
    private String name;
    public Student(){

    }
    //有参构造
    public Student(int id, String name) {
       this.id =id;//用来区分实例变量和局部变量
        this.name = name;//用来区分实例变量和局部变量
    }
    //实例方法
    public void setId(int id) {
        this.id = id;//this.id表示当前对象的id。在被调用是赋值
    }
    //实例方法
    public void setName(String name) {
        this.name = name;//this.name表示当前对象的name。在被调用是赋值
    }
}

在构造器中：

this（）在有参构造器中

public class Student {
    private int id;
    private String name;
    public Student(){
        System.out.println("无参构造被执行");
    }
    //有参构造
    public Student(int id, String name) {
        this();
        this.id =id;//用来区分实例变量和局部变量
        this.name = name;//用来区分实例变量和局部变量
        System.out.println("有参构造被执行");
    }
}

public class Student_Test {
    public static void main(String[] args) {
        Student zc = new Student(10, "zc");
    }
}
结果：无参构造被执行
      有参构造被执行

this（）在无参构造器中

public class Student {
    private int id;
    private String name;
    public Student(){
        this(10,"xx");
        System.out.println("无参构造被执行");
    }
    //有参构造
    public Student(int id, String name) {
        this.id =id;//用来区分实例变量和局部变量
        this.name = name;//用来区分实例变量和局部变量
        System.out.println("有参构造被执行");
    }
}

public class Student_Test {
    public static void main(String[] args) {
        Student zc = new Student();
    }
}
结果：有参构造被执行
      无参构造被执行

super：

1，super是一个关键字，不是一个引用，不保存内存地址指向父类。

super只是代表当前对象内部的那一块父类的特征。

2，super可以使用在实例方法中，也可以使用在构造方法中。

3，super出现在实例方法中其实代表的是父类对象。

4，super不能使用在静态方法中。

5，"super." 大部分情况可以省略，但是当父类中有并且子类中也有（同名的属性和方法），如果想在子类中访问“父类的特征”，"super."不能省略。

6，super（）这种语法只能出现在构造方法的第一行，表示当前构造方法调用“父类”中的构造方法，目的是：创建子类对象的时候先初始化父类型特征。

7，super的使用

super.属性名

super.方法名（实参）

super(实参)

重要结论：

1，当一个构造方法第一行：既没有this() 又没有 super()的话，默认会有一个super();

表示通过当前子类的构造方法调用父类的无参构造，所以必须保证父类的无参构造方法是存在的。

2，this()和super()不能共存。（它们都只能出现在构造器中第一行）

3，通过”1“可以了解，只要创建子类对象，父类的构造方法是一定会执行的。（如果你使用了this()调用了2构造器，那么2子类构造器一样会调用父类构造器）

super(实参)的作用：

super 的作用

用于获得被扩展类的属性和方法

扩展类的构造方法

super 并没有在内存中创建被扩展对象, 扩展类其实是被扩展类的升级或者说变异,被扩展类的构造方法会在变异的类中隐式调用,从而包装出新的构造方法

初始化当前对象的父类型特征。并不是创建新的对象，实际上对象值创建了一个。

代码示例：

在构造器中：

子类没有super（）

public class Person {
    String name;
    public Person(){
        System.out.println("父类无参构造");
    }
    public Person(String name){
        System.out.println("父类有参构造");
        this.name=name;
    }
}
//子类
 class Man extends Person{
    public Man(){
        System.out.println("子类无参构造");
    }
 }

public class Test02 {
    public static void main(String[] args) {
        Man man = new Man();
    }
}
结果：父类无参构造
      子类无参构造

子类有super（实参）

//父类
public class Person {
    String name;
    public Person(){
        System.out.println("父类无参构造");
    }
    public Person(String name){
        System.out.println("父类有参构造");
        this.name=name;
    }
}
//子类
 class Man extends Person{
    public Man(){
        super("张三");
        System.out.println("子类无参构造");
    }
 }

public class Test02 {
    public static void main(String[] args) {
        Man man = new Man();
    }
}
结果：父类有参构造
      子类无参构造

在实例方法中：

可以省略super.的情况

//父类
public class Person {
    String name;
}
//子类
 class Man extends Person{
    public void run(){
        System.out.println(super.name);//super.可以省略
        System.out.println(name);
    }
 }

public class Test02 {
    public static void main(String[] args) {
        Man man = new Man();
        man.run();
    }
}
结果：null
     null

不能省略super.的情况

//父类
public class Person {
    String name="小小";
}
//子类
 class Man extends Person{
    String name="小明";
    public void run(){
        System.out.println(super.name);//不可以省略，父类和子类有同名属性
        System.out.println(name);
    }
 }

public class Test02 {
    public static void main(String[] args) {
        Man man = new Man();
        man.run();
    }
}
结果：小小
      小明

this()和super()一起问题

//父类
public class Person {
    String name;
    public Person(){
        System.out.println("父类无参构造");
    }
    public Person(String name){
        System.out.println("父类有参构造");
        this.name=name;
    }
}
//子类
class Man extends Person{
    String name;
    public Man(){
        this("xx");
        System.out.println("子类无参构造");
    }
    public Man(String name){
        System.out.println("子类有参构造");
    }
}

public class Test02 {
    public static void main(String[] args) {
        Man man = new Man();
    }
}
结果：父类无参构造
      子类有参构造
      子类无参构造

final：

1、概念定义：

Java中，final 表示最终，也可以称为完结器，表示对象是最终形态的，不可改变的意思。

用途：final 应用于类、方法和变量时意义是不同的，但本质是一样的，都表示不可改变。

final的用法：

1）final 修饰变量，表示变量的值不可改变，此时该变量可被称为常量。

（只能赋值一次）

2）final 修饰方法，表示方法不能被子类重写；

重写概念：子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写，又称为方法覆盖。

3）final 用在类的前面表示该类不能有子类，即该类不可以被继承。

final的注意事项：