Détails du résumé des connaissances Java (image)

Je travaille actuellement sur Node.js J'ai oublié une grande partie de mes connaissances JAVA antérieures, j'ai donc fait le tri et j'ai déploré que les langages industriels aient encore des avantages considérables.

Répertoire

• Flux

• Exception

• Notes

• Sécurité

• Chargement des classes

• Mots clés

• Initialisation

• Multi-threading

• Pool de threads

• Modèle de mémoire

Stream

Toutes les classes de flux en Java se trouvent dans le package java.io et toutes héritent respectivement des quatre types de flux abstraits suivants.

继承自InputStream/OutputStream的流都是用于向程序中输入/输出数据，且数据的单位都是字节(byte=8bit)。

继承自Reader/Writer的流都是用于向程序中输入/输出数据，且数据的单位都是字符(2byte=16bit)。

异常

Java的异常(包括Exception和Error)分为：

可查的异常（checked exceptions）

除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

不可查的异常（unchecked exceptions）

包括运行时异常（RuntimeException与其子类）和错误（Error）。

运行时异常和非运行时异常：

RuntimeException

NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

RuntimeException以外的Exception

从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

注解

Java SE5内置了三种标准注解：

 @Override，表示当前的方法定义将覆盖超类中的方法。

 @Deprecated，使用了注解为它的元素编译器将发出警告，因为注解@Deprecated是不赞成使用的代码，被弃用的代码。

 @SuppressWarnings，关闭不当编译器警告信息。

Java还提供了4中注解，专门负责新注解的创建:

@Target：

表示该注解可以用于什么地方，可能的ElementType参数有：
CONSTRUCTOR：构造器的声明
FIELD：域声明（包括enum实例）
LOCAL_VARIABLE：局部变量声明
METHOD：方法声明
PACKAGE：包声明
PARAMETER：参数声明
TYPE：类、接口（包括注解类型）或enum声明

@Retention

表示需要在什么级别保存该注解信息。可选的RetentionPolicy参数包括：
SOURCE：注解将被编译器丢弃
CLASS：注解在class文件中可用，但会被VM丢弃
RUNTIME：VM将在运行期间保留注解，因此可以通过反射机制读取注解的信息

@Document

将注解包含在Javadoc中

@Inherited

允许子类继承父类中的注解

Example

定义注解：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface UseCase {
    public String id();
    public String description() default "no description";
}

使用注解：

public class PasswordUtils {
     @UseCase(id = 47, description = "Passwords must contain at least one numeric")
     public boolean validatePassword(String password) {
         return (password.matches("\\w*\\d\\w*"));
     }

     @UseCase(id = 48)
     public String encryptPassword(String password) {
         return new StringBuilder(password).reverse().toString();
     }
 }

解析注解：

public static void main(String[] args) {
     List<Integer> useCases = new ArrayList<Integer>();
     Collections.addAll(useCases, 47, 48, 49, 50);
     trackUseCases(useCases, PasswordUtils.class);
 }

 public static void trackUseCases(List<Integer> useCases, Class<?> cl) {
     for (Method m : cl.getDeclaredMethods()) {
         UseCase uc = m.getAnnotation(UseCase.class);
         if (uc != null) {
             System.out.println("Found Use Case:" + uc.id() + " "
                         + uc.description());
             useCases.remove(new Integer(uc.id()));
         }
     }
     for (int i : useCases) {
         System.out.println("Warning: Missing use case-" + i);
     }
 }
 // Found Use Case:47 Passwords must contain at least one numeric
 // Found Use Case:48 no description
 // Warning: Missing use case-49
 // Warning: Missing use case-50

安全性

1. 严格遵循面向对象的规范。这样封装了数据细节，只提供接口给用户。增加了数据级的安全性。

2. 无指针运算。java中的操作，除了基本类型都是引用的操作。引用是不能进行增减运算，不能被直接赋予内存地址的，从而增加了内存级的安全性。

3. 数组边界检查。这样就不会出现C/C++中的缓存溢出等安全漏洞。

4. 强制类型转换。非同类型的对象之间不能进行转换，否则会抛出ClassCastException

5. 语言对线程安全的支持。java从语言级支持线程。从而从语法和语言本身做了很多对线程的控制和支持。

6. 垃圾回收。

7. Exception。

类加载

原理

ClassLoader使用的是双亲委托模型来搜索类的，每个ClassLoader实例都有一个父类加载器的引用（不是继承的关系，是一个包含的关系），虚拟机内置的类加载器（Bootstrap ClassLoader）本身没有父类加载器，但可以用作其它ClassLoader实例的的父类加载器。

当一个ClassLoader实例需要加载某个类时，它会试图亲自搜索某个类之前，先把这个任务委托给它的父类加载器，这个过程是由上至下依次检查的，首先由最顶层的类加载器Bootstrap ClassLoader试图加载，如果没加载到，则把任务转交给Extension ClassLoader试图加载，如果也没加载到，则转交给App ClassLoader 进行加载，如果它也没有加载得到的话，则返回给委托的发起者，由它到指定的文件系统或网络等URL中加载该类。

如果它们都没有加载到这个类时，则抛出ClassNotFoundException异常。否则将这个找到的类生成一个类的定义，并将它加载到内存当中，最后返回这个类在内存中的Class实例对象。

JVM在判定两个class是否相同时，不仅要判断两个类名是否相同，而且要判断是否由同一个类加载器实例加载的。只有两者同时满足的情况下，JVM才认为这两个class是相同的。

加载器

BootStrap ClassLoader

启动类加载器，是Java类加载层次中最顶层的类加载器，负责加载JDK中的核心类库，如：rt.jar、resources.jar、charsets.jar等。

   URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
   for (int i = 0; i < urls.length; i++) {
       System.out.println(urls[i].toExternalForm());  
   }
   // 也可以通过sun.boot.class.path获取
   System.out.println(System.getProperty("sun.boot.class.path"))

Extension ClassLoader

扩展类加载器，负责加载Java的扩展类库，默认加载JAVA_HOME/jre/lib/ext/目下的所有jar。

App ClassLoader

系统类加载器，负责加载应用程序classpath目录下的所有jar和class文件

注意：

除了Java默认提供的三个ClassLoader之外，用户还可以根据需要定义自已的ClassLoader，而这些自定义的ClassLoader都必须继承自java.lang.ClassLoader类，
也包括Java提供的另外二个ClassLoader（Extension ClassLoader和App ClassLoader）在内。
Bootstrap ClassLoader不继承自ClassLoader，因为它不是一个普通的Java类，
底层由C++编写，已嵌入到了JVM内核当中，当JVM启动后，Bootstrap ClassLoader也随着启动，
负责加载完核心类库后，并构造Extension ClassLoader和App ClassLoader类加载器。

关键字

strictfp(strict float point)

strictfp 关键字可应用于类、接口或方法。使用strictfp关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用strictfp关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754算法对操作数预期的结果，以单精度和双精度格式表示。

如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp。

transiant

变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。

Volatile

作为指令关键字，确保本条指令不会因编译器的优化而省略，修饰变量，保证变量每次都是从内存中重新读取。

final

1. 修饰基础数据成员(as const)

2. 修饰类或对象的引用

3. 修饰方法的final(cannot overwrite)

4. 修饰类或者参数

初始化

父静态->子静态
父变量->父初始化区->父构造
子变量->子初始化区->子构造

多线程

java多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。

线程池

concurrent下的线程池：

名称	功能
ExecutorService	真正的线程池接口
ScheduledExecutorService	能和Timer/TimerTask类似，解决那些需要任务重复执行的问题
ThreadPoolExecutor	ExecutorService的默认实现
ScheduledThreadPoolExecutor	继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现

Exécuteurs

newSingleThreadExecutor

Créez un pool de threads à un seul thread. Ce pool de threads n'a qu'un seul thread fonctionnel, ce qui équivaut à un seul thread exécutant toutes les tâches en série. Si le seul thread se termine anormalement, un nouveau thread le remplacera. Ce pool de threads garantit que toutes les tâches sont exécutées dans l'ordre dans lequel elles sont soumises.

newFixedThreadPool

Crée un pool de threads de taille fixe. Un thread est créé à chaque fois qu'une tâche est soumise, jusqu'à ce que le thread atteigne la taille maximale du pool de threads. La taille du pool de threads reste inchangée une fois qu'elle atteint la valeur maximale. Si un thread se termine en raison d'une exception d'exécution, le pool de threads sera reconstitué avec un nouveau thread.

newCachedThreadPool

Crée un pool de threads pouvant être mis en cache. Si la taille du pool de threads dépasse les threads requis pour traiter les tâches, certains threads inactifs (n'exécutant pas de tâches pendant 60 secondes) seront recyclés. Lorsque le nombre de tâches augmente, ce pool de threads peut ajouter intelligemment de nouveaux threads pour traiter les tâches. Ce pool de threads ne limite pas la taille du pool de threads. La taille du pool de threads dépend entièrement de la taille maximale des threads que le système d'exploitation (ou la JVM) peut créer.

newScheduledThreadPool

Crée un pool de threads de taille illimitée. Ce pool de threads prend en charge la synchronisation et l'exécution périodique des tâches.

Modèle de mémoire

Le modèle de mémoire Java stipule que les variables partagées par plusieurs threads sont stockées dans la mémoire principale et que chaque thread a son propre mémoire de travail indépendante, un thread ne peut accéder qu'à sa propre mémoire de travail et ne peut pas accéder à la mémoire de travail des autres threads. Une copie des variables partagées de la mémoire principale est stockée dans la mémoire de travail. Pour utiliser ces variables partagées, le thread ne peut effectuer la copie que dans la mémoire de travail. Une fois l'opération terminée, elle est synchronisée avec la mémoire principale.

Comment garantir l'intégrité des données de la mémoire principale exploitée par plusieurs threads est un problème difficile. Le modèle de mémoire Java stipule également le protocole d'interaction entre la mémoire de travail et la mémoire principale. Premièrement, il définit 8 types d'opérations atomiques. :

• lock : verrouille les variables dans la mémoire principale et les rend exclusives à un thread

• unclock : déverrouille le verrou ajouté par lock. A ce moment, d'autres Threads ont la possibilité d'accéder à cette variable

• lire : lire la valeur de la variable dans la mémoire principale dans la mémoire de travail

• load : lecture La valeur est enregistrée dans une copie de la variable dans la mémoire de travail.

• use : Passer la valeur au moteur d'exécution de code du thread

• assign : Réaffecter la valeur renvoyée par le moteur d'exécution à la variable copy

• store : stocke la valeur de la copie de la variable dans la mémoire principale.

• écrire : Écrire la valeur stockée dans le magasin dans la variable partagée de la mémoire principale.

Composition de la mémoire

Heap

Zone de données d'exécution, la mémoire de toutes les instances de classe et de tous les tableaux provient de celle-ci. Créé au démarrage de la machine virtuelle Java. La mémoire tas d'un objet est récupérée par un système de gestion automatique de la mémoire appelé garbage collector.

• News Generation (La jeune génération est Eden From Space To Space sur la photo)

• Eden stocke de nouveaux objets

• Espace Survivant Deux objets qui stockent les objets qui survivent à chaque collecte d'ordures

• Ancienne génération (la génération titulaire est l'ancien espace sur la photo) stocke principalement objets vivants avec un long cycle de vie

mémoire non tas

JVM a une mémoire partagée par tous les threads, zone de méthode . La zone de méthode appartient à la mémoire non tas. Il stocke chaque structure de classe telle que le pool de constantes d'exécution, les données de champ et de méthode, ainsi que le code des méthodes et des constructeurs. Il est créé au démarrage de la machine virtuelle Java. En plus de la zone de méthode, l'implémentation de la machine virtuelle Java peut nécessiter de la mémoire pour le traitement interne ou l'optimisation, qui est également de la mémoire non tas. Par exemple, le compilateur JIT nécessite de la mémoire pour stocker le code natif converti à partir du code de la machine virtuelle Java afin d'obtenir des performances élevées.

La génération permanente (espace permanent dans l'image) stocke les propres objets de réflexion de la JVM, tels que les objets de classe et les objets de méthode
tas natif

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!