重庆市建筑工程信息官方网站交换链接适合哪些网站

目录

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 {@Overridevoid 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();}
}

总结

this关键字在Java中是一个非常有用的特性，它提供了对当前对象的引用，有助于解决命名冲突、实现构造方法之间的调用、支持链式方法调用以及在内部类中访问外部类对象。

访问限定符

在Java中，访问限定符（也称为访问修饰符）如public、protected、private以及默认（不写任何关键字，也称为包访问权限）也属于关键字的一部分。

在Java中，访问限定符用于控制类、方法、变量等成员的访问权限。Java提供了四种主要的访问限定符：public、protected、默认（不写任何关键字）和private。

1.public‌

• 可以被任何其他类访问。
• 如果一个类被声明为public，那么它必须被定义在一个文件中，且文件名必须与类名相同（包括大小写）。
• 常用于需要被其他任何类访问的类、方法或变量。

2.protected‌

• 可以被同一个包内的其他类访问。
• 还可以被不同包中的子类访问。
• 常用于需要被同一个包内的其他类访问，同时也希望被其他包中的子类继承并重写的类、方法或变量。

3.默认（无修饰符）‌

• 也称为包访问权限或包私有。
• 只能被同一个包内的其他类访问。
• 如果一个类没有声明为public，那么它就是包私有的，并且不能被其他包中的类访问。
• 常用于只在同一个包内部使用的类、方法或变量。

4.private‌

• 只能被定义它们的类访问。
• 常用于隐藏类的内部实现细节，确保类的封装性。
• 即使子类也无法访问父类的私有成员（除非通过父类提供的公共或受保护的方法）。