Objekter i Java

1. Objekter

Alt i Java er et objekt.

Mer nøyaktig er det svært få ting i Java som ikke er objekter. For eksempel primitive typer. Men dette er et ganske sjeldent unntak fra regelen.

Så hva er en gjenstand?

Et objekt er en enhet som grupperer data sammen med metoder som behandler dataene . Når vi sier «data», mener vi selvfølgelig variabler.

Et objekts variabler kalles dets "data" eller "tilstand".

Et objekts metoder sies å være dets "atferd". Det er vanlig å endre et objekts tilstand (variabler) bare ved å bruke det objektets metoder. Å endre et objekts variabler direkte (ikke ved å bruke dets metoder) anses som dårlig form.

Hvert objekt , så vel som hver variabel, har en type . Denne typen bestemmes én gang når objektet opprettes og kan ikke endres i fremtiden. Et objekts type er dets klasse.

Hvert objekt har sin egen kopi av instansvariabler (felt). Hvis en ikke-statisk int en variabel er deklarert i en klasse, og programmet ditt lager 10 objekter av den klassen, vil hvert objekt ha sin egen int en variabel.

Samhandle med et objekt

Den mest praktiske måten å jobbe med et objekt på er å lagre en referanse til det i en variabel, og deretter kalle metoder på den variabelen. Dette vil se kjent ut for deg:

variable.method()

Hvor variableer en variabel som lagrer en referanse til et objekt, og methoder en metode for den klassen.

Hvis du vil referere til et felt (variabel) av et objekt, må du også bruke punktoperatoren :

variable.field

Hvor variableer en variabel som lagrer en referanse til et objekt, og fielder en forekomstvariabel (felt).

2. newoperatør

For å lage et objekt av en bestemt klasse, må du bruke newoperatoren. Generelt ser du slik det ser ut å lage et objekt:

Class variable = new Class(arguments);

Hvor Classer navnet på klassen til variabelen variablesamt navnet på klassen til objektet som skal opprettes. Og variable er en variabel som lagrer en referanse til det opprettede objektet. Og argumentser en plassholder for en kommadelt liste over argumenter som sendes til konstruktøren.

Den spesifikke listen over argumenter som kan bestås bestemmes av programmererne som skriver klassen.

Du har laget objekter før og til og med brukt denne spesielle konstruksjonen. Du har ikke glemt, håper jeg?

Scanner console = new Scanner(System.in);
int x = console.nextInt();

Scanner console— dette lager en consolevariabel hvis type er Scanner. — dette skaper et nytt objekt. Og tilordningsoperatøren setter variabelen lik en referanse til det nyopprettede objektet.new Scanner(System.in)Scannerconsole

I den andre linjen kaller vi nextInt()metoden på Scannerobjektet, ved å bruke consolevariabelen, som lagrer en referanse til Scannerobjektet.

Eksempler på objektoppretting:

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

De opprettede objektene kalles objekter av klassen eller forekomster av klassen , mens klassen kalles klassen til objektet . For eksempel slagrer variabelen en referanse til en forekomst av Stringklassen.

3. Introdusere klasser

Jeg tror du allerede har sett hvor veldig praktisk det er å bruke klasser skrevet av andre programmerere. Men hva med å skrive dine egne klasser?

Hvordan vet du når og hvor du trenger din egen klasse og hvordan du lager en?

Programmerere lager vanligvis sine egne klasser når de ønsker å ta med en ny enhet inn i programmet. Høres det forvirrende ut? Så skal jeg prøve å forklare, men jeg skal begynne langt unna.

Gruppe av data

For å forenkle litt kan vi si at et objekt i Java er en minneblokk som inneholder variablene som er deklarert i en klasse (forekomstfelt). Eller, med andre ord, variabler kombinert til en gruppe.

La oss si at programmet ditt trenger å lagre koordinatene til 100punktene og trenger en metode for å vise dem på skjermen. Dette kan gjøres ved hjelp av arrays. For eksempel slik:

class Solution
{
   public static void printPoints(int[] x, int[] y, int[] color)
   {
     for (int i = 0; i < x.length; i++)
       System.out.println("Color of (" + x[i] + ", " + y[i] + ") = " + color[i]);
   }

   public static void main(String[] args)
   {
     int[] x = new int[100];
     int[] y = new int[100];
     int[] color = new int[100];
     printPoints(x, y, color);
   }
}

Det ville vært mye mer praktisk om vi hadde én enkelt type for å lagre all informasjon om et punkt: x, y, color. Hvis en slik type ikke finnes i Java, kan du lage den selv.

For å gjøre dette, skriver vi kode for en Pointklasse:

public class Point
{
   public int x;
   public int y;
   public int color;
}

Nå kan koden ovenfor skrives om som:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       System.out.println("Color of (" + points[i].x + ", " + point[i].y + ") = " + points[i].color);
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

La oss nå legge til en metode til Pointklassen som viser informasjon om objektet:

public class Point
{
   public int x;
   public int y;
   public int color;
   public void print()
   {
     System.out.println("Color of (" + x + ", " + y + ") = " + color);
   }
}

Nå Solutionser klassen slik ut:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       points[i].print();
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

Vi gjemte på en dyktig måte punktets koordinater og fargeinformasjon inne i Pointklassen sammen med metoden som viser punktets tilstand.

Klasser er en måte å håndtere programkompleksitet på. Et stort program blir mindre komplekst når det deles opp i mange små klasser.

4. Mulige vs uforanderlige objekter

En gang i tiden studerte vi konstanter i Java og kom til en konklusjon som ikke er særlig trøstende. Konstanter lar deg beskytte variabler fra å bli endret, men de kan ikke forhindre endringer i objektene de refererer til.

For å løse dette problemet kom Java opp med konstante objekter. Eller, som de oftere kalles, uforanderlige objekter.

Forresten, du kjenner allerede en slik klasse, hvis objekter ikke kan endres: String. Et Stringobjekt forblir for alltid uendret etter at det er opprettet. Og hvordan oppnådde Javas skapere dette?

Først er alle variabler i Stringklassen skjult, dvs. deklarert private.

For det andre kan du ikke arve Stringklassen: dens klasseerklæring inkluderer finalmodifikatoren.

For det tredje, og mest interessant, alle metodene i klassen String, som du i teorien forventer å endre det eksisterende objektet, endrer det faktisk ikke, men returnerer i stedet et nytt.

Metoden gjør for eksempel toUpperCase()at alle bokstavene i strengen blir store. Men i stedet for å endre objektet som metoden kalles på, returnerer den et nytt Stringobjekt bestående av store bokstaver:

String text = "This is a very important message";
String message = text.toUpperCase();

Dette er hva som vil være i minnet etter å ha utført denne koden:

Så send gjerne strengene dine til en hvilken som helst metode: ingen vil endre dem.