目录
一、this & super
this 和 super 都是 Java 中的关键字,分别表示当前对象和父类对象。它们的作用如下:
1. this
调用当前类的属性和方法:当在类中访问当前类的成员时,可以使用 this 关键字,以便与同名的局部变
量进行区分。
调用本类的构造函数:使用 this() 可以调用本类的其他构造函数。但是,必须将 this() 作为构造函数中
的第一条语句,并且只能在构造函数中使用。
返回当前对象:使用 return this; 可以返回当前对象的引用。
例如下面的代码片段演示了如何使用 this 关键字:
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void sayHello() {
System.out.println("Hello, my name is " + this.name);
}
}
在这个例子中,我们通过 this.name 引用了当前对象的 name 属性,在 sayHello() 方法中输出了该属性
的值。
2. super
调用父类的属性和方法:当想要在子类中访问父类中定义的同名变量或方法时,可以使用 super 关键字
加以区分。
调用父类的构造函数:使用 super() 可以显式调用父类的构造函数。与 this() 相同,super() 必须作为构
造函数中的第一条语句,并且只能在构造函数中使用。
返回父类对象:如果子类想要返回其直接父类的引用,可以使用 super 关键字。
例如下面的代码片段演示了如何使用 super 关键字:
public class Student extends Person {
private int grade;
public Student(String name, int age, int grade) {
super(name, age);
this.grade = grade;
}
public void study() {
System.out.println("I'm studying in grade " + this.grade);
}
}
在这个例子中,我们通过 super(name, age) 调用了父类 Person 的构造函数,并将参数传递给父类的 name 和 age 属性。这样,我
们可以在 Student 类中访问父类 Person 的属性和方法。
3. 总结
总之,this 和 super 都是 Java 中的关键字,分别表示当前对象和父类对象。使用 this 可以调用当前类
的属性和方法、调用本类的构造函数和返回当前对象。使用 super 可以调用父类的属性和方法、调用父
类的构造函数和返回父类对象。
二、static
1. 作用
static 是 Java 中的一个关键字,表示静态的、不可变的。在 Java 中,static 主要有以下几种作用:
- 声明静态方法或属性:使用 static 关键字可以将方法或属性声明为静态的,这意味着它们属于类而不是对象。
- 访问静态方法或属性:由于静态方法和属性属于类而不是对象,因此可以通过类名直接访问它们,而无需先创建对象。
- 静态代码块:可以使用 static 关键字来声明静态代码块,在类加载时执行一次,可以用来进行初始化操作。
- 声明静态内部类:静态内部类属于外部类,但不能访问其它非静态的成员,常用于辅助实现某些功能。
例如下面的代码片段演示了如何使用 static 声明静态方法和属性:
public class MyClass {
private static int x;
public static void setX(int newX) {
x = newX;
}
public static int getX() {
return x;
}
}
在这个例子中,我们使用 static 关键字声明了一个静态属性 x 和两个静态方法 setX 和 getX。
由于 x 属于类而不是对象,因此可以通过 MyClass.setX(10) 来访问该属性,而不需要先创建 MyClass 对象。
总之,static 是 Java 中的一个关键字,表示静态的、不可变的。
在 Java 中,static 主要用于声明静态方法或属性、访问静态方法或属性、定义静态代码块和声明静态内
部类等操作。
2. 访问问题
在 Java 中,使用 static 可以声明静态方法和静态属性,可以通过类名直接访问它们,而不需要先创建对
象。但是,在实际开发中需要注意以下几个问题:
- 静态方法不能访问非静态方法和属性:由于静态方法属于类而不是对象,因此无法访问属于对象的非静态方法和属性。如果需要使用非静态方法和属性,必须先创建对象。
- 静态方法不能重写:static 方法是属于类本身的,不能被子类重写。因此,父类中的 static 方法在子类中也必须是 static 的。
- 静态属性共享性:静态属性属于类,所有对象共享同一个静态属性。因此,对于一个类的静态属性的修改,会影响到所有对象。
- 静态代码块执行时机:静态代码块在类加载时执行一次。如果静态代码块中的逻辑比较复杂或者有耗时操作,可能会造成程序启动缓慢的问题。
下面是一个简单的示例,说明了如何使用 static 访问静态方法和属性:
public class MyClass {
private static int count = 0;
public static void incrementCount() {
count++;
}
public static int getCount() {
return count;
}
}
public class Main {
public static void main(String[] args) {
MyClass.incrementCount();
MyClass.incrementCount();
System.out.println(MyClass.getCount()); // Output: 2
}
}
在这个例子中,我们声明了一个静态属性 count 和两个静态方法 incrementCount 和 getCount,并通
过 MyClass.incrementCount() 调用 incrementCount 方法,将 count 属性加一。最后,我们通过
MyClass.getCount() 访问 count 属性并输出结果。
3. 总结
总之,使用 static 可以方便地访问静态方法和属性,但需要注意静态方法不能访问非静态方法和属性、
不能被重写、共享静态属性等问题。
三、final、finally、finilize
final、finally 和 finalize 是 Java 中的三个关键字,它们分别表示不可变性、异常处理和垃圾回收。
它们的作用如下:
1. final
声明常量:使用 final 关键字可以将变量声明为常量,一旦被赋值就不能再次更改。
防止继承或重写:使用 final 关键字可以防止类被继承、方法被重写和变量被修改。
例如下面是一个简单的示例:
public class MyClass {
public final int MAX_VALUE = 100; // 声明一个不可变的常量
public void printMaxValue() {
System.out.println("MAX_VALUE: " + MAX_VALUE);
}
}
在这个例子中,我们使用 final 关键字将 MAX_VALUE 声明为常量,并在 MyClass 类中声明了一个
printMaxValue() 方法来输出该常量的值。
2. finally
finally 关键字通常与 try-catch 结构一起使用,无论是否出现异常都会执行相关代码。
例如下面是一个简单的示例:
public class FileTest {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("myfile.txt");
int data = fis.read();
while (data != -1) {
System.out.print((char) data);
data = fis.read();
}
} catch (IOException e) {
System.out.println(e.getMessage());
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
System.out.println("finally block");
}
}
}
在这个例子中,我们使用 FileInputStream 读取文件 myfile.txt 中的内容,如果出现异常,则捕获并输
出相关信息。
无论是否出现异常,finally 块中的代码都会被执行。
3. finillize
finalize() 方法是 Object 类中的一个方法,用于垃圾回收。
当对象不再被引用或被 JVM 彻底回收时,finalize() 方法会被调用。
例如下面是一个简单的示例:
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
@Override
protected void finalize() throws Throwable {
// 进行清理操作
}
}
在这个例子中,我们重写了 Object 类中的 finalize() 方法,在该方法中可以进行一些对象释放和资源回收的操作。
4. 总结
总之,final、finally 和 finalize 都是 Java 中的关键字。final 主要用于声明常量和防止继承、重写等操
作;finally 通常与 try-catch 结构一起使用,用于处理一些必须执行的代码块;finalize() 方法用于垃圾
回收,当对象不再被引用或被 JVM 彻底回收时,该方法会被调用。