Objekt i Java

1. Objekt

Allt i Java är ett objekt.

Mer exakt är det väldigt få saker i Java som inte är objekt. Till exempel primitiva typer. Men detta är ett ganska sällsynt undantag från regeln.

Så vad är ett föremål?

Ett objekt är en enhet som grupperar data tillsammans med metoder som bearbetar data . När vi säger "data" menar vi naturligtvis variabler.

Ett objekts variabler kallas dess "data" eller "tillstånd".

Ett objekts metoder sägs vara dess "beteende". Det är vanligt att ändra ett objekts tillstånd (variabler) endast med hjälp av det objektets metoder. Att ändra ett objekts variabler direkt (inte använda dess metoder) anses vara dålig form.

Varje objekt , såväl som varje variabel, har en typ . Denna typ bestäms en gång när objektet skapas och kan inte ändras i framtiden. Ett objekts typ är dess klass.

Varje objekt har sin egen kopia av instansvariabler (fält). Om en icke-statisk int en variabel deklareras i en klass, och ditt program skapar 10 objekt av den klassen, kommer varje objekt att ha sin egen int en variabel.

Interagera med ett objekt

Det bekvämaste sättet att arbeta med ett objekt är att lagra en referens till det i en variabel och sedan anropa metoder för den variabeln. Detta kommer att se bekant ut för dig:

variable.method()

Var variableär en variabel som lagrar en referens till ett objekt och methodär en metod för den klassen.

Om du vill referera till ett fält (variabel) för ett objekt, måste du också använda punktoperatorn :

variable.field

Var variableär en variabel som lagrar en referens till ett objekt och fieldär en instansvariabel (fält).

2. newoperatör

För att skapa ett objekt av en viss klass måste du använda newoperatorn. I allmänhet, så här ser det ut att skapa ett objekt:

Class variable = new Class(arguments);

Var Classär namnet på klassen för variablevariabeln samt namnet på klassen för objektet som ska skapas. Och variable är en variabel som lagrar en referens till det skapade objektet. Och argumentsär en platshållare för en kommaavgränsad lista med argument som skickas till konstruktorn.

Den specifika listan med argument som kan godkännas bestäms av programmerarna som skriver klassen.

Du har skapat objekt förut och till och med använt denna speciella konstruktion. Du har inte glömt, hoppas jag?

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

Scanner console— detta skapar en consolevariabel vars typ är Scanner. — detta skapar ett nytt objekt. Och tilldelningsoperatorn sätter variabeln lika med en referens till det nyskapade objektet.new Scanner(System.in)Scannerconsole

På den andra raden anropar vi nextInt()metoden på Scannerobjektet, med hjälp av consolevariabeln, som lagrar en referens till objektet Scanner.

Exempel på objektskapande:

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

De skapade objekten kallas objekt i klassen eller instanser av klassen , medan klassen kallas objektets klass . Till exempel slagrar variabeln en referens till en instans av Stringklassen.

3. Introduktion av klasser

Jag tror att du redan har sett hur mycket bekvämt det är att använda klasser skrivna av andra programmerare. Men hur är det med att skriva egna lektioner?

Hur vet du när och var du behöver din egen klass och hur man gör en?

Programmerare skapar vanligtvis sina egna klasser när de vill ta med en ny enhet i programmet. Låter det förvirrande? Sedan ska jag försöka förklara, men jag ska börja på långt håll.

Grupp av data

För att förenkla lite kan vi säga att ett objekt i Java är ett minnesblock som innehåller de variabler som deklareras i en klass (instansfält). Eller, med andra ord, variabler kombinerade till en grupp.

Låt oss säga att ditt program behöver lagra koordinaterna för 100punkter och behöver en metod för att visa dem på skärmen. Detta kan göras med hjälp av arrayer. Till exempel, så här:

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 skulle vara mycket bekvämare om vi hade en enda typ för att lagra all information om en punkt: x, y, color. Om en sådan typ inte finns i Java kan du skapa den själv.

För att göra detta skriver vi kod för en Pointklass:

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

Nu kan koden ovan skrivas 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);
   }
}

Låt oss nu lägga till en metod till Pointklassen som visar information 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);
   }
}

Nu Solutionser klassen ut så här:

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 gömde skickligt punktens koordinater och färginformation i Pointklassen tillsammans med metoden som visar punktens tillstånd.

Klasser är ett sätt att hantera programkomplexitet. Ett stort program blir mindre komplext när det delas upp i många små klasser.

4. Föränderliga vs oföränderliga objekt

En gång i tiden studerade vi konstanter på Java och kom fram till en slutsats som inte är särskilt tröstande. Konstanter låter dig skydda variabler från att ändras, men de kan inte förhindra ändringar av de objekt som de refererar till.

För att lösa detta problem kom Java med konstanta objekt. Eller, som de oftare kallas, oföränderliga objekt.

Förresten, du känner redan till en sådan klass, vars objekt inte kan ändras: String. Ett Stringobjekt förblir för alltid oförändrat efter att det skapats. Och hur uppnådde Javas skapare detta?

Först Stringär alla variabler i klassen dolda, dvs deklarerade private.

För det andra kan du inte ärva Stringklassen: dess klassdeklaration inkluderar finalmodifieraren.

För det tredje, och det mest intressanta, alla metoder i Stringklassen, som du i teorin skulle förvänta dig att ändra det befintliga objektet, ändrar inte det, utan returnerar istället ett nytt.

Metoden gör till exempel toUpperCase()alla bokstäver i strängen med versaler. Men istället för att ändra objektet som metoden anropas på, returnerar den ett nytt Stringobjekt bestående av versaler:

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

Detta är vad som kommer att finnas i minnet efter exekvering av den här koden:

Så skicka gärna dina strängar till vilken metod som helst: ingen kommer att ändra dem.