【Java】常见关键字

最新推荐文章于 2025-06-14 10:42:43 发布
最新推荐文章于 2025-06-14 10:42:43 发布
阅读量832 收藏 24
点赞数 10
CC 4.0 BY-SA版权
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79791432/article/details/147871074
1.this关键字的用法

💗在成员方法内部，this表示对“调用方法的那个对象”的引用
💫方法形参或局部变量与成员变量同名时，成员变量被隐藏，通过“this.成员变量名”使用成员变量
💫this可作为返回值，返回对当前对象的引用
💗在构造方法内部，通过this调用当前类的另一个构造方法（见“构造方法重载”）

在这里插入图片描述

在这里插入图片描述
💗在成员方法内部

public class Leaf {
	int i;
	Leaf(int i){
		this.i = i;  //任何一个对象除了基本的成员变量以外，还有一个区域是this,this是个对象，指向自身
	}
	Leaf increment() {//成员方法，返回值为Leaf类型
		i++;
		return this;
	}
	void print() {
		System.out.println("i = "+i);
	}
	public static void main(String[]args) {
		Leaf leaf = new Leaf(100);
		leaf.increment().increment().print();//102
		//为了便于理解，上面这一句等效于下面三句
		Leaf leaf2 = leaf.increment();
		Leaf leaf3 = leaf2.increment();
		leaf3.print();
		}

}

进入leaf(int i){}
在这里插入图片描述
跳出leaf(int i){},结束Leaf leaf = new Leaf(100);局部变量被销毁。
在这里插入图片描述
leaf.increment().increment()；
在这里插入图片描述
💗在构造方法内部

public class Leaf {
	int i;
	Leaf(int i){
		this.i = i; 
	}
	Leaf(){
		this(1);//在构造方法内部，通过this调用当前类的另一个构造方法
		//等价于在main函数中Leaf(1)，但构造方法只能和new一起
	}
	public static void main(String[]args) {
		Leaf leaf = new Leaf();
	}
}
2.super关键字的用法

super和this类似，都是在堆中的对象里占用空间。

💗表示“当前对象的父类对象的引用”，用来引用父类中的成员变量或方法。
💗在子类构造方法中，通过“super([参数列表]);”调用父类的构造方法。该语句必须出现在子类构造方法的第一行。

💗对当前对象的父类对象的引用

public class TestInheritance{
	public static void main(String[] args){
		Rectangle rect=new Rectangle();
		rect.newDraw();
	}
}
class Shape{
	public void draw(){ System.out.println("Draw shape"); }
}
class Rectangle extends Shape{
	public void draw(){ System.out.println("Draw Rectangle"); }
	public void newDraw(){
		draw();
		super.draw();
	}
}

输出结果为：

Draw Rectangle
Draw shape

在这里插入图片描述

package java001;

class FatherClass{
	public int value;
	public void f() {
		value=100;
		System.out.println("FatherClass,value:"+value);
	}
}
class ChildClass extends FatherClass{
	public int value;
	public void f() {
		super.f();
		value = 200;
		System.out.println("ChildClass.value:"+value);
		System.out.println(value);
		System.out.println(super.value);
	}
}
public class TestInherit {
	public static void main(String[]args) {
		ChildClass cc = new ChildClass();
		cc.f();
	}
}

在这里插入图片描述
在这里插入图片描述

💗调用父类的构造方法

package java001;

class SuperClass{
	private int n;
	SuperClass(){
		System.out.println("SuperClass()");
	}
	SuperClass(int n){
		System.out.println("SuperClass("+n+")");
		this.n=n;
	}
	void getSuperN() {
		System.out.println("Super N:"+n);
	}
}
class SubClass extends SuperClass{
	private int n;
	SubClass(int n){
		System.out.println("SubClass("+")");
		this.n=n;
	}
	SubClass(){
	    //super();默认的
		super(300);//调用父类的构造方法，一定要放在子类构造方法的第一行，如果不写这一行代码，电脑会自动默认调用父类的无参数的构造方法。
		System.out.println("SubClass()");
	}
	void getSubN() {
		System.out.println("Sub N:"+n);
	}
}

public class TestSuperSub {
	public static void main(String[]args) {
		SubClass sc = new SubClass();
		//可以这样理解：
		//这句代码把SuperClass中的变量和方法空间创建出来，又创建了SubClass的变量和方法空间，调用SubClass()构造方法（进入SunClass()行数第一步就去调用SuperClass()构造方法）和SuperClass()构造方法。（如果没有super(300);会自动调用super();）
		//父类优先
		sc.getSuperN();
		sc.getSubN();
	}

}

在这里插入图片描述

在这里插入图片描述

💦子类对象的创建与初始化的一般步骤💦SubClass sc = new SubClass();
1.子类构造方法调用父类构造方法:
通过显式的super()方法调用或编译器隐含插入的super()方法调用(子类构造方法的第一句)，这一过程递归地进行（多重继承关系时），直到根类Object的构造方法。在这一过程中，子类对象所需的所有内存空间被分配，所有成员变量均使用默认值初始化。
2.从根类Object的构造方法开始，自顶向下地对每个类依次执行如下两步：
显式初始化。
执行构造方法的主体（不包括使用super调用父类构造方法）。

3.static关键字（可修饰类成员变量和成员方法）
3.1静态变量

静态变量：在类的成员变量声明中带有static关键字的变量。

在这里插入图片描述
静态变量的创建：

  • 静态变量的创建与实例对象无关。
  • 只在系统加载其所在类时分配空间并初始化，且在创建该类的实例对象时不再分配空间。
    在这里插入图片描述
    代码建议仔细阅读，后面有注释，含有变量、构造方法调用的顺序。
package java004;
//在调用构造方法之前，先把对应类中的变量创建出来，若有static变量，按从上往下的顺序创建（调用构造方法），再创建普通变量
//若static变量之前创建过，再次遇到时跳过，而普通变量需要再次被创建、调用构造方法，如main函数中的两个new Cupboard();
class Bowl {
    Bowl(int i) { System.out.println("Bowl(" + i + ")"); }
    void f1(int i) { System.out.println("f1(" + i + ")"); }
}
class Table {
    static Bowl bowl1 = new Bowl(1);
    Table() {
        System.out.println("Table()");
        bowl2.f1(1);
    }
    void f2(int i) { System.out.println("f2(" + i + ")"); }
    static Bowl bowl2 = new Bowl(2);
}
class Cupboard {
    Bowl bowl3 = new Bowl(3);
    static Bowl bowl4 = new Bowl(4);
    Cupboard() {
        System.out.println("Cupboard()");
        bowl4.f1(2);
    }
    void f3(int i) { System.out.println("f3(" + i + ")"); }
    static Bowl bowl5 = new Bowl(5);
}

public class StaticInitialization {//这个类包含Static变量，加载这个类的时候，首先要加载Static变量
    public static void main(String[] args) {
        System.out.println("new Cupboard() in main");
        new Cupboard();//在调用构造方法之前，bowl3会再被创建一次，调用new Bowl(3)，输出Bowl(3)，而静态变量只创建一次，故不再调用
        //调用构造方法，输出Cupboard()、f1(2)
        System.out.println("new Cupboard() in main");
        new Cupboard();//重复上面的new Cupboard();
        table.f2(1);
        cupboard.f3(1);
    }
    static Table table = new Table();//StaticInitialization类包含static变量，第一步，先执行这一句，在数据区创建table变量，接着在调用构造方法之前，先加载Table类的static变量,
    //在数据区创建bowl1变量，Bowl类中无静态变量，调用构造方法，输出Bowl(1)。接着，在数据区创建bowl2变量，Bowl类中无静态变量，调用构造方法，输出Bowl(2)。
    //静态变量加载完后，调用new Table()构造方法，输出Table()、f1(1)；
    static Cupboard cupboard = new Cupboard();//第二步，数据区创建cupboard变量，接着在调用构造方法之前，先加载Table类的static变量,
    //在数据区创建bowl4变量，Bowl类中无静态变量，调用new Bowl(4)构造方法，输出Bowl(4)。接着，在数据区创建bowl5变量，Bowl类中无静态变量，调用构造方法，输出Bowl(5)。
    //在栈中创建变量bowl3，Bowl类中无静态变量，调用new Bowl(3)构造方法，输出Bowl(3)。
    //静态变量加载完后，调用new Cupboard()构造方法，输出Cupboard()、f1(2)
    //进入main函数
}

非private的静态变量，可在类外用类名访问（一下两种均可）

class Employee{
private int id;
public static int serialNum = 1;
Employee(){ id=serialNum ++; }
}
class OtherClass{
public static void main(String[] args){
      System.out.println(Employee.serialNum);
}
}

class Employee{
private int id;
public static int serialNum = 1;
Employee(){ id=serialNum ++; }
}
class OtherClass{
public static void main(String[] args){
      Employee e=new Employee();
      System.out.println(e.serialNum);
}
}
3.2静态方法
  • 静态方法：在类的成员方法声明中带有static关键字的方法。
  • main方法是静态方法、程序入口点，不创建实例对象就可以运行该方法。
  • 静态方法一般通过类名访问，但特殊情况下也可通过实例对象访问。
class GeneralFunction {
	public static int add(int x, int y) {
		return x + y;
	}
}
public class UseGeneral {
	public static void main(String[] args) {
		int c = GeneralFunction.add(9, 10);
		System.out.println("9 + 10 = " + c);
	}
}

静态方法中没有this引用，需要将实例传入参数才可访问。因此，静态方法不能直接调用实例方法，也不能直接访问所属类的实例成员变量，但可以访问静态变量和静态方法。

public class TestStaticMethod{
	public static void main(String[] args){
		StaticMethod obj=new StaticMethod();
		StaticMethod.sPrintXAndY(obj);		}
}
class StaticMethod{
	int x=0;		static int y=1;
	public void iPrintAndIncreaseY(){
		sPrintY(); 
		y++;
	}
	public static void sPrintY(){
		//System.out.println(this.x);	//不能访问实例成员变量
		//iPrintAndIncreaseY();		//不能访问实例方法
		System.out.println(StaticMethod.y);	//可以访问静态变量
	}
	public static void sPrintXAndY(StaticMethod o){
		System.out.println(o.x);	//可以通过o引用访问实例成员变量
		o.iPrintAndIncreaseY();	//可以通过o引用调用实例方法
		sPrintY();		//可以直接调用静态方法
	}

静态方法的重写：
回顾方法重写的规则：
不改变方法的名称、参数列表和返回值，改变方法的内部实现
子类中重写方法的访问权限不能缩小
子类中重写方法不能抛出新的异常
父类中private的成员，在子类中不能被覆盖（重写）
本节加入以下重写规则：
子类不能把父类的静态方法重写为非静态
子类不能把父类的非静态方法重写为静态
子类可以声明与父类静态方法相同的方法
//静态方法的重写不会导致多态性
//构造方法可以看成是static方法，不具有多态性

在这里插入图片描述

4.final关键字

final的使用位置
1.在类声明中使用：表示类不能被继承。
2.在成员方法声明及方法参数中使用：成员方法不能被重写，参数变量值不能更改。
3.在成员变量和局部变量声明中使用：表示变量的值不能更改。

4.1在类声明中使用final关键字

被定义成final的类不能再派生子类
例： final class Employee {…}
class Manager extends Employee { …}

4.2在成员方法声明中使用final关键字

被定义成final的方法不能被重写。
//将方法定义为final可使运行时的效率优化
//对于final方法，编译器直接产生调用方法的代码，而阻止运行时刻对方法调用的动态绑定
private的方法都隐含指定为是final的，对子类不可见就无所谓被重写。

4.3在方法参数中使用final关键字

将方法参数指明为final，则无法在方法中更改参数的值

//Cat类含有name和eyeColor两个成员变量
public void m2(final int j) { // final变量不能改变值，final方法不能被重写
		//j = 10; 报错
	}
	
	public void mCat(final Cat c) {  
		c.eyeColor = "black";//重要！！！！不报错，引用不能改变,但堆里的内容可以改变
		//c = new Cat("name", "color"); 报错，指向新的引用
	}
}
4.4在成员变量中使用final关键字

在这里插入图片描述

class T {
	final int i = 8; //final的变量不能改变值, c++ -> const
	public final void m() { //final方法不能被重写
		//i = 8; 让i=8仍会报错，因为编译器会理解为你在试图改变i的值
	}
}

空白final：若final成员变量声明时未赋初值，则在所属类的每个构造方法中都必须对该变量赋值。

class Poppet {
	private int i;
	Poppet(int ii) { i = ii; }
}
public class BlankFinal {
	private final int i = 0; 	// 被初始化的final
	private final int j; 	// 空白final
	private final Poppet p; 	// 空白final引用
	public BlankFinal() {
		j = 1; 			// 初始化空白final
		p = new Poppet(1); 	// 初始化空白final引用
	}
	public BlankFinal(int x) {
		j = x; 			// 初始化空白final
		p = new Poppet(x); 	// 初始化空白final引用
	}
	public static void main(String[] args) {
		new BlankFinal();
		new BlankFinal(47);
	}
}
4.5在局部变量中使用final关键字

被定义成final的局部变量可以在所属方法的任何位置被赋值，但只能赋一次。

Java volatile关键字最全总结：原理剖析与实例讲解(简单易懂)
夏日清风
06-13 24万+
本文从Java的内存模型和线程的工作原理出发，对volatile关键字进行介绍。帮助读者深入理解volatile的工作机制。同时，还通过简单易懂的示例讲解了如何正确地使用volatile关键字实现线程安全，避免常见的多线程安全问题。
【Java基础知识 14】java final关键字
学Java，找哪吒
11-17 6084
final关键字可以用来修饰引用、方法和类。
Java关键字大全
Yaml4的博客
02-19 1225
顺序结构是指程序按照代码书写的顺序依次执行，没有跳过和重复执行的操作。由于 i 的初始值为 1，满足条件，因此进入循环体。执行完循环体语句后，执行控制条件语句 i++，将 i 的值加 1，此时 i 的值变为 2。循环结构是指根据一定的条件，反复执行相同或类似的代码块。执行控制条件语句 i++，将 i 的值加 1，此时 i 的值变为 3。分支结构是指根据不同的条件，执行不同的代码块。当 i 的值为 6 时，不满足条件 i <= 5，结束循环。再次判断条件，重复上述步骤，直到 i 的值逐渐增加到 6。
【基础篇】Java关键字（超详细）
weixin_43608968的博客
10-25 8872
Java中的关键字，每个关键字的含义，以及Java中的关键字个数
Java中的this关键字
最新发布
weixin_74120671的博客
06-14 709
Java中的this关键字是当前对象的隐式引用，主要有四种核心用法：区分成员变量与局部变量、构造方法中调用其他构造方法、作为参数传递当前对象、返回当前对象实现方法链。从底层看，JVM会将this作为实例方法的第一个隐含参数传递。this在内部类和匿名类中可用于访问外部类成员，与super配合实现继承逻辑。常见错误包括在静态方法使用this和构造器顺序错误。最佳实践包括用this增强可读性、构建流畅API，但需避免滥用。this不会带来性能开销，是Java面向对象编程的重要机制。
java this关键字的使用_Java语言this关键字用法全面总结
weixin_39632982的博客
11-29 933
学习Java编程的时候，无论是谁，当学到面向对象这部分内容时都会遇到一个关键字：this。很多初学者对这个关键字的都会感觉到理解不透，不明白这个神秘的”this”到底表示什么意思。按照官方正规的解释，this关键字的意义被解释为“指向当前对象的引用”。这个解释非常准确并且很精炼，但它太过学术化了，导致很多初学者有点读不懂，更谈不上深入理解它的意义。本文将用大白话的形式帮助初学Java的小伙伴来深入...
猿创征文｜《Java》关键字大全-小结
qq_39395109的博客
09-08 4771
Java关键字大全
【java基础】java关键字总结及详解
qq_43273025的博客
08-11 1万+
Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。 （一）总表：java关键字共53个（其中包含两个保留字const，goto） 另外，Java还有3个保留字:true、false、null。它们不是关键字，而是文字。包含Java定义的值。和关键字一样,它们也不可以作为标识符使用。参考百度百科 （二）大致含义 关键字 含
Java关键字有哪些？
m0_51465608的博客
10-01 5298
48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp
Java常见关键字
程序员世杰
03-11 874
有些关键字在之前的内容已经提到过，这里做一个总结 一、final、static、abstract 1.static 修饰符 被 static 关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。 static 作用于代码块：称作静态代码块 static 方法（类方法）只能访问 static 方法，不能访问非 static 方法 static 方法只能...
java PDF关键字定位
12-14
在Java开发中，处理PDF文档是一项常见的任务，特别是在需要搜索、提取或替换PDF中的特定信息时。本篇文章将深入探讨如何使用iText库在Java中实现PDF关键字定位。iText是一个强大的PDF处理库，它提供了丰富的API来...
java中的常见关键字解析
09-04
Java是一种广泛使用的面向对象的编程语言，其语法中包含了多种关键字，这些关键字有着特定的含义和用途。本篇文章将深入解析Java中四个重要的关键字：final、static、super和this。 首先，我们来看`final`关键字。`...
java关键字及作用
12-02
java常见的关键字及作用，几乎包含所有关键字，比较全面
Java中this的用法
热门推荐
benxiangsj的博客
04-19 5万+
一、this关键字 1.this的类型：哪个对象调用就是哪个对象的引用类型 二、用法总结 1.this.data; //访问属性 2.this.func(); //访问方法 3.this(); //调用本类中其他构造方法 三、解释用法 1.this.data 这种是在成员方法中使用 让我们来看看不加this会出现什么样的状况 class MyDate{ public int year; public int month; public int day;.
Java中“this”关键字梳理详解
cuijiying的博客
04-19 1370
Java中的this区分同名变量：解决实例变量与局部变量或参数的命名冲突。构造器调用：在构造器中调用同一类的其他构造器。传递当前对象：将当前对象作为参数传递给其他方法。方法链调用：通过返回this实现流畅的链式调用。限制：不能在静态方法中使用。通过上述代码示例和场景分析，this的作用和用法应该已经非常清晰。它不仅是Java面向对象编程的核心概念之一，也是编写清晰、可维护代码的重要工具。
46个java关键字介绍和使用大全含示例（值得珍藏）
a342874650的专栏
01-16 2261
Java关键字是Java编程语言的核心组成部分，它们具有特定的语义和用途。这些关键字包括控制流语句的关键字（如if、else、while、for、switch等）、创建对象的关键字（new）、访问控制修饰符关键字（public、private、protected）等。这些关键字为Java程序提供了基本的结构和功能，使程序能够实现各种逻辑和控制流程。
JAVA 关键字 查询表
zigbee_rfmcu的专栏
01-14 5156
JAVA 关键字 查询表 1.abstract - 2 -  [ˈæbˌstrækt]  adj.抽象的，理论上的；难解的；抽象派的；茫然的           2.boolean - 3 -  [ˈbuliən]    adj.布尔数学体系的 3.break - 3 -    [brek]  vt.& vi.打破；折断；弄坏；削弱 4.byte - 4 - 5.case - 4 -
Java常用关键字总结
N_Peng的博客
05-17 739
Java中常用的关键字有以下分类： 访问控制 private protected public 类,方法和变量修饰符 abstract class extends final implements interface native new static strictfp synchronized transient vo...
Java中的50个关键字
专注于此刻
09-14 592
Java中的50个关键字 关键字也称为保留字，是指java语言中规定了特定含义的标示符。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。Java中有50个常用关键字： 与数据类型相关（10） 关键字 类型 占字节数 备注 boolean 布尔数据类型 1 有true和false两个值 int 整型数据类型 4 long ...
java的常见关键字
04-02
Java 的常见关键字是指在 Java 编程语言中具有特殊含义并且保留使用的词汇。以下是几个常见的 Java 关键字及其作用： 1. **class**：用于声明一个新类，这是面向对象编程的基础单元。 - 示例：`public class HelloWorld { }` 2. **static**：用于创建静态方法和变量，它们属于类本身而不是某个实例。 - 示例：`public static void main(String[] args) {}` 3. **void**：表示方法不返回任何值。 - 示例：`public void printMessage() {}` 4. **if、else**：控制程序流程的关键字，允许基于条件执行不同的代码块。 - 示例：```java if (x > 0) { ... } else { ... }``` 5. **for、while**：循环结构的关键字，分别适用于已知次数和未知次数的迭代。 - 示例：```java for(int i = 0; i < n; i++) {...}``` ```java while(x != y){...}``` 6. **new**：用于创建一个新的对象实例。 - 示例：`String str = new String("Hello World!");` 7. **this**：引用当前对象自身。 - 示例：`this.variableName` 8. **extends** 和 **implements**：分别用于单继承以及实现接口。 - 示例：`public class ChildClass extends ParentClass implements SomeInterface {}` 9. **return**：结束方法并选择性地向调用者传递结果。 以上只是一些例子，在实际应用中有更多的关键词服务于各种用途如访问修饰符(private, protected等)，类型转换等等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值