当前位置：首页 > news >正文

Java中的常用关键字

news 来源：原创 2025/5/15 6:17:01

static关键字

（1）static修饰成员变量

（2）static修饰成员方法

super和this关键字

super关键字

示例1：使用super调用父类的构造器

示例2：使用super访问父类的方法

示例3：使用super访问父类的变量

示例4：super在方法重写中的使用

使用super时的注意事项

父类构造与子类构造的执行顺序

情况一：父类是有参构造时

情况二：父类是显示定义无参构造，或默认无参构造时，子类的构造中第一行会默认有一个super()

this关键字

1. 区分实例变量和局部变量

2. 在构造方法中调用另一个构造方法

3. 返回当前对象的引用

4. 在内部类中引用外部类对象

总结

访问限定符

1.public‌

2.protected‌

3.默认（无修饰符）‌：

4.private‌：

static关键字

（1）static修饰成员变量

static修饰的成员变量，赋值一次，以后这个类实例化出的其它对象初始都是这个值

访问形式：

1.类名.成员变量

2.对象引用.成员变量

但是通过类名去访问成员变量更好，因为这个成员变量属于类。

静态的成员不依赖对象，意味着不需要对象的引用来调用。

静态成员变量的特性：

1.不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2.既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3.类变量存储在方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

而静态的变量属于类变量，随着类的加载而被创建，而局部变量是调用该方法的时候，才创建的。

所以，此时两种变量的性质是冲突的。Java当中不允许定义局部的静态变量。

（2）static修饰成员方法

static修饰的方法为静态方法

在静态方法中不能够直接调用非静态方法，因为静态方法不依赖于对象，可以直接通过类名进行访问，而非静态方法依赖对象，需要通过对象的引用访问。

但是在静态方法中可以通过对象的引用调用非静态方法

在staic方法当中不能使用this关键字，因为static不依赖对象

super和this关键字

super关键字

在Java中，super关键字用于访问父类（超类）的成员变量、方法和构造器

示例1：使用`super`调用父类的构造器

class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
        System.out.println("Animal constructor called. Name: " + name);
    }
}

class Dog extends Animal {
    String breed;

    public Dog(String name, String breed) {
        super(name); // 调用父类的构造器
        this.breed = breed;
        System.out.println("Dog constructor called. Breed: " + breed);
    }
}

public class SuperExample {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy", "Labrador");
    }
}

输出：

Animal constructor called. Name: Buddy
Dog constructor called. Breed: Labrador

示例2：使用`super`访问父类的方法

class Vehicle {
    void start() {
        System.out.println("Vehicle started");
    }
}

class Car extends Vehicle {
    void start() {
        super.start(); // 调用父类的方法
        System.out.println("Car started");
    }
}

public class SuperExample2 {
    public static void main(String[] args) {
        Car car = new Car();
        car.start();
    }
}

输出：

Vehicle started
Car started

示例3：使用`super`访问父类的变量

class Parent {
    int value = 10;
}

class Child extends Parent {
    int value = 20;

    void display() {
        System.out.println("Child value: " + value); // 访问子类的变量
        System.out.println("Parent value: " + super.value); // 使用super访问父类的变量
    }
}

public class SuperExample3 {
    public static void main(String[] args) {
        Child child = new Child();
        child.display();
    }
}

输出：

Child value: 20
Parent value: 10

示例4：`super`在方法重写中的使用

class Parent {
    void display() {
        System.out.println("Parent display method");
    }
}

class Child extends Parent {
    @Override
    void display() {
        super.display(); // 调用父类的被重写方法
        System.out.println("Child display method");
    }
}

public class SuperExample4 {
    public static void main(String[] args) {
        Child child = new Child();
        child.display();
    }
}

输出：

Parent display method
Child display method

使用super时的注意事项

（1）super只能访问当前类的父类，不能访问父类的父类

（2）父类有构造方法的时候，子类也必须创建构造方法

当父类有构造方法的时候，子类也必须创建构造方法，并且用super调用父类构造方法，为父类的构造方法进行初始化。

一、父类有有参构造方法：

如果父类构造方法是一个有参的构造：

那么子类也必须创建构造方法为父类的构造方法进行初始化：

两种方式对父类进行初始化

二、父类是默认的无参构造时：

如果没有自己手动写构造方法时，java中会提供空的构造方法

此时子类会默认也有一个空的构造并且子类的构造第一行使用super调用父类的构造

三、父类是显示定义的无参构造：

比如下面的这种情况：

子类可以不写构造方法，java会提供空的构造方法

此时的输出结果为：

BaseBase

父类构造与子类构造的执行顺序

父子父子，先有父再有子。

即子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法

因为super（）必须在子类构造方法的第一行

情况一：父类是有参构造时

执行结果：

情况二：父类是显示定义无参构造，或默认无参构造时，子类的构造中第一行会默认有一个super()

执行结果：

父类无参构造
子类的无参构造

this关键字

在Java中，this关键字是一个非常重要的引用变量，它指代当前对象。

下面讲一讲它的主要用途：

1. 区分实例变量和局部变量

当方法的参数名称与类的成员变量名称相同时，可以使用this关键字来区分成员变量和局部变量。

public class Person {
    private String name;

    public Person(String name) {
        this.name = name; // this.name指的是类的成员变量name，而右侧的name是构造方法的参数
    }

    public void setName(String name) {
        this.name = name; // 同样，这里使用this来区分成员变量name和参数name
    }

    public String getName() {
        return name;
    }
}

2. 在构造方法中调用另一个构造方法

一个类的构造方法可以通过this()调用同一个类的另一个构造方法。注意，这样的调用必须是构造方法中的第一条语句。

public class Rectangle {
    private int width;
    private int height;

    // 参数化构造方法
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    // 使用this调用另一个构造方法
    public Rectangle(int size) {
        this(size, size); // 调用有两个参数的构造方法
    }
}

3. 返回当前对象的引用

在链式调用中，this可以用来返回当前对象的引用。

public class StringBuilderExample {
    private String text = "";

    public StringBuilderExample append(String str) {
        this.text += str;
        return this; // 返回当前对象的引用，允许链式调用
    }

    public String toString() {
        return this.text;
    }

    public static void main(String[] args) {
        StringBuilderExample example = new StringBuilderExample();
        System.out.println(example.append("Hello").append(", ").append("World!"));
    }
}

4. 在内部类中引用外部类对象

在内部类（如匿名内部类或非静态内部类）中，this通常指向内部类对象本身。如果要从内部类访问外部类对象，可以使用外部类名.this。

public class OuterClass {
    private String message = "Hello from OuterClass!";

    class InnerClass {
        void display() {
            System.out.println(OuterClass.this.message); // 使用OuterClass.this访问外部类的成员变量
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display();
    }
}