04.Bases de Java - Cours

Concepts de base

Dans le concept orienté objet, nous savons que tous les objets sont représentés par des classes.

En Java, les classes sont définies par le mot-clé class.

De même, les classes en Java ont de nombreuses formes, notamment des classes ordinaires, des classes abstraites et des classes internes.

Les classes internes comprennent : les classes internes membres, les classes internes locales, les classes internes anonymes et les classes internes statiques.

---

Type normal

Il n'y a rien à dire à ce sujet.

public class Demo { }

---

Classe abstraite

1 Concepts de base

Tous les objets mentionnés ci-dessus sont représentés à travers. classes, mais toutes les classes ne sont pas utilisées pour décrire des objets.

Si une classe ne contient pas suffisamment d'informations pour décrire un objet spécifique (on peut la comprendre comme une classe incomplète), une telle classe est une classe abstraite.

Les classes abstraites sont définies avec le mot-clé absract. Il peut contenir des méthodes abstraites et des méthodes non abstraites.

---

2. Exemple d'étude

• Définition de classe abstraite

public abstract class Parent {

    // 1.成员变量，与普通类无差别
    private  String word="aa";    // 2.非抽象方法，与普通类无差
    private void talk(){
        System.out.println("Parent is talking");
    }    // 3.抽象方法，访问权限只能是 public 和 protected 
    abstract void print();
}

• Héritage de classe abstraite

// 1.抽象类继承抽象类，抽象子类不用实现父类的方法public abstract class Son extends Parent { }
// 2.普通类继承抽象类，普通子类必须实现父类的所有抽象方法public class Grandson extends Son {
    @Override
    void print() {
        System.out.println("I am Grandson");
    }
}

• Appel de classe abstraite

// 错误，抽象类不允许被实例化//Parent parent = new Parent();

Grâce au code ci-dessus, nous pouvons résumer les points suivants :

• Les classes abstraites et les méthodes abstraites ne peuvent pas être modifiées par private , et doit être défini à l’aide du mot-clé abstract.

• Si la sous-classe n'est pas une classe abstraite, elle doit implémenter toutes les méthodes abstraites de la classe parent.

• La classe abstraite ne peut pas être instanciée, erreur de compilation.

• Les classes abstraites peuvent également contenir des méthodes ordinaires et des variables membres.

---

Classe interne des membres

1. Concepts de base

Situé à l'intérieur d'une classe. La classe est appelée classe interne membre.

Les classes internes des membres ont les caractéristiques suivantes : toutes les propriétés de leurs classes externes sont accessibles sans aucune condition particulière.

2. Exemple d'étude

• Définition de classe interne membre :

public class Outter {
    private int a = 10;    static int b = 20;    int c = 30;    // 内部类
    class Inner {        void print(int d) {
            System.out.println(a + "-" +b+ "-" +c+ "-" + "-" +d;
        }
    }    // 取得内部类
    Inner getInner() {        return new Inner();
    }
}

• Appel de classe interne au membre

Outter out = new Outter();// 创建内部类的两种方式：
Outter.Inner inner = out.new Inner();Outter.Inner inner2 = out.getInner();inner.print(20);

3. Analyse du principe

En décompilant le fichier de classe, la commande est la suivante. :

javap -v Outter

Après avoir exécuté la commande, vous obtiendrez deux fichiers de classe : Oututter.Class et Oututter$Inner.Class.

Explication selon laquelle pour les machines virtuelles, les classes internes sont en fait les mêmes que les classes normales. Ainsi, Inner est toujours compilé dans une classe indépendante, plutôt que dans un certain champ de la classe Outter.

Mais comme la classe interne du membre ressemble à un membre de la classe externe, elle peut avoir les mêmes droits d'accès que le membre.

---

Classes internes locales

1.Concepts de base

Il existe deux types de classes internes locales :

• Classe au sein de la méthode.

• Cours en portée.

peut être considérée comme une variable locale interne d'une méthode ou d'une portée, ses droits d'accès sont donc limités à la méthode ou à la portée.

Comme les variables locales, elle ne peut pas être modifiée par les mots-clés public, protected, private et static.

2. Exemple d'étude

public class Man {
    public Object getWoman() {        // 注意：三个变量都相互不受影响
        int age = 30;        // 1.方法内的类
        class Woman {            int age = 20;
        }        // 2.作用域内的类，此时作用域为 if 
        if(true){
            class Son{                int age = 10;
            }
        }   
        return new Woman();
    }
}

---

Classe interne anonyme

1.

Les classes internes anonymes sont les seules classes sans constructeur. En raison de cette fonctionnalité, la portée d'utilisation des classes internes anonymes est très limitée et la plupart d'entre elles sont utilisées pour les rappels d'interface.

Elle présente les caractéristiques suivantes :

• La classe interne anonyme est automatiquement nommée Oututter$1.class par le système lors de la compilation.

• Les classes internes anonymes sont généralement utilisées pour hériter d'autres classes ou implémenter des interfaces. Elles n'ont pas besoin d'ajouter de méthodes supplémentaires, mais uniquement d'implémenter ou de réécrire les méthodes héritées.

• Les classes internes anonymes ne peuvent pas accéder aux variables locales dans les méthodes de classe externe à moins que les variables ne soient déclarées comme type final

---

2. Exemple d'étude

public class Test {
    // a 属于全局变量
    int a =100;    public static void main(String[] args) {
        Test t = new Test();
        t.test(200);
    }    // b 属于局部变量
    public void test(final int b) {        // c 属于局部变量
        final int c = 300;        //  匿名内部类
        new Thread() {            int  d = 400;            public void run() {
                System.out.println(a+"-"+b+"-"+c+"-"+d);
            };
        }.start();
    }
}

---

3. Analyse de principe

Vous pouvez obtenir deux classes en décompilant la commande Fichiers. : Oututter.class et Oututter$1.class.

À propos du cycle de vie des variables locales :

• Lorsqu'une méthode est appelée, des variables locales sont créées sur la pile. Lorsque la méthode se termine, elle est retirée de la pile et les variables locales meurent.

À propos du cycle de déclaration des objets de classe interne :

• Créez un objet de classe interne anonyme et le système alloue de la mémoire pour l'objet jusqu'à ce que non les variables sont référencées Points vers la mémoire allouée à l'objet avant qu'il ne soit traité par GC.

Il y a donc une situation :

• La méthode membre a été appelée jusqu'à la fin, la variable locale est morte, mais l'objet de la classe intérieure anonyme est toujours vivante.

La méthode de copie de mot-clé final est donc utilisée en Java pour résoudre le problème :

• final 关键字：因为它的特性是一旦变量被赋值后，就不能被修改。

• 复制：在匿名内部类中直接复制了一个与局部变量值的数，让它变成自己的局部变量。

所以当局部变量的生命周期结束后，匿名内部类照样可以访问 final 类型的局部变量，因为它自己拷贝了一份，且与原局部变量的值始终一致。

下面针对上面的代码来分析：

• 当 test 方法执行完毕之后，变量 b、c 的生命周期就结束了。然而 Thread 对象的生命周期很可能还没有结束。因此要将 b、c 设置为 final 。

• a 之所以不采用 final 修饰，因为它是全局变量，生命周期是随着类的结束而结束。而类的生命周期肯定大于匿名内部类。

---

静态内部类

1.基本概念

静态内部类也是定义在一个类里面的类，只不过在类的前面多了一个关键字static。

静态内部类和静态成员变量其实具有相同的特点：

• 它只有类有关，与对象无关。因此可以在没有外部类对象情况下，创建静态内部类。

• 不能访问外部类的非静态成员或方法

---

2.实例探究

• 内部静态类定义：

public class Outter {
    int a = 5;    static int b = 500;    // 静态内部类
    static class Inner {        public Inner() {            // 只能访问外部类的静态成员
            System.out.println(b);
        }
    }
}

• 静态内部类调用：

// 静态内部类的调用不依赖外部类对象Outter.Inner inner= new Outter.Inner();

---

接口内部类

1.基本概念

接口内部类，顾名思义就是在接口内定义的类。

---

2.实例探究

• 接口内部类定义：

public interface People{
    class Man {        public void print() {
            System.out.println("man.print()...");
        }
    }
}

• 接口内部类调用：

People.Man  man = new People.Man();

 以上就是04.Java 基础 - 类的内容，更多相关内容请关注PHP中文网（www.php.cn）！

---