Java 快速入门 知识精简(2)基础知识-关键字

关键字

定义:被Java语言赋予了特殊含义,用做专门用途的字符串(单词)。

特点:关键字中所有字母都为小写。

用于定义数据类型的关键字:

类的类型定义 class  interface  enum

方法返回值的类型定义 void 

数据类型定义 byte  short  int  long  float  double  char  boolean

public class MyClass {
    // 类    类名: MyClass 
}

public interface MyInterface {
    // 接口  接口名: MyInterface 
}

public enum Day {
    // 枚举  枚举名: Day
    MONDAY, TUESDAY, WEDNESDAY;
}

public class TestClass{

    public void doSomething() {    // 方法  方法名: doSomething
        // void: 不返回任何值
    }
    // byte:8位有符号整数
    byte b = 100;

    // short:16位有符号整数。
    short s = 10000;

    // int:32位有符号整数。
    int i = 1000000;

    // long:64位有符号整数。
    long l = 100000000000L;

    // float:单精度浮点数。
    float f = 1.23F;

    // double:双精度浮点数。
    double d = 1.23;

    // char:单字符。
    char ch = 'A';

    // boolean:布尔值。
    boolean flag = true;
        
    }
}

用于定义流程控制的关键字:

if else switch case default do while for

break continue return

public class testClass{  // 类 testClass

    public String test(){  // 方法 test 定义了String字符串类型的返回值

        // if-else:条件控制
        if (condition) {
            // 条件为真时执行
        } else {
            // 条件为假时执行
        }
        

        // switch-case-default:多条件选择
        switch (day) {
            case MONDAY:
                // day = MONDAY时, 执行代码
                break;
            default:
                // 默认执行的代码
                break;


        // do-while:循环控制
        do {
            a += 1;     // a = a + 1
        } while (a < 10); // 先执行一次do{}中的代码 , 再判断while()

        // while:循环控制
        while (a < 10) {  // 当 a < 10 执行while(){}
            System.out.println("a小于10");
        }

        // for:循环控制
        for (int i = 0; i < 10; i++) {
            // 循环体
        }

        // break:跳出循环
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break; // 跳出循环
            }
        }

        // continue:跳过当前循环
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                continue; // 跳过偶数
            }
            // 执行奇数的代码
        }

        // return:结束方法
   
        return "返回值"; // 返回字符串
    }
}

用于定义访问权限修饰符的关键字:

public protected private 默认无修饰符 default

// public:公共访问权限。
public class PublicClass {
    // 类体
}

// protected:受保护的访问权限。
protected int protectedVar;

// private:私有访问权限。
private void privateMethod() {
    // 方法体
}

// default(无修饰符):包访问权限。
class DefaultAccessClass {
    // 默认包访问权限的成员
}

用于定义类、函数、变量修饰符的关键字:

abstract final static synchronized

// abstract:抽象的
public abstract class AbstractClass {
    // 抽象类不能被实例化
}


// final:最终的,不可改变的
final int CONSTANT = 100;



public class MyClass {
    // static:静态的
    public static void staticMethod() {
        // 静态方法
    }

    // synchronized:同步的
    public synchronized void synchronizedMethod() {
        // 同步方法
    }
}

用于定义类与类之间关系的关键字:

extends implements

// extends:继承
public class SubClass extends SuperClass {
    // 子类 继承 父类
}


// implements:实现
public class MyClass implements MyInterface {
    // 类 实现 接口
}

用于定义建立实例与引用实例,判断实例的关键字:

new this super instanceof

// new:创建新实例
MyClass obj = new MyClass();


// this:指向当前对象的引用
public class MyClass {
    public void print() {
        System.out.println(this);
    }
}

// super:指向父类的引用
public class SubClass extends SuperClass {
    public void method() {
        super.someMethod(); // 调用父类的方法
    }
}

// instanceof:判断实例类型
if (obj instanceof MyClass) {
    // obj是MyClass类型或其子类的实例
    boolean isMyClass = true
}

用于异常处理的关键字:

try catch finally throw throws

public void method() throws Exception {

    try-catch-finally:异常处理。
    try {
        // 尝试执行的代码
    } catch (Exception e) {
        // 异常发生时执行的代码
        throw new Exception("Error occurred");    // throw:抛出异常。
    } finally {
        // 无论是否发生异常都会执行的代码
    }
}


// throws:方法可能抛出的异常。
public void method() throws IOException {
    // 可能会抛出IOException的方法体
}

用于包的关键字:

package import

package com.example;    // package:定义包

// import:导入类或包
import com.example.MyClass;
import java.util.*;

其他修饰符关键字:

native  strictfp transient volatile

public class TestClass {

    // native:方法用其他语言实现
    public native void nativeMethod();


    // strictfp:严格模式浮点数计算
    public strictfp double strictfpMethod(double a, double b) {
        return a + b;
    }


    // transient:对象序列化时忽略该变量
    public transient int transientVar;


    // volatile:确保变量的读写操作的原子性,保证内存可见性
    private volatile int counter;

}

用于定义数据类型值的字面值

true false null

public class TestClass {

    // true 和 false:布尔值。
    boolean isTrue = true;
        
    boolean isFalse = false;


    // null:空引用。
    String str = null;

}

保留字(reserved word):

goto const

你可能感兴趣的:(Java,java)