Classes et objets de base Java, modèle singleton, héritage

Classes et objets Java

Les classes générales ne peuvent être que publiques ou par défaut. Si elles sont publiques, le nom de la classe doit être le même que le nom du fichier. Généralement, une seule classe est écrite dans un fichier, cette classe est donc généralement ajoutée avec public.

Les classes internes peuvent également être privées et protégées, généralement privées, car seule la classe actuelle est nécessaire. De cette façon, seules ses classes externes peuvent y accéder directement. Peu importe donc que les données contenues soient publiques, privées ou par défaut.

public class Out {private int d = 10;public int add() {      // 外部类不能直接访问内部类的数据，除非new出内部类对象,如下  // Out.In abc = new Out().new In();a = 3; // falseb = 5; // false}  // 内部类private class In {private int a = 100;int b;public int c;public void add() {
            System.out.println(d); // true, 内部类却可以直接访问外部类的数据}
    }public static void main(String[] args) {
        Out bb = new Out();
        Out.In abc = new Out().new In();
        bb.d = 20; // 本类可以直接访问private，一般不这样，而是写个set函数，搭配get函数System.out.println(aa.a); // 100System.out.println(bb.d); // 被修改为20}
}

• Objet Anonyme

new Abc().run(); // 调用一次后这个对象就销毁new Abc().run(); // 这是另外一个Abc对象了

• À propos des variables privées

• privées : encapsulez les données et affichez uniquement les méthodes aux utilisateurs. Par exemple, le nom de la chaîne privée ne peut pas être modifié à volonté, mais les méthodes setName() et getName() peuvent être appelées pour réaliser l'encapsulation des données, ce qui est plus sûr.

• Méthode privée : une fonction qui n'a pas besoin d'être appelée par l'utilisateur peut être définie comme privée après avoir complété certains détails d'implémentation internes. Par exemple, l'algorithme de tri par sélection est écrit sous la forme d'une méthode contenant le processus d'échange de deux données et encapsulée dans une fonction. Cette fonction n'a pas besoin d'être utilisée par l'utilisateur (l'utilisateur n'a besoin que d'utiliser un sort()), et ce swap() est défini comme privé.

Le modèle de conception à cas unique

peut garantir l'unicité des objets d'une classe en mémoire. Lorsque vous devez utiliser le même objet d'informations de configuration pour plusieurs programmes, vous devez le faire. assurez-vous que l'unicité de l'objet, alors instance unique est nécessaire.

Dans la classe d'outils, si les données membres de l'objet ne sont pas utilisées (accédées), il n'est pas nécessaire de créer un objet. Pour empêcher la création d'objets, le constructeur peut être défini comme privé.

Comment garantir l'unicité des objets ?

1. Ne permettez pas à d'autres programmes de créer des objets de cette classe en utilisant new et définissez le constructeur sur private

2. Créez une instance de classe unique dans cette classe

3. Fournir une méthode pour que d'autres programmes puissent obtenir cet objet unique

Étapes de conception d'un seul cas

1. Priver le constructeur de cette classe

2. Mettre un objet de cette classe dans cette classe via new

3. Définir une méthode publique, renvoie l'objet créé en 2. >

Q : Pourquoi les variables membres et les méthodes sont-elles statiques ?

A : Parce que new n'est pas autorisé à créer de nouveaux objets dans d'autres classes, getInstance() ne peut pas être appelé si nous le définissons sur une

méthode statique

, elle peut être obtenue via <🎜. > Il n'est pas nécessaire d'avoir un nouvel objet et les données de la méthode statique doivent également être statiques. Par conséquent, cet objet SingleDemo doit également être statique.

// 饿汉式--不管用不用得到，先new出一个再说public class SingleDemo {// private不能将这个实例暴露出去，只能通过getInstance()获取，另为何是static？private static SingleDemo s = new SingleDemo();private SingleDemo() {}// 供外界调用来获取这个对象public static SingleDemo getInstance() {return s;
    }  // 只有本类中可以new对象并调用addpublic void add() {
        System.out.println("danli");
    }public static void main(String[] args) {      // 本类可以newSingleDemo a = new SingleDemo();
        a.add();
    }
}public class Test {public static void main(String[] args) {      // fasle, 其他类中若用到这个单例，不能newSingleDemo aa = new SingleDemo();      // true  SingleDemo aa = SingleDemo.getInstance();
    }
}

Q : Quelle est la différence entre le mode homme affamé et le mode homme paresseux ?

A :

Le mode paresseux

est un chargement retardé, et il n'est nouveau qu'après son utilisation ; l'unicité de l'objet ne peut pas être garantie en multi-thread, et il est thread-dangereux.

// 另外一种单例设计模式--懒汉模式--用到了才new，延时加载public class SingleDemo {// 先设为空private static SingleDemo s;private SingleDemo() {}// 供外界调用来获取这个对象public static SingleDemo getInstance() {      if (s == null)
        s = new SingleDemo();return s;
    }

Le mode Hungry Man

signifie qu'au fur et à mesure que la classe est chargée, l'objet sera nouveau, qu'il soit utilisé ou non, il est thread-safe.

Héritage

Java utilise généralement l'héritage uniqueSingle.getInstance(), et ne peut pas directement hériter de plusieurs --> car plusieurs classes parent peuvent avoir les mêmes membres, l'appel entraînera une ambiguïté.

Mais vous pouvez
héritage multi-niveaux, comme A ---> B --->Ｃ--> hérite de C, ainsi de suite.

Utilisez

pour faire la distinction entre les membres de cette classe et les variables locales

Utilisez

lorsque les membres des sous-classes et des classes parentes ont du même nom Distinguer

Les classes dérivées ne peuvent pas accéder aux membres privés de la classe de base, mais elles sont bien héritées, mais elles ne sont pas accessibles. Vous pouvez appeler la fonction

de. la classe parent pour gérer la sous-classe. Les membres privés n'ont aucun effet sur la classe parent.

• this

  Si le membre est protégé ou dispose d'autorisations plus élevées, vous pouvez accéder directement au membre sans
.

• super

  Les membres de la classe parent et de la sous-classe sont indépendants les uns des autres. La sous-classe change ses propres membres et la classe parent reste la même.

• set、get

• set、getLa sous-classe exécute implicitement super() lors de la création d'un objet enfant, le constructeur de la classe parent est d'abord appelé. . Exécutez ensuite le constructeur de la sous-classe.

• Le constructeur par défaut est sans paramètre, et le constructeur

  avec paramètres remplacera le
sans paramètre. À ce stade, super(args) doit être utilisé explicitement et doit être placé sur la première ligne. Si super n'est pas écrit explicitement, le

super()

par défaut sera exécuté, qui est le constructeur de la classe parent. sans paramètres.

package Chap1;public class Fu {  // 父类的成员是私有的，子类继承过去了也不能直接访问
  private int age;private String name;public Fu(int age, String name) {this.age = age;this.name = name;
    }public int getAge() {return age;
    }public void setAge(int age) {this.age = age;
    }public String getName() {return name;
    }public void setName(String name) {this.name = name;
    }
}class Zi extends Fu {  // 特有的job，父不能访问private String job;Zi(int age, String name, String job) {super(age, name);this.job = job;
    }public String getJob() {return job;
    }  public static void main(String[] args) {
        Zi aa = new Zi(23, "Zi","Study");
        Fu bb = new Fu(55, "Fu");      // 改变子类不会影响父类aa.setAge(24);
        aa.setName("zi");      // zi 24 Study  // Fu 55System.out.println(aa.getName()+" "+aa.getAge() + " " + aa.getJob());
        System.out.println(bb.getName()+" "+bb.getAge());

    }
}

• • 类是public，构造函数也是public的。他们的修饰符是对应的。

  一个对象的实例化过程

  Person p = new Person();

  1. JVM读取Person.class文件，加载进内存；若有父类，会先加载父类。

  2. 在堆内存中开辟空间，分配地址。

  3. 在对象空间中，对对象的属性进行默认初始化，如int age = 0; String name = null;

  4. 显示初始化，如private int age = 9。若是子类，则会先调用父类的构造器。

  5. （子）类的 构造函数进行特定的初始化。如下程序中age变成100。

  6. 初始化后，将地址传递给引用变量。Person p <-- new Person();

  package Test;// 先打印9// 再打印100public class Demo {private int age = 9;
      {
          System.out.println(age);
      }Demo(int age) {this.age = age;
      }public static void main(String[] args) {
          Demo aa = new Demo(100);
          System.out.println(aa.age);
      }
  }

  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!