Aktionen

Objekte und Klassen

Aus Java Tutorial - Java lernen

Java ist eine objektorientierte Sprache. Als eine Sprache, die die objektorientierte Eigenschaft besitzt, unterstützt Java die folgenden grundlegenden Konzepte:

  • Polymorphismus
  • Vererbung
  • Einkapselung
  • Abstraktion
  • Klassen
  • Objekte
  • Instanz
  • Methode
  • Übermittlung von Nachrichten

In diesem Kapitel werden wir uns mit den Konzepten - Klassen und Objekte - befassen.

  • Objekt - Objekte haben Zustände und Verhaltensweisen. Beispiel: Ein Hund hat die Zustände - Farbe, Name, Rasse sowie die Verhaltensweisen - Schwanzwedeln, Bellen, Fressen. Ein Objekt ist eine Instanz einer Klasse.
  • Klasse - Eine Klasse kann als Vorlage / Entwurf definiert werden, die das Verhalten / den Zustand beschreibt, den das Objekt seines Typs unterstützt.


Objekte in Java

Lassen Sie uns nun tief in das hineinschauen, was Objekte sind. Wenn wir die reale Welt betrachten, können wir viele Objekte um uns herum finden, Autos, Hunde, Menschen usw. Alle diese Objekte haben einen Zustand und ein Verhalten.

Wenn wir einen Hund betrachten, dann ist sein Zustand: Name, Rasse, Farbe, und das Verhalten ist: bellen, mit dem Schwanz wedeln, laufen.

Wenn Sie das Software-Objekt mit einem Objekt aus der realen Welt vergleichen, haben sie sehr ähnliche Eigenschaften.

Software-Objekte haben auch einen Zustand und ein Verhalten. Der Zustand eines Software-Objekts wird in Feldern gespeichert, und das Verhalten wird über Methoden gezeigt.

In der Software-Entwicklung operieren Methoden also auf dem internen Zustand eines Objekts, und die Objekt-zu-Objekt-Kommunikation erfolgt über Methoden.

Klassen in Java

Eine Klasse ist ein Entwurf, aus der einzelne Objekte erstellt werden.

Es folgt ein Beispiel einer Klasse. 

public class Dog {
   String breed;
   int age;
   String color;

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

Eine Klasse kann irgendeinen der folgenden Variablentypen enthalten:

  • Lokale Variablen - Variablen, die innerhalb von Methoden, Konstruktoren oder Blöcken definiert sind, werden als lokale Variablen bezeichnet. Die Variable wird innerhalb der Methode deklariert und initialisiert, und die Variable wird zerstört, wenn die Methode abgeschlossen ist.
  • Instanzvariablen - Instanzvariablen sind Variablen innerhalb einer Klasse, aber außerhalb jeder Methode. Diese Variablen werden initialisiert, wenn die Klasse instanziiert wird. Auf Instanzvariablen kann von jeder Methode, jedes Konstruktors oder von Blöcken dieser bestimmten Klasse aus zugegriffen werden.
  • Klassenvariablen - Klassenvariablen sind Variablen, die innerhalb einer Klasse, außerhalb jeder Methode, mit dem Schlüsselwort static deklariert sind.

Eine Klasse kann eine beliebige Anzahl von Methoden haben, um auf den Wert verschiedener Arten von Methoden zuzugreifen. Im obigen Beispiel sind barking(), hungry() und sleeping() Methoden.

Nachfolgend sind einige der wichtigen Themen aufgeführt, die bei der Betrachtung von Klassen der Java-Sprache diskutiert werden müssen.

Konstruktoren

Wenn über Klassen diskutiert wird, wäre eines der wichtigsten Unterthemen die Konstruktoren. Jede Klasse hat einen Konstruktor. Wenn wir nicht explizit einen Konstruktor für eine Klasse schreiben, erstellt der Java-Compiler einen Standardkonstruktor für diese Klasse.

Jedes Mal, wenn ein neues Objekt erzeugt wird, wird mindestens ein Konstruktor aufgerufen. Die Hauptregel von Konstruktoren ist, dass sie den gleichen Namen wie die Klasse haben sollten. Eine Klasse kann mehr als einen Konstruktor haben.

Es folgt ein Beispiel für einen Konstruktor - 

public class Puppy {
   public Puppy() {
   }

   public Puppy(String name) {
      // Dieser Konstruktor hat einen Parameter: name
   }
}

Java unterstützt auch Singleton-Klassen, bei denen Sie nur eine Instanz einer Klasse erzeugen können.

Hinweis - Wir haben zwei verschiedene Arten von Konstruktoren. Wir werden die Konstruktoren in den folgenden Kapiteln im Detail besprechen.

Ein Objekt erstellen

Wie bereits erwähnt, stellt eine Klasse die Entwürfe für Objekte zur Verfügung. Im Grunde wird also aus einer Klasse ein Objekt erzeugt. In Java wird das neue Schlüsselwort verwendet, um neue Objekte zu erstellen.

Die Erstellung eines Objekts aus einer Klasse erfolgt in drei Schritten:

  1. Deklaration - Eine Variablendeklaration mit einem Variablennamen und mit einem Objekttyp.
  2. Instanziierung - Das Schlüsselwort 'new' wird verwendet, um das Objekt zu erzeugen.
  3. Initialisierung - Auf das Schlüsselwort 'new' folgt der Aufruf eines Konstruktors. Dieser Aufruf initialisiert das neue Objekt.

Es folgt ein Beispiel für die Erstellung eines Objekts: 

public class Puppy {
   public Puppy(String name) {
      // Dieser Konstruktor hat einen Parameter: name
      System.out.println("Passed Name is :" + name );
   }

   public static void main(String []args) {
      // Folgende Anweisung würde ein Objekt 'myPuppy' erzeugen
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

Wenn wir das obige Programm kompilieren und ausführen, dann wird es folgendes Ergebnis liefern:

Ausgabe

Passed Name is :tommy

Zugriff auf Instanzvariablen und Methoden

Auf Instanzvariablen und Methoden wird über erzeugte Objekte zugegriffen. Der Zugriff auf eine Instanzvariable erfolgt über den voll qualifizierten Pfad - 

/* Erstellen Sie zunächst ein Objekt */
ObjectReference = new Constructor();

/* Rufen Sie nun eine Variable wie folgt auf */
ObjectReference.variableName;

/* Nun können Sie eine Klassenmethode wie folgt aufrufen */
ObjectReference.MethodName();

Beispiel

Dieses Beispiel erklärt, wie auf Instanzvariablen und Methoden einer Klasse zugegriffen werden kann. 

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // Dieser Konstruktor hat einen Parameter: name
      System.out.println("Name chosen is :" + name );
   }

   public void setAge( int age ) {
      puppyAge = age;
   }

   public int getAge( ) {
      System.out.println("Puppy's age is :" + puppyAge );
      return puppyAge;
   }

   public static void main(String []args) {
      /* Erstellen eines Objektes */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Klassenmethode aufrufen, um das puppys Alter festzulegen */
      myPuppy.setAge( 2 );

      /* Eine weitere Klassenmethode aufrufen um puppys Alter zu ermitteln */
      myPuppy.getAge( );

      /* Sie können auf die Instanzvariable auch wie folgt zugreifen */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

Wenn wir das obige Programm kompilieren und ausführen, dann wird es folgendes Ergebnis liefern:

Ausgabe

Name chosen is :tommy
Puppy's age is :2
Variable Value :2

Regeln für die Deklaration der Quelldatei

Als letzter Teil dieses Abschnitts wollen wir uns nun die Deklarationsregeln für die Quelldatei ansehen. Diese Regeln sind bei der Deklaration von Klassen, Import-Anweisungen und Paket-Anweisungen in einer Quelldatei von wesentlicher Bedeutung.

  • Es kann nur eine öffentliche Klasse pro Quelldatei geben.
  • Eine Quelldatei kann mehrere nicht-öffentliche Klassen haben.
  • Der Name der öffentlichen Klasse sollte auch der Name der Quelldatei sein, der am Ende mit .java angehängt werden sollte. Zum Beispiel: der Klassenname ist die öffentliche Klasse Employee{}, dann sollte die Quelldatei als Employee.java bezeichnet werden.
  • Wenn die Klasse innerhalb eines Pakets definiert ist, dann sollte die Paketanweisung die erste Anweisung in der Quelldatei sein.
  • Wenn Import-Anweisungen vorhanden sind, müssen sie zwischen der Paket-Anweisung und der Klassendeklaration geschrieben werden. Wenn es keine Paket-Anweisungen gibt, sollte die Import-Anweisung die erste Zeile in der Quelldatei sein.
  • Import- und Paket-Anweisungen beziehen sich auf alle in der Quelldatei vorhandenen Klassen. Es ist nicht möglich, verschiedene Import- und/oder Paketanweisungen für verschiedene Klassen in der Quelldatei zu deklarieren.

Klassen haben mehrere Zugriffsebenen, und es gibt verschiedene Arten von Klassen: abstrakte Klassen, finale Klassen usw. Wir werden all dies im Kapitel Zugriffsmodifikatoren erklären.

Abgesehen von den oben erwähnten Klassentypen gibt es in Java auch einige spezielle Klassen, die als Innere Klassen und Anonyme Klassen bezeichnet werden.

Java-Paket

In einfachen Worten, es ist eine Möglichkeit, die Klassen und Schnittstellen zu kategorisieren. Bei der Entwicklung von Anwendungen in Java werden Hunderte von Klassen und Schnittstellen geschrieben, daher ist die Kategorisierung dieser Klassen ein Muss und macht das Leben viel einfacher.

Import-Anweisungen

Wenn in Java ein vollqualifizierter Name angegeben wird, der das Paket und den Klassennamen enthält, dann kann der Compiler den Quellcode oder die Klassen leicht finden. Die Import-Anweisung ist eine Möglichkeit, dem Compiler den richtigen Ort anzugeben, an dem er diese bestimmte Klasse finden kann.

Zum Beispiel würde die folgende Zeile den Compiler auffordern, alle im Verzeichnis java_installation/java/io verfügbaren Klassen zu laden: 

import java.io.*;

Eine einfache Fallstudie

Für unsere Fallstudie werden wir zwei Klassen erzeugen. Sie sind Employee und EmployeeTest.

Öffnen Sie zunächst den Notizblock und fügen Sie den folgenden Code hinzu. Denken Sie daran, dass dies die Klasse Employee ist und die Klasse eine öffentliche Klasse ist. Speichern Sie nun diese Quelldatei unter dem Namen Employee.java.

Die Klasse Employee hat vier Instanzvariablen: Name, Alter, Bezeichnung und Gehalt. Die Klasse hat einen explizit definierten Konstruktor, der einen Parameter aufnimmt.

Beispiel

import java.io.*;
public class Employee {

   String name;
   int age;
   String designation;
   double salary;

   // Das ist der Konstruktor der Klasse Employee
   public Employee(String name) {
      this.name = name;
   }

   // Ordnen Sie das Alter des Mitarbeiters dem variablen Alter zu.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Weisen Sie die Bezeichnung der Variablenbezeichnung zu.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Weisen Sie das Gehalt dem variablen Gehalt zu.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Geben Sie die Mitarbeiterdaten aus */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

Wie bereits zuvor in diesem Tutorial erwähnt, beginnt die Verarbeitung bei der Hauptmethode. Damit wir diese Employee-Klasse ausführen können, muss es also eine Hauptmethode geben und es müssen Objekte erstellt werden. Für diese Aufgaben werden wir eine separate Klasse erstellen.

Es folgt die Klasse EmployeeTest, die zwei Instanzen der Klasse Employee erstellt und die Methoden für jedes Objekt aufruft, um Werte für jede Variable zuzuweisen.

Speichern Sie den folgenden Code in der Datei EmployeeTest.java. 

import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Erstellen von zwei Obejekten durch Benutzen des Konstruktors */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Aufrufen der Methoden für jedes erstellte Objekt
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

Kompilieren Sie nun die beiden Klassen und führen Sie dann EmployeeTest aus, um Folgendes Ergebnis zu sehen:

Ausgabe

C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0
Abgerufen von „https://www.javatutorial.de/w/?title=Objekte_und_Klassen&oldid=101“