服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|JAVA教程|ASP教程|

服务器之家 - 编程语言 - JAVA教程 - Java中一些关键字的使用技巧总结

Java中一些关键字的使用技巧总结

2020-01-04 17:10leizhimin JAVA教程

这篇文章主要介绍了Java中一些关键字的使用技巧总结,其中重点讲述了this和super两个关键字的用法,需要的朋友可以参考下

final——

final用于类表示该类不能派生子类。

final用于方法表示该方法不能被子类重写。

final用于变量时表示常量,类似于C/C++的const关键字。

final用于成员变量表示该成员变量为常量,不能被修改,必须在变量定义时赋值。

final用于局部变量表示该局部变量为常量,不能被修改,可以在变量定义时赋值,也可以先定义变量后赋值。

static——

static用于成员变量表示该变量只有一份,也就是说静态成员变量属于类而不属于某个具体的类实例对象,所有的类实例对象共享这个静态成员变量,访问静态成员变量时通过对应的类名完成。静态成员变量在定义时可初始化赋值,也可不赋值,不赋值时会被自动初始化,切记局部变量不可以是静态的。

static用于方法,使得不需要实例化类就可以通过类名来调用静态方法,需要注意的是在静态方法内不可以使用this关键字,不可以调用非静态方法,也不可以引用非静态成员变量。

static用于类,这里指的是内部类,那么在别的地方就可以通过外部类名来引用这个静态的内部类。

static还可以用于类的代码块,叫做静态代码块,是在类中独立于类成员的static语句块,可以有多个,位置可以随便放,它不在任何的方法体内,JVM加载类时会执行这些静态的代码块,如果static代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码块只会被执行一次。

类的访问权限(Y/N)

|| 关键字 || 类 || 包 || 子类 || 其它包 ||
| public | Y | Y | Y | Y |
| protected | Y | Y | Y | N |
| default | Y | Y | N | N |
| private | Y | N | N | N |

public、protected和private三个关键字,可以用于类(内部类)、成员变量和成员函数,默认的访问权限是包内有效,当类访问权限与成员变量或成员函数的访问权限不同时,选择最低访问权限。

interface/implements/extends/class——

interface用于声明接口,接口中的方法只有声明,没有实现,访问权限可以是public或者默认权限,还可以指定为abstract。

implements用于实现接口,需要实现接口中的所有方法,可以同时实现多个接口。

extends用于继承父类或父接口,继承父类时只能是单继承,与C++的多继承不同,接口继承支持多继承。

class用于声明类,访问权限可以是public或者默认权限,还可以指定为abstract、final,访问权限对于顶层类和内部类的限制是不同的。


abstract——

abstract用于类表示这个类为抽象类,不能实例化。

abstract用于方法表示这个方法为抽象方法,只需声明,不用实现,由子类实现,抽象方法不能用private和static关键字。

下面来着重讲一下this和super的使用:

this
        Java关键字this只能用于方法方法体内。当一个对象创建后,Java虚拟机(JVM)就会给这个对象分配一个引用自身的指针,这个指针的名字就是this。因此,this只能在类中的非静态方法中使用,静态方法和静态的代码块中绝对不能出现this,这在“Java关键字static、final使用总结”一文中给出了明确解释。并且this只和特定的对象关联,而不和类关联,同一个类的不同对象有不同的this。下面给出一个使用this的综合实例,以便说明问题:
 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package org.leizhimin;
public class Test6 {
 private int number;
 private String username;
 private String password;
 private int x = 100;
 public Test6(int n) {
 number = n; // 这个还可以写为: this.number=n;
 }
 public Test6(int i, String username, String password) {
 // 成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.
 this.username = username;
 this.password = password;
 }
 // 默认不带参数的构造方法
 public Test6() {
 this(0, "未知", "空"); // 通过this调用另一个构造方法
 }
 public Test6(String name) {
 this(1, name, "空"); // 通过this调用另一个构造方法
 }
 public static void main(String args[]) {
 Test6 t1 = new Test6();
 Test6 t2 = new Test6("游客");
 t1.outinfo(t1);
 t2.outinfo(t2);
 }
 private void outinfo(Test6 t) {
 System.out.println("-----------");
 System.out.println(t.number);
 System.out.println(t.username);
 System.out.println(t.password);
 f(); // 这个可以写为: this.f();
 }
 private void f() {
 // 局部变量与成员变量同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.
 int x;
 x = this.x++;
 System.out.println(x);
 System.out.println(this.x);
 }
 
 //返回当前实例的引用
 private Test6 getSelf() {
 return this;
 }
}

 
运行结果如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
-----------
0
未知
100
101
-----------
0
游客
100
101

 
        看着上面的例子,说明在什么情况下需要用到this:
        第一、通过this调用另一个构造方法,用发是this(参数列表),这个仅仅在类的构造方法中,别的地方不能这么用。
        第二、函数参数或者函数中的局部变量和成员变量同名的情况下,成员变量被屏蔽,此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然,在没有同名的情况下,可以直接用成员变量的名字,而不用this,用了也不为错,呵呵。
        第三、在函数中,需要引用该函所属类的当前对象时候,直接用this。
        其实这些用法总结都是从对“this是指向对象本身的一个指针”这句话的更深入的理解而来的,死记不然容易忘记而且容易搞错,要理解!
 
super
 
        super关键和this作用类似,是被屏蔽的成员变量或者成员方法或变为可见,或者说用来引用被屏蔽的成员变量和成员成员方法。
不过super是用在子类中,目的是访问直接父类中被屏蔽的成员,注意是直接父类(就是类之上最近的超类)。下面是一个综合运用super的例子,有两个类:一个Father类,一个Father类的子类Son,通过这两个类完全演示了super的用法,一下是代码:
 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package org.leizhimin;
public class Father {
 public String v="Father";
 public String x="输出了Father类的public成员变量x!!!";
 
 public Father() {
 System.out.println("Father构造方法被调用!");
 }
 
 public Father(String v){
 this.v="Father类的带参数构造方法!运行了.";
 }
 public void outinfo(){
 System.out.println("Father的outinfo方法被调用");
 }
 public static void main(String[] args) {
 // TODO 自动生成方法存根
 }
}
 
package org.leizhimin;
public class Son extends Father{
 public String v="Son";
 
 public Son() {
 super();   //调用超类的构造方法,只能放到第一行.
 System.out.println("Son无参数构造方法被调用!");
 //super();   //错误的,必须放到构造方法体的最前面.
 }
 
 public Son(String str){
 super(str);
 System.out.println("Son带参数构造方法被调用!");
 }
 //覆盖了超类成员方法outinfo()
 public void outinfo(){
 System.out.println("Son的outinfo()方法被调用");
 }
 
 public void test(){
 
 String v="哈哈哈哈!"//局部变量v覆盖了成员变量v和超类变量v
 
 System.out.println("------1-----");
 System.out.println(v);  //输出局部变量v
 System.out.println(this.v); //输出(子类)成员变量v
 System.out.println(super.v); //输出超类成员变量v
 
 System.out.println("------2-----");
 System.out.println(x);  //输出超类成员变量v,子类继承而来
 System.out.println(super.x); //输出超类成员变量v
 
 System.out.println("------3-----");
 outinfo();  //调用子类的outinfo()方法
 this.outinfo(); //调用子类的outinfo()方法
 super.outinfo(); //调用父类的outinfo()方法
 }
 
 public static void main(String[] args) {
 new Son().test();
 
 }
}

 
子类Son运行结果:
 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
Father构造方法被调用!
Son无参数构造方法被调用!
------1-----
哈哈哈哈!
Son
Father
------2-----
输出了Father类的public成员变量x!!!
输出了Father类的public成员变量x!!!
------3-----
Son的outinfo()方法被调用
Son的outinfo()方法被调用
Father的outinfo方法被调用

延伸 · 阅读

精彩推荐