Zusammenfassung der objektorientierten Programmierung mit Java

Zusammenfassung der objektorientierten Programmierung mit Java

Ich dachte, dass das Material, das ich für die Lernsitzung gemacht habe, "nun, ich konnte einen anständigen Betrag für mich selbst verdienen" war, also habe ich dies zum ersten Mal gepostet. Es wäre jedoch sehr peinlich, wenn ich damit den falschen Inhalt schreiben würde.

Was ist eine Klasse?

In der Objektorientierung heißt eine Einheit mit behavior und attribute object, und dieser Objekttyp heißt class. Um die Geschichte ein wenig mehr zu brechen,

• Verhalten: Einige Verhaltensweisen. Methode
• Attribut: Einige Informationen. Feld
• Objekt: Methode + Feld (dh __ Mitglied __)
• Klasse: Objekttyp

Ist.

Die Standardsyntax der Klasse lautet wie folgt.

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

Grundlegende Klassenverwendung

Instanziierung

__ Klassenobjekt erstellen __. Auch als " new "bekannt. Die Instanziierung wird wie folgt durchgeführt. Durch Instanziieren können Sie die Mitglieder und Methoden der instanziierten Klasse verwenden.

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.
  }
}

Konstrukteur

Ein Konstruktor ist eine Methode __, die nur einmal ausgeführt wird, wenn sie instanziiert wird. Beim Erstellen eines Konstruktors sollte der Methodenname mit dem Klassennamen übereinstimmen.

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.
  }
}

Ausführungsergebnis

Action constructor.

Qualifikation

1. Zugriffsmodifikator

Der Zugriff von außen kann durch Hinzufügen eines Zugriffsmodifikators eingeschränkt werden.

Ein einfaches Zugriffsbeispiel lautet wie folgt.

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";
}

Ausführungsergebnis

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

Wenn ich versuche, das letzte "System.out.println" ("Sie können" + cls.private_mbr + "member") zu kommentieren und zu kompilieren, wird aufgrund von Zugriffsbeschränkungen ein Kompilierungsfehler angezeigt.

2. Modifikator "statisch"

Mit dem Qualifikationsmerkmal "statisch" kann es zur Laufzeit im Speicher erweitert und ohne Instanziierung aufgerufen werden.

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";
}

Ausführungsergebnis

You can access static field.

3. final Modifikator

Durch Verwendung des Qualifikationsmerkmals "final" wird es zu einer Konstanten und sein Wert kann nicht geändert werden.

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";
}

Verkapselung

Fügen Sie Felder und Methoden zusammen und fügen Sie den zu schützenden Mitgliedern "privat" hinzu, damit auf sie nicht zugegriffen werden kann. Kapselung ist grundlegend,

• Wert abrufen: getter
• Wert zuweisen: Setter

Wird oft verwendet. Diese beiden Methoden werden als __accessor-Methode __ bezeichnet.

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;
  }
}

Ausführungsergebnis

hoge

Es gibt jedoch eine Geschichte, dass es bedeutungslos ist, "Getter" und "Setter" zu machen und mit "Privat" auf das Feld zuzugreifen, so dass "Getter" und "Setter" die Kapselung realisieren. Ansonsten habe ich in [diesem Artikel] geschrieben (https://qiita.com/katolisa/items/6cfd1a2a87058678d646).

Kapselung bedeutet übrigens auch, dass Sie den Zweck erreichen können, ohne sich um Daten und Verarbeitung kümmern zu müssen (bitte teilen Sie mir dies in den Kommentaren [Artikel] mit (https://qiita.com/shiracamus/items/ee10c7cf16102898bbeb#). _reference-867e1b32cdfedfcc02e2) hat es auch getan.).

Verwendung fortgeschrittener Klassen

Erbe

Um der Klasse eine __ Eltern-Kind-Beziehung zu geben __. Eine untergeordnete Klasse, die die übergeordnete Klasse erbt, erbt die Funktionalität der __parent-Klasse __.

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.");
  }
}

Ausführungsergebnis

I am Person.
I am Child.

So rufen Sie den Konstruktor der übergeordneten Klasse auf

Wenn Ihr Elternteil einen Konstruktor hat und Sie ihn aufrufen möchten, können Sie super (); ausführen.

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.");
  }
}

Ausführungsergebnis

I am Person.
I am Child.

Überlast

Überladung ist __, um mehrere Methoden mit demselben Namen und unterschiedlichen Argumenten __ zu generieren.

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);
  }
}

Ausführungsergebnis

String: hoge
Integer: 1

überschreiben

Überschreiben bedeutet, die von der übergeordneten Klasse geerbte Methode mit der untergeordneten Klasse zu überschreiben.

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.");
  }
}

Polymorphismus

In der Lage sein, das Verhalten abhängig von der Anwendung durch Überladen, Überschreiben und Schnittstelle zu ändern (später beschrieben).

Abstrakte Klasse

__ Eine Klasse, die nur den Zweck der übergeordneten Klasse berücksichtigt __. Daher kann es nicht direkt instanziiert werden.

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.");
  }
}

Ausführungsergebnis

I am Person.
I am Child.

Schnittstelle

__ Eine weitere Abstraktion der abstrakten Klasse __. Methoden können in der Schnittstelle deklariert werden, die Verarbeitung ist jedoch grundsätzlich nicht geschrieben. __ Beim Versuch, __ eine normale Verarbeitung zu schreiben, tritt ein Kompilierungsfehler auf.

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();
}

Da die Methoden in "interface" als "public" behandelt werden, müssen Sie bei Verwendung von "sayComment ()" von "interface" in "Class" "public" hinzufügen. Außerdem werden die Mitglieder in "interface" als "public static final" behandelt.

Bei der Beschreibung der Verarbeitung in "Schnittstelle"

Fügen Sie den Standardmodifikator hinzu.

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.");
  }
}

Ausführungsergebnis

I am Interface.

Eine Klasse kann mehrere Schnittstellen erfassen

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.");
  }
}

Ausführungsergebnis

I am Interface1.
I am Interface2.