Qu'est-ce que Java statique

1. méthode statique

la méthode statique est généralement appelée méthode statique car la méthode statique ne dépend d'aucun object Il est accessible, donc pour les méthodes statiques, il n'y a pas de this, car il n'est attaché à aucun objet. Puisqu'il n'y a pas d'objet, il n'y a pas de this. Et en raison de cette fonctionnalité, les variables membres non statiques et les méthodes membres non statiques de la classe ne sont pas accessibles dans les méthodes statiques, car les méthodes/variables membres non statiques doivent s'appuyer sur des objets spécifiques avant de pouvoir être appelées.

Mais il convient de noter que bien que les méthodes membres non statiques et les variables membres non statiques ne soient pas accessibles dans les méthodes statiques, les méthodes/variables membres statiques sont accessibles dans les méthodes membres non statiques. Un exemple simple :

Dans le code ci-dessus, puisque la méthode print2 existe indépendamment de l'objet, elle peut être appelée directement en utilisant le nom de la classe. Si les méthodes/variables non statiques sont accessibles dans les méthodes statiques, alors s'il y a l'instruction suivante dans la méthode principale :

MyObject.print2();

À ce moment, il n'y a aucun objet et str2 n'existe pas du tout, donc il y aura un conflit. Il en va de même pour les méthodes. Étant donné que vous ne pouvez pas prédire si les variables membres non statiques sont accédées dans la méthode print1, l'accès aux méthodes membres non statiques dans les méthodes membres statiques est également interdit.

En ce qui concerne les méthodes membres non statiques, il n'y a évidemment aucune restriction sur l'accès aux méthodes/variables membres statiques.

Par conséquent, si vous souhaitez appeler une méthode sans créer d'objet, vous pouvez définir cette méthode sur statique. Notre méthode statique la plus courante est la méthode main. Quant à savoir pourquoi la méthode main doit être statique, c'est maintenant clair. Étant donné que le programme ne crée aucun objet lors de l'exécution de la méthode principale, il n'est accessible que via le nom de la classe.

N'oubliez pas non plus que pour savoir si le constructeur est une méthode statique, veuillez vous référer à : http://blog.csdn.net/qq_17864929/article/details/48006835

2. Variables statiques

Les variables statiques sont également appelées variables statiques. La différence entre les variables statiques et les variables non statiques est que les variables statiques sont partagées par tous les objets et il y en a. une seule en mémoire. La copie est [stockée dans la zone méthode], qui sera initialisée si et seulement lorsque la classe est chargée pour la première fois [les emplacements d'initialisation des variables statiques avec final et sans final sont différents]. Les variables non statiques appartiennent aux objets et sont initialisées lors de la création de l'objet. Il existe plusieurs copies et les copies appartenant à chaque objet ne s'affectent pas les unes les autres.

L'ordre d'initialisation des variables membres statiques est initialisé dans l'ordre défini.

3. Bloc de code statique

Le mot-clé static joue également un rôle clé dans la formation de blocs de code statiques pour optimiser les performances du programme. Un bloc statique peut être placé n’importe où dans une classe et il peut y avoir plusieurs blocs statiques dans une classe. Lorsqu'une classe est chargée pour la première fois, chaque bloc statique sera exécuté dans l'ordre des blocs statiques et ne sera exécuté qu'une seule fois [selon le principe de chargement de classe, chaque classe est chargée une fois en utilisant le chargement par délégation parent].

Bloc de code statique de séquence d'initialisation> Bloc de code de construction> Constructeur

public class Client {
{//构造代码块
System.out.println("执行构造代码块");
}
}

La raison pour laquelle le bloc statique peut être utilisé pour optimiser les performances du programme est dû à ses caractéristiques : il ne sera chargé que lorsque la classe est chargée exécuté une seule fois. Regardons un exemple :

class Person{
private Date birthDate;
public Person(Date birthDate) {
this.birthDate = birthDate;
}
boolean isBornBoomer() {
Date startDate = Date.valueOf("1946");
Date endDate = Date.valueOf("1964");
return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
}
}

isBornBoomer est utilisé pour déterminer si la personne est née entre 1946 et 1964. Chaque fois que isBornBoomer est appelé, deux objets, startDate et BirthDate, seront générés, ce qui entraînera une perte de temps. space. Si vous le remplacez par ceci, ce sera plus efficace. En fait, il utilise le mécanisme de chargement des blocs de code statiques une fois en mémoire :

class Person{
private Date birthDate;
private static Date startDate,endDate;
static{
startDate = Date.valueOf("1946");
endDate = Date.valueOf("1964");
}
public Person(Date birthDate) {
this.birthDate = birthDate;
}
boolean isBornBoomer() {
return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
}
}

Par conséquent, plusieurs fois, certaines opérations d'initialisation n'ont besoin que d'être effectuées. effectués une fois sont placés dans un bloc de code statique.

4. Les classes internes statiques

Les classes internes statiques ne sont pas écrites séparément à cet endroit. Nous pouvons approfondir notre compréhension des classes internes statiques en les comparant avec les classes internes ordinaires. :

Pourquoi utiliser des classes internes ?

1. Les classes internes ne sont généralement utilisées que par leurs classes externes ; [Un bon exemple d'utilisation par des classes externes est qu'il existe une entrée de classe interne dans la collection hashmap, qui est convertie en stockage hashmap pour être utilisée. ]

2. La classe interne fournit une fenêtre sur la classe externe. La classe interne a une référence à la classe externe, afin que la classe interne puisse accéder directement aux propriétés de la classe externe

外部类按常规的类访问方式（以对象的方式）使用内部 类，唯一的差别是外部类可以访问内部类的所有方法与属性，包括私有方法与属性，外部类访问内部类，需要创建对象访问；有一点需要注意，内部类不能访问外部类所在的局部变量，只能访问final修饰的局部变量。

在方法内定义内部类时，如果内部类调用了方法中的变量，那么该变量必须申明为final类型，百思不得其解，后来想到应该是生命周期的原因，因为方法内定义的变量是局部变量，离开该方法，变量就失去了作用，也就会自动被消除，而内部类却不会离开它所在方法就失去作用，它有更广的生命周期。

（1）创建实例

OutClass.InnerClass obj = outClassInstance.new InnerClass(); //注意是外部类实例.new，内部类
AAA.StaticInner in = new AAA.StaticInner();//注意是外部类本身，静态内部类

（2）内部类中的this

内部类中的this与其他类一样是指的本身。创建内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件，可理解为内部类链接到外部类。 用外部类创建内部类对象时，此内部类对象会秘密的捕获一个指向外部类的引用，于是，可以通过这个引用来访问外围类的成员。

（3）外部类访问内部类

内部类类似外部类的属性，因此访问内部类对象时总是需要一个创建好的外部类对象。外部类对象通过‘外部类名.this.xxx’的形式访问内部类的属性与方法。如：

System.out.println("Print in inner Outer.index=" + pouter.this.index);
System.out.println("Print in inner Inner.index=" + this.index);

（4）内部类向上转型

内部类也可以和普通类一样拥有向上转型的特性。将内部类向上转型为基类型，尤其是接口时，内部类就有了用武之地。如果内部类是private的，只可以被它的外部类问，从而完全隐藏实现的细节。

（5）方法内的类

方法内创建的类（注意方法中也能定义类），不能加访问修饰符。另外，方法内部的类也不是在调用方法时才会创建的，它们一样也被事先编译了。

（6）静态内部类

定义静态内部类：在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。

通常称为嵌套类，当内部类是static时，意味着：

[1]要创建嵌套类的对象，并不需要其外围类的对象；

[2]不能从嵌套类的对象中访问非静态的外围类对象（不能够从静态内部类的对象中访问外部类的非静态成员）；

嵌 套类与普通的内部类还有一个区别：普通内部类的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有static数据和static字段， 也不能包含嵌套类。但是在嵌套类里可以包含所有这些东西。也就是说，在非静态内部类中不可以声明静态成员，只有将某个内部类修饰为静态类，然后才能够在这 个类中定义静态的成员变量与成员方法。

另外，在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。普通非静态内部类的 对象是依附在外部类对象之中的，要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。静态类和方法只属于类本身，并不属于 该类的对象，更不属于其他外部类的对象。

（7）内部类标识符

每个类会产生一个.class文件，文件名即为类名。同样，内部类也会产生这么一个.class文件，但是它的名称却不是内部类的类名，而是有着严格的限制：外围类的名字，加上$,再加上内部类名字。

代码具体：

public class OutClassTest 
{
static int a;
int b;
public static void test() {
System.out.println("outer class static function");
}
public static void main(String[] args) {
// new一个外部类
OutClassTest oc1 = new OutClassTest();
// 通过外部类的对象new一个非静态的内部类
OutClassTest.InnerClass no_static_inner = oc1.new InnerClass();
// 调用非静态内部类的方法
System.out.println(no_static_inner.getKey());
// 调用静态内部类的静态变量
System.out.println(OutClassTest.InnerStaticClass.static_value);
// 不依赖于外部类实例,直接实例化内部静态类
OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass();
// 调用静态内部类的非静态方法
System.out.println(inner.getValue());
// 调用内部静态类的静态方法
System.out.println(OutClassTest.InnerStaticClass.getMessage());
}
private class InnerClass {
// 只有在静态内部类中才能够声明或定义静态成员
// private static String tt = "0";
private int flag = 0;
public InnerClass() {
// 三.非静态内部类的非静态成员可以访问外部类的非静态变量和静态变量
System.out.println("InnerClass create a:" + a);
System.out.println("InnerClass create b:" + b);
System.out.println("InnerClass create flag:" + flag);
//
System.out.println("InnerClass call outer static function");
// 调用外部类的静态方法
test();
}
public  String getKey() {
return "no-static-inner";
}
}
private static class InnerStaticClass {
// 静态内部类可以有静态成员，而非静态内部类则不能有静态成员。
private static String static_value = "0";
private int flag = 0;
public InnerStaticClass() {
System.out.println("InnerClass create a:" + a);
            // 静态内部类不能够访问外部类的非静态成员
            // System.out.println("InnerClass create b:" + b);
            System.out.println("InnerStaticClass flag is " + flag);
            System.out.println("InnerStaticClass tt is " + static_value);
        }
        public int getValue() {
            // 静态内部类访问外部类的静态方法
            test();
            return 1;
        }
        public static String getMessage() {
            return "static-inner";
        }
    }
    public OutClassTest() {
        // new一个非静态的内部类
        InnerClass ic = new InnerClass();
        System.out.println("OuterClass create");
    }
}

有就是类名ClassName后面多了个.* ，意思是导入这个类里的静态方法。当然，也可以只导入某个静态方法，只要把 .* 换成静态方法名就行了。然后在这个类中，就可以直接用方法名调用静态方法，而不必用ClassName.方法名 的方式来调用。

好处：这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一个静态方法print(…)，在使用时直接print(…)就可以了。但是这种方法建议在有很多重复调用的时候使用，如果仅有一到两次调用，不如直接写来的方便

example：

在Java 5中，import语句得到了增强，以便提供甚至更加强大的减少击键次数功能，虽然一些人争议说这是以可读性为代价的。这种新的特性成为静态导入。当你想使用static成员时，可以使用静态导入（在API中的类和你自己的类上，都可以使用该特性）。下面是静态导入前后的代码实例：

在静态导入之前：

public class TestStatic {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.toHexString(42));
}
}

在静态导入之后：

import static java.lang.System.out;
import static java.lang.Integer.*;
public class TestStaticImport {
public static void main(String[] args) {
out.println(MAX_VALUE);
out.println(toHexString(42));
}
}

让我们看一下使用静态导入特性的代码中将发生什么：

1. Bien que cette fonctionnalité soit souvent appelée « importation statique », la syntaxe doit être import static, suivie du nom complet du membre statique que vous souhaitez importer, ou d'un caractère générique. Dans cet exemple, nous effectuons un import statique sur l'objet out de la classe System.

2. Dans cet exemple, nous souhaiterons peut-être utiliser plusieurs membres statiques de la classe java.lang.Integer. Cette instruction d'importation statique utilise des caractères génériques pour dire "Je souhaite effectuer une importation statique sur tous les membres statiques de cette classe".

3. Nous voyons enfin les avantages de la fonctionnalité d'importation statique ! Nous n'avons pas besoin de taper System dans System.out.println. Très bien! De plus, nous n'avons pas besoin de taper Integer dans Integer.MAX_VALUE. Ainsi, dans cette ligne de code, nous pouvons utiliser des raccourcis pour une méthode statique et une constante.

4. Enfin, nous effectuons davantage d'opérations de raccourci, cette fois pour les méthodes de la classe Integer.

Nous sommes déjà un peu sarcastiques à propos de cette fonctionnalité, mais nous ne sommes pas seuls. Nous ne pensons pas que sauvegarder quelques frappes rende le code plus difficile à lire, mais de nombreux développeurs ont demandé qu'il soit ajouté au langage.

Voici plusieurs principes d'utilisation de l'importation statique :

Vous devez dire import static, pas static import.

Méfiez-vous des membres statiques nommés de manière ambiguë. Par exemple, si vous effectuez des importations statiques sur la classe Integer et la classe Long, le référencement à MAX_VALUE provoquera une erreur du compilateur car Integer et Long ont tous deux une constante MAX_VALUE et Java ne saura pas à quelle MAX_VALUE vous faites référence.

Vous pouvez effectuer des importations statiques sur des références d'objets statiques, des constantes (rappelez-vous, elles sont statiques ou finales) et des méthodes statiques.

De nombreuses vidéos de formation Java, toutes sur le site PHP chinois, bienvenue pour apprendre en ligne !

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!