Résumé de la programmation orientée objet utilisant Java

Résumé de la programmation orientée objet utilisant Java

Je pensais que le matériel que j'avais fait pour la session d'étude était "bien, j'ai pu me faire un montant décent", alors j'ai posté ceci pour la première fois. Cependant, ce serait très embarrassant si j'écrivais le mauvais contenu avec cela.

Qu'est-ce qu'une classe

En orientation objet, une unité de 1 avec behavior et attribute est appelée object, et ce type d'objet est appelé class. Pour casser un peu plus l'histoire,

• Comportement: certains comportements. Méthode
• Attribut: certaines informations. champ
• Objet: Méthode + champ (c'est-à-dire __ membre __)
• Classe: type d'objet

Est.

La syntaxe standard de la classe est la suivante.

class sandbox {
  public int field;
  public void method() {
    // Write anything process.
  }
}

Utilisation de base des cours

Instanciation

__ Création d'un objet de classe __. Aussi connu sous le nom de «« nouveau »». L'instanciation est effectuée comme suit. En instanciant, vous pouvez utiliser les membres et les méthodes de la classe instanciée.

class sandbox {
  public static void main(String[] args) {
    Class cls = new Class(); // Create instance.
    cls.method(); // You can action method() of  Class.
  }
}

class Class {
  public int field;
  public void method() {
    // Write anything process.
  }
}

constructeur

Un constructeur est une méthode __ qui n'est exécutée qu'une seule fois lorsqu'elle est instanciée. Lors de la création d'un constructeur, le nom de la méthode doit être le même que le nom de la classe.

class sandbox {
  public static void main(String[] args) {
    Class cls = new Class();
    // Create instance and action constructor.
  }
}

class Class {
  public int field;
  public Class() {
    System.out.println("Action constructor.");
  }
  public void method() {
    // Write anything process.
  }
}

Résultat d'exécution

Action constructor.

Qualificatif

1. Modificateur d'accès

L'accès de l'extérieur peut être restreint en ajoutant un modificateur d'accès.

Un exemple d'accès simple est le suivant.

class sandbox {
  public static void main(String[] args) {
    Class cls = new Class(); // Create instance.
    System.out.println("You can access " + cls.public_fld + " field.");
    System.out.println("You can access " + cls.protected_fld + " field.");
    System.out.println("You can access " + cls.nothing_fld + " filed.");

    // Compile err.
    // System.out.println("You can " + cls.private_fld + " field.");
  }
}

class Class {
  public String public_fld = "public";
  protected String protected_fld = "protected";
  String nothing_fld = "nothing";
  private String private_fld = "private";
}

Résultat d'exécution

You can access public field.
You can access protected field.
You can access nothing field.

Quand j'essaye de compiler en décommentant le dernier System.out.println (" You can "+ cls.private_mbr +" member ");, j'obtiens une erreur de compilation en raison de restrictions d'accès.

2. Modificateur static

Le qualificatif «static» lui permet d'être étendu en mémoire au moment de l'exécution et d'y accéder sans instanciation.

class sandbox {
  public static void main(String[] args) {
    System.out.println("You can access " + Class.static_fld + " field.");
  }
}

class Class {
  static String static_fld = "static";
}

Résultat d'exécution

You can access static field.

3. Modificateur final

En utilisant le qualificatif «final», il devient une constante et sa valeur ne peut pas être modifiée.

class sandbox {
  public static void main(String[] args) {
    System.out.println("You can access " + Class.static_fld + "member.");

    // Compile err.
    // Class.static_fld = "final";
  }
}

class Class {
  static final String static_fld = "static";
}

Encapsulation

Rassemblez les champs et les méthodes et ajoutez private aux membres que vous souhaitez protéger afin qu'ils ne soient pas accessibles. L'encapsulation est basique,

• Obtenir la valeur: getter
• Attribuer une valeur: setter

Est souvent utilisé. Ces deux méthodes sont appelées méthode __accessor __.

class sandbox {
  public static void main(String[] args) {
    Class cls = new Class();
    cls.setField("hoge");
    System.out.println(cls.getField());
  }
}

class Class {
  private String field = "";

  /**
   * Accessor method.
   * setField(String param) -> Setter
   * getField() -> Getter
  **/
  void setField(String param) {
    field = param;
  }

  String getField() {
    return field;
  }
}

Résultat d'exécution

hoge

Cependant, il y a une histoire selon laquelle il est inutile de faire en sorte que «getter» et «setter» et accéder au champ avec «private», donc pur «getter» et «setter» réalisent l'encapsulation. Sinon, j'ai écrit dans cet article.

D'ailleurs, l'encapsulation signifie également que vous pouvez atteindre l'objectif sans vous soucier des données et du traitement (veuillez me le dire dans les commentaires, article _reference-867e1b32cdfedfcc02e2) l'a également fait.).

Comment utiliser les cours avancés

Héritage

Donner à la classe une __ relation parent-enfant __. Une classe enfant qui hérite de la classe parent héritera des fonctionnalités de la classe __parent __.

class sandbox {
  public static void main(String[] args) {
    Child cld = new Child();
    cld.sayCommentByPerson();
    cld.sayCommentByChild();
  }
}

// Super class.
class Person {
  void sayCommentByPerson() {
    System.out.println("I am Person.");
  }
}

// Sub class.
class Child extends Person {
  void sayCommentByChild() {
    System.out.println("I am Child.");
  }
}

Résultat d'exécution

I am Person.
I am Child.

Pour appeler le constructeur de la classe parent

Si votre parent a un constructeur et que vous voulez l'appeler, vous pouvez faire super ();.

class sandbox {
  public static void main(String[] args) {
    Child cld = new Child();
    cld.sayCommentByChild();
  }
}

// Super class.
class Person {
  Person() {
    System.out.println("I am Person.");
  }
}

// Sub class.
class Child extends Person {

  //Call constructor of super class.
  Child() {
    super();
  }

  void sayCommentByChild() {
    System.out.println("I am Child.");
  }
}

Résultat d'exécution

I am Person.
I am Child.

Surcharge

La surcharge est __ pour générer plusieurs méthodes avec le même nom avec des arguments différents __.

class sandbox {
  public static void main(String[] args) {
    Class strClass = new Class("hoge");
    Class intClass = new Class(1);
  }
}

class Class {
  Class(String param) {
    System.out.println("String: " + param);
  }
  
  Class(int param) {
    System.out.println("Integer: " + param);
  }
}

Résultat d'exécution

String: hoge
Integer: 1

passer outre

Le remplacement consiste à remplacer la méthode héritée de la classe parente par la classe enfant.

class sandbox {
  public static void main(String[] args) {
    Child cld = new Child();
    cld.sayComment();
  }
}

// Super class.
class Person {
  void sayComment() {
    System.out.println("I am Person.");
  }
}

// Sub class.
class Child extends Person {

  @Override
  void sayComment() {
    System.out.println("I am Child.");
  }
}

Polymorphisme

Être capable de changer le comportement en fonction de l'application en surchargeant, en remplaçant et en interface (décrit plus loin).

Classe abstraite

__ Une classe qui considère uniquement le but de la classe parent __. Par conséquent, il ne peut pas être instancié directement.

class sandbox {
  public static void main(String[] args) {
    // Compile err.
    // Person prson = new Person();

    Child chld = new Child();
    chld.sayCommentByPerson();
    chld.sayCommentByChild();
  }
}

abstract class Person {
  void sayCommentByPerson() {
    System.out.println("I am Person.");
  }
}

class Child extends Person {
  void sayCommentByChild() {
    System.out.println("I am Child.");
  }
}

Résultat d'exécution

I am Person.
I am Child.

interface

__ Une autre abstraction de la classe abstraite __. Les méthodes peuvent être déclarées dans l'interface, mais le traitement n'est pas écrit en principe. __ Une erreur de compilation se produit lorsque vous essayez d'écrire __ le traitement normalement.

class sandbox {
  public static void main(String[] args) {
    Class cls = new Class();
    cls.sayComment();
  }
}

class Class implements Interface {
  public void sayComment() {
    System.out.println("I am Class.");
  }
}

interface Interface {
  void sayComment();
}

De plus, puisque la méthode dans ʻinterface est traitée comme public, lorsque vous utilisez sayComment () de ʻinterface dans Class, vous devez ajouter public. De plus, les membres de l '«interface» sont traités comme «public static final».

Lors de la description du traitement dans ʻinterface`

Ajoutez le modificateur default.

class sandbox {
  public static void main(String[] args) {
    Class cls = new Class();
    cls.sayComment();
  }
}

class Class implements Interface {

}

interface Interface {
  default void sayComment() {
    System.out.println("I am Interface.");
  }
}

Résultat d'exécution

I am Interface.

Une classe peut capturer plusieurs «interfaces»

class sandbox {
  public static void main(String[] args) {
    Class cls = new Class();
    cls.sayComment1();
    cls.sayComment2();
  }
}

class Class implements Interface1, Interface2 {

}

interface Interface1 {
  default void sayComment1() {
    System.out.println("I am Interface1.");
  }
}

interface Interface2 {
  default void sayComment2() {
    System.out.println("I am Interface2.");
  }
}

Résultat d'exécution

I am Interface1.
I am Interface2.