Java - Object en klassen

Java is een objectgeoriënteerde taal. Als een taal die de functie Object-Oriented heeft, ondersteunt Java de volgende fundamentele concepten −

Polymorfisme
Overerving
Inkapseling
Abstractie
Klassen
Objecten
Instantie
Methode
Bericht doorgegeven

In dit hoofdstuk zullen we kijken naar de concepten - Klassen en Objecten.

Object − Objecten hebben toestanden en gedragingen. Voorbeeld:Een hond heeft toestanden - kleur, naam, ras en gedrag - kwispelen, blaffen, eten. Een object is een instantie van een klasse.
Klasse − Een klasse kan worden gedefinieerd als een sjabloon/blauwdruk die het gedrag/de toestand beschrijft die het object van zijn type ondersteunt.

Objecten in Java

Laten we nu diep ingaan op wat objecten zijn. Als we de echte wereld beschouwen, kunnen we veel objecten om ons heen vinden, auto's, honden, mensen, enz. Al deze objecten hebben een toestand en een gedrag.

Als we een hond beschouwen, dan is zijn staat - naam, ras, kleur, en het gedrag is - blaffen, kwispelen, rennen.

Als je het software-object vergelijkt met een object uit de echte wereld, hebben ze zeer vergelijkbare kenmerken.

Softwareobjecten hebben ook een status en een gedrag. De status van een softwareobject wordt opgeslagen in velden en het gedrag wordt weergegeven via methoden.

Dus bij softwareontwikkeling werken methoden op de interne toestand van een object en vindt de object-naar-objectcommunicatie plaats via methoden.

Klassen in Java

Een klasse is een blauwdruk van waaruit individuele objecten worden gemaakt.

Hieronder volgt een voorbeeld van een klas.

Voorbeeld

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

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

Een klasse kan elk van de volgende typen variabelen bevatten.

Lokale variabelen − Variabelen die binnen methoden, constructors of blokken zijn gedefinieerd, worden lokale variabelen genoemd. De variabele wordt gedeclareerd en geïnitialiseerd binnen de methode en de variabele wordt vernietigd wanneer de methode is voltooid.
Instantievariabelen − Instantievariabelen zijn variabelen binnen een klasse, maar buiten elke methode. Deze variabelen worden geïnitialiseerd wanneer de klasse wordt geïnstantieerd. Instantievariabelen zijn toegankelijk vanuit elke methode, constructor of blokken van die specifieke klasse.
Klassevariabelen − Klassevariabelen zijn variabelen gedeclareerd binnen een klasse, buiten elke methode, met het statische sleutelwoord.

Een klasse kan een willekeurig aantal methoden hebben om toegang te krijgen tot de waarde van verschillende soorten methoden. In het bovenstaande voorbeeld zijn blaffen(), hongerig() en slapen() methoden.

Hieronder volgen enkele van de belangrijke onderwerpen die moeten worden besproken bij het bekijken van klassen van de Java-taal.

Constructeurs

Bij het bespreken van klassen, zou een van de belangrijkste subonderwerpen constructeurs zijn. Elke klasse heeft een constructor. Als we niet expliciet een constructor voor een klasse schrijven, bouwt de Java-compiler een standaardconstructor voor die klasse.

Elke keer dat een nieuw object wordt gemaakt, wordt er ten minste één constructor aangeroepen. De hoofdregel van constructors is dat ze dezelfde naam moeten hebben als de klasse. Een klasse kan meer dan één constructor hebben.

Hieronder volgt een voorbeeld van een constructor −

Voorbeeld

public class Puppy {
   public Puppy() {
   }

   public Puppy(String name) {
      // This constructor has one parameter, name.
   }
}

Java ondersteunt ook Singleton Classes waar je maar één instantie van een klasse zou kunnen maken.

Opmerking − We hebben twee verschillende typen constructeurs. We gaan de constructeurs in detail bespreken in de volgende hoofdstukken.

Een object maken

Zoals eerder vermeld, levert een klasse de blauwdrukken voor objecten. Dus eigenlijk wordt een object gemaakt op basis van een klasse. In Java wordt het nieuwe trefwoord gebruikt om nieuwe objecten te maken.

Er zijn drie stappen bij het maken van een object van een klasse −

Verklaring − Een variabeledeclaratie met een variabelenaam met een objecttype.
Instantiëring − Het 'nieuwe' sleutelwoord wordt gebruikt om het object te maken.
Initialisatie − Het trefwoord 'new' wordt gevolgd door een aanroep van een constructor. Deze aanroep initialiseert het nieuwe object.

Hieronder volgt een voorbeeld van het maken van een object −

Voorbeeld

Live demo

public class Puppy {
   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name );
   }

   public static void main(String []args) {
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

Als we het bovenstaande programma compileren en uitvoeren, zal het het volgende resultaat opleveren −

Uitvoer

Passed Name is :tommy

Toegang tot instantievariabelen en -methoden

Instantievariabelen en -methoden zijn toegankelijk via gemaakte objecten. Om toegang te krijgen tot een instantievariabele, volgt het volledig gekwalificeerde pad −

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();

Voorbeeld

In dit voorbeeld wordt uitgelegd hoe u toegang krijgt tot instantievariabelen en methoden van een klasse.

Live demo

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // This constructor has one 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) {
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy's age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy's age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

Als we het bovenstaande programma compileren en uitvoeren, zal het het volgende resultaat opleveren −

Uitvoer

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

Regels voor declaratie van bronbestanden

Laten we als laatste deel van deze sectie eens kijken naar de regels voor het declareren van bronbestanden. Deze regels zijn essentieel bij het declareren van klassen, import verklaringen en pakket verklaringen in een bronbestand.

Er kan slechts één openbare klasse per bronbestand zijn.
Een bronbestand kan meerdere niet-openbare klassen hebben.
De naam van de openbare klasse moet ook de naam zijn van het bronbestand, dat moet worden toegevoegd door .java aan het einde. Bijvoorbeeld:de klasnaam is openbare klaswerknemer{} dan zou het bronbestand moeten zijn als Employee.java.
Als de klasse binnen een pakket is gedefinieerd, moet de pakketverklaring de eerste instructie in het bronbestand zijn.
Als er importverklaringen aanwezig zijn, dan moeten deze tussen de pakketverklaring en de klassenverklaring worden geschreven. Als er geen pakketinstructies zijn, dan zou de importinstructie de eerste regel in het bronbestand moeten zijn.
Import- en pakketinstructies zijn van toepassing op alle klassen die aanwezig zijn in het bronbestand. Het is niet mogelijk om verschillende import- en/of pakketinstructies voor verschillende klassen in het bronbestand te declareren.

Klassen hebben verschillende toegangsniveaus en er zijn verschillende soorten klassen; abstracte klassen, eindklassen, enz. We zullen dit allemaal uitleggen in het hoofdstuk toegangsmodifiers.

Afgezien van de bovengenoemde soorten klassen, heeft Java ook enkele speciale klassen, genaamd Inner klassen en Anonieme klassen.

Java-pakket

In eenvoudige bewoordingen is het een manier om de klassen en interfaces te categoriseren. Bij het ontwikkelen van applicaties in Java zullen honderden klassen en interfaces worden geschreven, daarom is het categoriseren van deze klassen een must en wordt het leven veel gemakkelijker.

Invoerverklaringen

Als in Java een volledig gekwalificeerde naam wordt gegeven, die het pakket en de klassenaam omvat, kan de compiler gemakkelijk de broncode of klassen vinden. Het importstatement is een manier om de compiler de juiste locatie te geven om die bepaalde klasse te vinden.

De volgende regel zou bijvoorbeeld de compiler vragen om alle klassen te laden die beschikbaar zijn in de directory java_installation/java/io −

import java.io.*;

Een eenvoudige casestudy

Voor onze case study zullen we twee klassen maken. Ze zijn Werknemer en WerknemerTest.

Open eerst Kladblok en voeg de volgende code toe. Onthoud dat dit de klasse Werknemer is en dat de klasse een openbare klasse is. Sla dit bronbestand nu op met de naam Employee.java.

De klasse Werknemer heeft vier instantievariabelen:naam, leeftijd, functie en salaris. De klasse heeft één expliciet gedefinieerde constructor, die een parameter nodig heeft.

Voorbeeld

import java.io.*;
public class Employee {

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

   // This is the constructor of the class Employee
   public Employee(String name) {
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

Zoals eerder vermeld in deze tutorial, begint de verwerking vanaf de hoofdmethode. Daarom moet er een hoofdmethode zijn en objecten moeten worden gemaakt om deze Employee-klasse uit te voeren. We zullen een aparte klas maken voor deze taken.

Hieronder volgt de EmployeeTest class, die twee instanties van de klasse Employee maakt en de methoden voor elk object aanroept om waarden voor elke variabele toe te wijzen.

Sla de volgende code op in het bestand EmployeeTest.java.

import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      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();
   }
}

Compileer nu beide klassen en voer vervolgens EmployeeTest . uit om het resultaat als volgt te zien −

Uitvoer

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

Wat is de volgende stap?

In de volgende sessie bespreken we de basisgegevenstypen in Java en hoe deze kunnen worden gebruikt bij het ontwikkelen van Java-applicaties.

Java - Basissyntaxis Java - Constructeurs

Java