Quels sont les mots-clés importants en Java

1.extends

• est utilisé pour les classes d'héritage de classe, utilisation : class+nom de sous-classe+extends+nom de classe parent+{}class+子类名+extends+父类名+{}

class Animal{}//父类
class cat extends Animal{}//子类用extends实现继承

注意：一个类只能用extends关键字声明继承一个父类

• 用于接口继承接口，用法：interface+接口名+extends+接口名+{}

interface Clippers {}
interface Warriors {}
interface Lakers extends Clippers,Warriors {}//接口类用extends关键字继承其他接口（可多个）

注意：

• 接口不能用extends声明继承别的类

• 接口只能用extends声明继承别的接口，且可以继承多个接口

• 当一个类用implements实现了一个接口时，不仅要实现该接口的方法，也要实现该接口继承的接口的方法

2.implements

• 用于声明一个类实现了一个接口类，用法：class+类名+implements+接口名+{}

class Nets implements Clippers,Warriors{}//用implements关键字声明实现了两个接口类

注意：

• 一个普通类可以implements关键字声明实现多个接口，但必须实现所有接口中的所有方法

• 抽象类实现接口，可以不用实现接口的方法（因为抽象类中可以有抽象方法）

• 意义：可以用implements关键字声明实现多个接口来实现类似多继承

3.final

使用方法：

• 修饰类，使该类不能被继承

• 修饰方法，使该方法不能被子类重写 （仍可以被继承和调用）

• 修饰属性，使该属性的值不能被修改（使为常量）

• 修饰局部变量，使该变量不能被修改（局部常量）

使用细节：

final修饰的属性在定义时必须赋初值，且不能修改，可以在以下位置赋初值

• 定义时（显示初始化）

• 在构造器中

• 在代码块中

static final：全局常量

• 如果final修饰的属性是静态（static）的，则不能在构造器中赋初值，原因：静态属性要求在类加载时就有初值，而构造器在创建对象时才被调用，所以可能导致调用静态属性时没有创建对象而没有给静态属性赋值

• final不能修饰构造方法，没有意义

• 被final和static同时修饰的属性在调用时不会导致类的加载，效率更高

4.native

基本介绍：

native用来修饰方法，被修饰的方法即成为了一个Java调用但非Java代码实现的接口（本地方法） ，该方法在外部可以用任何语言去实现

"A native method is a java method whose implementation is provided by non-java code."

使用方法：

native修饰方法的位置必须在方法返回类型之前，和方法访问修饰符位置没有要求，如：public native int hashCode();

native细节：

• native方法没有方法体，也没有{}

• 用native修饰后的方法不能用abstract修饰，因为abstract指明该方法无实现体，而native方法是有实现体的，只是用非Java代码实现的

• native方法的返回类型可以是任意类型

• 如果一个有native方法的类被继承，子类会继承这个native方法，并且可以用java语言重写

使用JNI(Java Native Interface) 

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectOutputStream;
import java.io.Serializable;
public class outStream {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\Cat.txt";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        oos.writeObject(new Cat("小花猫", 3));
        oos.close();
    }
}
class Cat implements Serializable {
    private String name;
    private int age; //没有用transient修饰
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Car{" +

                "name='" + name + ''' +

                ", age=" + age +

                '}';
    }
}
public class inStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String filePath = "d:\Cat.txt";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        System.out.println(ois.readObject());
        ois.close();
    }
}

🎜Remarque : Une classe ne peut utiliser que le mot-cléextendspour déclarer qu'elle hérite d'une classe parent🎜🎜🎜🎜pour l'héritage d'interface Interface, utilisation : interface+nom de l'interface+étend+nom de l'interface+{}🎜🎜

......
private String name;
private transient int age; //使用transient修饰
......

🎜Remarque : 🎜🎜🎜 🎜Interfaces ne peut pas utiliser l'instruction extends pour hériter d'autres classes🎜🎜🎜Les interfaces ne peuvent utiliser que l'instruction extends pour hériter d'autres Interface, et peut hériter de plusieurs interfaces🎜🎜🎜Lorsqu'une classe implémente une interface à l'aide de implements, elle ne doit pas seulement implémenter Les méthodes de l'interface doivent également être implémentéesLes méthodes de l'interface héritées par l'interface🎜🎜🎜2.implements🎜🎜🎜🎜 permet de déclarer qu'un la classe implémente uneClasse d'interface, utilisation : class+nom de la classe+impléments+nom de l'interface+{}🎜🎜

public class syn implements Runnable {
    static int i = 0;
    public static void main(String[] args) throws InterruptedException {
        syn test = new syn();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.start();
        t2.start();
    }
    public synchronized void increase() {//被synchronized修饰的同步方法
        System.out.println(Thread.currentThread().getName() + "调用：" + i++);

    }
    @Override
    public void run() {
        for (int j = 0; j < 100; j++) {
            increase();
        }
    }
}

🎜 Remarque : 🎜🎜🎜🎜Une classe ordinaire peut être déclarée avec le mot-clé implements pour implémenter plusieurs interfaces, mais doit implémenter toutes les interfaces Toutes les méthodes🎜🎜🎜Classe abstraiteimplémentent l'interface, vous n'avez pas besoin d'implémenter les méthodes de l'interface (car il peut y avoir des méthodes abstraites dans classes abstraites)🎜🎜🎜🎜 🎜Signification : Vous pouvez utiliser le mot-clé implements pour déclarer plusieurs interfaces afin d'obtenir quelque chose comme un héritage multiple🎜🎜🎜3.final🎜 🎜Utilisation :🎜🎜🎜🎜Modifier la Classe afin que la classe ne puisse pas être héritée 🎜🎜🎜Modifier Méthode afin que les méthodes ne puissent pas être remplacées par des sous-classes (elles peuvent toujours être héritées et appelées) 🎜🎜🎜modifier la propriété pour que la valeur de la propriété ne puisse pas être modifiée (rendre constante) 🎜🎜🎜Modifier la variable locale pour que la variable ne puisse pas être modifiée ( constante locale) 🎜🎜🎜Détails d'utilisation : 🎜🎜finalLes propriétés modifiées doivent se voir attribuer une valeur initiale lorsqu'il est défini, et ne peut pas être modifié. Vous pouvez attribuer la valeur initiale 🎜🎜🎜🎜Lorsque défini (initialisation explicite) 🎜🎜🎜Dans le constructeur 🎜🎜🎜Dans bloc de code🎜🎜🎜static final : constante globale 🎜🎜🎜🎜Si la propriété est modifiée par final est statique ( static), alors ne peut pas attribuer de valeur initiale dans le constructeur. La raison : les attributs statiques nécessitent une valeur initiale lorsque la classe est chargée. , et le constructeur est Il est appelé uniquement lors de la création de l'objet, cela peut donc entraîner que l'objet ne soit pas créé et que la propriété statique ne soit pas attribuée lors de l'appel de la propriété statique🎜 li>🎜🎜final ne peut pas être modifiéMéthode du constructeur, cela n'a aucun sens🎜🎜🎜Attributs modifiés par final et static<strong> en même temps</strong> lorsqu'il est appelé<strong> >Ne provoque pas de chargement de classe</strong>, plus efficace🎜🎜🎜4.native🎜🎜<strong>Introduction de base : </strong>🎜🎜<code>natif est utilisé pour la Méthode de modification, la méthode modifiée devient une interface (méthode locale) appelée par Java mais implémentée par du code non Java . Cette méthode peut être utilisée en externe dans n'importe quel langage d'implémentation🎜

🎜"Une méthode native est une méthode Java dont l'implémentation est fournie par du code non-java."🎜🎜Utilisation :🎜🎜 La position de la méthode native modifiée doit être avant le type de retour de la méthode, et il n'y a aucune exigence pour la position du modificateur d'accès à la méthode, tel que : public native int hashCode();🎜🎜 nativeDétails : 🎜🎜🎜🎜native méthode n'a pas de corps de méthode, ni {}🎜 🎜🎜Les méthodes modifiées avec native ne peuvent pas être modifiées with abstractcar abstract Indique que la méthode n'a pas de corps d'implémentation, tandis que la méthode native a un corps d'implémentation, mais elle est implémentée en code non Java🎜🎜🎜natif Le type de retour de la méthode code> peut être <strong>n'importe quel type</strong>🎜🎜 🎜Si une classe avec une méthode <code>native est héritée, les sous-classes hériteront de cette méthodenativeet pourront être remplacé enjavalangage🎜🎜🎜Utilisez JNI (Java Native Interface) pour interagir avec d'autres langages ​​🎜

JNI是Java平台的一部分，它允许Java代码和其他语言写的代码进行交互。

使用步骤：

• 编写带有native方法的java类，生成.java文件

• 使用javac命令编译生成.class文件

• 使用javah -jni 类名 生成.h文件

• 使用C/C++（或者其他编程语言）实现native方法，创建.cpp（或其他）文件

• 将C/C++编写的文件创建动态链接库（生成DLL文件）

• native方法中使用System.loadLibrary()方法加载动态库，将DLL文件名作为参数传入，这时候再运行.java程序即可实现对本地方法的调用

详细步骤参考

native意义：

Java无法直接访问到操作系统底层（如系统硬件），但通过使用native关键字修饰方法可以借用其他的语言来扩展Java程序的功能，提高程序的效率

5.static

修饰变量，成为静态变量或者类变量

• 使用方法：访问修饰符+``static``+数据类型+变量名

注意事项：

• 静态变量会被类的所有对象实例所共享，并且在类加载的时候就会初始化。

• 静态变量的访问方法（遵守相关访问权限）：类名.静态变量名 或者 对象名.静态变量名

修饰方法，成为静态方法或者类方法

• 使用方法：访问修饰符+``static``+返回数据类型+方法名+{}

注意事项：

• 调用方法（遵守相关访问权限）：类名.静态方法名 或者 对象名.静态方法名

• 静态方法和普通方法都是随着类加载而加载，将结构信息存储在方法区

• 静态方法中不允许使用this和super关键字

• 静态方法中只能访问静态变量和静态方法

• 普通方法可以访问静态成员和普通成员

• 修饰代码块，成为静态代码块：

静态代码块会在类加载时被加载，优先级和静态属性一样，有多个静态代码块和静态属性时，初始化顺序按定义顺序执行

好处：static关键字的使用，将类中的一些成员修饰成静态的，这样我们不需要创建该类的对象就可以调用该成员，大大提高了编程效率

6.transient

基本介绍：

transient用于修饰实现了Serilizable接口的类中的成员变量，在该类的实例对象进行序列化处理时，被transient修饰的成员变量不会进行序列化。

使用例子：

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectOutputStream;
import java.io.Serializable;
public class outStream {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\Cat.txt";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        oos.writeObject(new Cat("小花猫", 3));
        oos.close();
    }
}
class Cat implements Serializable {
    private String name;
    private int age; //没有用transient修饰
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Car{" +

                "name='" + name + ''' +

                ", age=" + age +

                '}';
    }
}
public class inStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String filePath = "d:\Cat.txt";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        System.out.println(ois.readObject());
        ois.close();
    }
}

可以在Cat.txt文件内看到两个成员变量都能被序列化，并且能被反序列化读出信息。

当小花猫觉得自己的年龄是隐私不想被读出时，用transient修饰成员变量age:

......
private String name;
private transient int age; //使用transient修饰
......

这时在Cat.txt文件中可以看到只有name一个成员变量被序列化，反序列化后的成员变量age读出的是int类型的默认值，说明对于transient修饰的成员变量，在类的实例对象序列化的过程中会被忽略

transient细节

• 对transient修饰的成员变量可以理解为：不会参与进行对象的序列化和反序列化过程，生存周期仅存于调用者的内存而不会写进磁盘里进行持久化

• static修饰的成员变量（静态变量）也是不可序列化的，不论被transient修饰与否

因为序列化是保存的实例对象的状态，而静态变量保存的是类的状态

• transient关键字只能修饰变量，不能修饰方法和类

• transient关键字不能修饰局部变量

• 如transient关键字修饰的是自定义类的变量，则该类需要实现Serilizable接口

注意：

实现Serilizable接口的类的实例对象是自动进行序列化的，如果序列化对象的类实现的是Externalizable接口，则序列化不会自动进行，需要实现接口内的方法指定要序列化的变量，这时与有无Transient修饰无关

7.synchronized

基本介绍：

关键字synchronized可以保证在同一时刻，只有一个线程可以执行被synchronized修饰的方法或代码块

线程同步：

程序中多个线程都要使用同一个方法，而这个方法用synchronized进行了修饰，在多个线程调用这个方法时必须遵循同步机制

线程同步机制：

当一个线程使用synchronized修饰的方法时，其他线程想使用这个方法时就必须等待，直到这个线程使用完synchronized方法

synchronized使用方法：

• 普通同步方法：public synchronized void m () {}

public class syn implements Runnable {
    static int i = 0;
    public static void main(String[] args) throws InterruptedException {
        syn test = new syn();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.start();
        t2.start();
    }
    public synchronized void increase() {//被synchronized修饰的同步方法
        System.out.println(Thread.currentThread().getName() + "调用：" + i++);

    }
    @Override
    public void run() {
        for (int j = 0; j < 100; j++) {
            increase();
        }
    }
}

两个线程同时调用一个对象的一个同步方法，由于一个对象只有一把锁，所以只有一个线程能够获得该对象的锁，另一个线程无法获得，就不能调用该对象的synchronized方法，需要等对象被释放后才能调用。

从运行结果中可以证明线程1抢到了锁，线程0必须等待线程1执行完毕，否则不能访问该同步方法。

• 静态同步方法：public static synchronized void m () {}

public class syn implements Runnable {
    static int i = 0;
    public static void main(String[] args) throws InterruptedException {
        syn test = new syn();
        syn test1 = new syn();
        Thread t1 = new Thread(test);//传入实例对象test
        Thread t2 = new Thread(test1);//传入实例对象test1
        t1.start();
        t2.start();
    }
    public static synchronized void increase() {//同步静态方法
        System.out.println(Thread.currentThread().getName() + "调用：" + i++);
    }
    @Override
    public void run() {
        for (int j = 0; j < 100; j++) {
            increase();
        }
    }
}

虽然两个线程实例化了两个不同的对象，但是synchronized修饰的是静态方法，两个线程仍然发生了互斥，因为静态方法是依附与类的而不是对象，线程1先抢到了类的锁，而线程0必须等待线程1执行完毕释放才能调用同步方法

• 同步代码块：synchronized(object) {}

public class syn implements Runnable {
    static Object object = new Object();//共享对象
    public static void main(String[] args) throws InterruptedException {
        syn test = new syn();
        syn test1 = new syn();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test1);
        t1.start();
        t2.start();

    }
    @Override
    public void run() {
        synchronized (object) {//代码块用静态成员变量上锁
            for (int j = 0; j < 100; j++) {
                System.out.println(Thread.currentThread().getName() + "调用第" + j + "次");
            }
        }
    }
}

同步代码块用两个实例变量共享的静态成员object对象来上锁，虽然是两个线程实例化两个不同的对象，但是对整个syn类来说只有一个共享的object对象，所以只有一把锁，每当有线程来访问代码块时需持有锁，对象锁被其他线程持有时需等待。线程1需要等线程0执行完毕才能访问同步代码块

同步的局限性：

由于同步的方法或代码块只能同一时间让一个线程访问，所以会导致程序的执行效率降低

尽可能让synchronized修饰的范围最小化，来减少互斥对程序执行带来的影响

8.volatile

基本介绍：

volatile用于修饰变量，用volatile修饰的变量的值被某个线程修改时，会强制将修改的值立即写入主存中，主存中的值更新会使得缓存中的该变量的值失效，对比与非volatile变量，可能会被其他线程读取到更新前的值。

使用方法：

//现在有线程1和线程2同时执行下列代码
int i = 0;
i = i + 1;

执行完毕后预想的结果是 i = 2;但是可能存在这样一种情况：两个线程先同时把i的值读取到自己的工作内存中，然后再分别执行 i = i + 1 的操作，再将结果写入主存，这样两个线程写入的都是 i = 1，最终 i 的结果是 1 ，而不是 2

但如果 i 是 volatile 修饰的变量就会不一样了，在一个线程修改 i的值后，会立即强制在主存中更新 i 的值，这样会导致另一个线程的工作内存中 i 的缓存值无效，所以另一个线程再次从主存中读取新的 i 的值，这样保证了i的值是最新并正确的

并发编程的三大概念：

• 原子性：执行一个操作时，要么全部步骤执行完毕且不被中断，要么就不执行

x = 100;//是原子性操作
y = x;//不是原子性操作，可分解为：1.先读取x的值    2.将x的值写入主存
x ++;//不是原子性操作，可分解为：1.读取x的值    2.进行加一操作    3.写入主存

• 可见性：多个线程对同一个变量进行操作时，一个线程修改了变量的值，其他线程能立即看到修改的值

• 有序性：程序执行的顺序按照代码的先后顺序执行

volatile的意义

• 保证了不同线程对变量进行修改时的可见性：因为对于volatile变量来说，被修改后新值对其他线程来说是立即可见的

• 保证了有序性：volatile禁止了指令重排，它能保证在对volatile修饰的变量进行操作时，之前的代码语句已经全部被执行，并且后面的语句都未执行，但是对其他语句的顺序是不做保证的

注意： volatile不能保证原子性,因为不能保证对变量的操作是原子性操作

9.this

• 在方法中修饰属性，this理解为当前对象，用来区别成员方法和形参，通常省略

• 修饰方法，this理解为当前对象，通常省略；不能在静态方法中使用

• 调用构造器，在构造器中使用this(形参列表)显式调用指定的其他构造器

• 必须在首行调用其他构造器

• 一个构造器中不能调用多个其他构造器

• 不能在构造器中调用递归调用，不能成环调用

10.super

super可以理解为：父类的

• 修饰属性：去父类中找对应属性，用来区分子父类重名的属性

• 修饰方法：调用重写之前的方法

• 调用构造器：使用super(形参列表)指定调用父类构造器

• super(形参列表)必须放在构造器的首行

• super(形参列表)和this(形参列表)只能二选一

• 在构造器首行如果没有显式声明super(形参列表)或this(形参列表)则默认调用父类的空参构造器super()（如果此时父类中没有空参构造器就会报错）

• 不能在静态方法中使用

当一个方法和属性被static属性修饰时，这些方法和属性是优先于对象加载进入内存的，是随着类的加载而加载的；this是当前对象的引用，super是指父类的引用，当静态方法加载进内存进栈时，如果在静态方法中有this和super关键字时,this和super也被加载到了内存，但是这个时候并没有对象的引用，this和super没有初始化，所有编译会报错。

10.1.子类对象实例化的过程

11. Modificateur d'accès

Classe publique modifiée :

• Il peut y avoir au plus une classe publique dans une classe, et le nom du fichier doit être cohérent avec la classe publique

• S'il y en a. pas de classe publique, le fichier Vous pouvez avoir n'importe quel nom

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!