Instans av och arv i Java

Hej! I tidigare lektioner har vi redan kort bekantat oss med begreppet arv. Idag kommer vi att beröra detta ämne igen, men återigen inte alltför djupt. Vi kommer fortfarande att ha en mer detaljerad lektion om detta i framtiden. Idag ska vi bara ta en snabb titt på några praktiska exempel och bekanta oss med en intressant operatör i Java.

Arv

Så, vad är arv? Arv är en programmeringsmekanism (inklusive i Java) som låter dig deklarera en ny klass baserat på en befintlig. Den härledda klassen får sedan tillgång till fälten och metoderna för den överordnade klassen. Varför skulle vi behöva detta? Tja, föreställ dig att du behöver skapa flera bilklasser i ett program: Lastbil, RaceCar, Sedan, Pickup, etc. Redan innan du skriver någon kod vet du säkert att alla dessa klasser har mycket gemensamt: alla bilar har en modell namn, tillverkningsår, motorstorlek, maxvarv etc. (för att inte tala om att de alla har hjul och andra delar gemensamt). I den här situationen kan du:

• Skapa dessa fält i varje klass (lägg till dem i varje ny bilklass när du skapar den)
• Ta med de fält som är gemensamma för alla bilar i en Caröverordnad klass och använd sedan nyckelordet extends för att härleda alla klasser för specifika typer av bilar från Carklassen.

Naturligtvis är det andra alternativet mycket bekvämare:

public class Car {

   private String model;
   private int maxSpeed;
   private int yearOfManufacture;

   public Car(String model, int maxSpeed, int yearOfManufacture) {
       this.model = model;
       this.maxSpeed = maxSpeed;
       this.yearOfManufacture = yearOfManufacture;
   }
}

public class Truck extends Car {

   public Truck(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

public class Sedan extends Car {
   public Sedan(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

Som ett minimum undviker vi onödig dubblering av kod (och det ska vi alltid sträva efter när vi skriver program). Dessutom har vi en enkel och begriplig klassstruktur, med alla fält som är gemensamma för alla bilar samlade i en klass. Om lastbilar har några specialfält som andra bilar inte har kan de deklareras i klassen Truck. Detsamma gäller metoder. Alla bilar har ett visst gemensamt beteende som kan beskrivas med metoder, t.ex. starta bilen, accelerera/bromsa, etc. Dessa vanliga metoder kan konsolideras i moderklassen, Caroch varje specifik biltyp kan definiera sina unika handlingar i sina härledda klasser .

public class Car {

   public void gas() {
       // Accelerate
   }

   public void brake() {
       // Brake
   }
}


public class F1Car extends Car {

   public void pitStop() {
      
       // Only race cars make pit stops
   }

   public static void main(String[] args) {
      
       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

Vi lade till de metoder som är gemensamma för alla bilar i Carklassen. Men titta på F1Carklassen, som representerar "Formel 1" racerbilar. Depåstopp (stopp för brådskande bilunderhåll) görs endast i tävlingar, så vi har lagt till denna specifika funktionalitet till den relevanta härledda klassen.

instans av operatör

I Java finns det en speciell operator, instansof , för att kontrollera om ett objekt skapades baserat på en viss klass. Det returnerar sant eller falskt beroende på resultatet av kontrollen. Låt oss se hur det fungerar med klasserna i vårt bilexempel:

public class Truck extends Car {

   public static void main(String[] args) {

       Truck truck = new Truck();
       System.out.println(truck instanceof Car);
   }
}

Output: true Operatören instanceofreturnerar true eftersom vi har ett Truckobjekt och alla lastbilar är bilar. Klassen Truckkommer från Carklassen. Alla lastbilar skapas utifrån den gemensamma föräldern, Carklassen. Titta noga på hur instanceofoperatören används. Du skriver det utan punkt, eftersom det är en operator, inte en metod ("objektinstans av klass"). Låt oss försöka på ett annat sätt:

public static void main(String[] args) {

   Car car = new Car();
   System.out.println(car instanceof Truck);
}

Output: false Klassen Car(och bilobjekt) härrör inte från Truckklassen. Alla lastbilar är bilar, men alla bilar är inte lastbilar. Carobjekt är inte baserade på Truckklassen. Ytterligare ett exempel:

public static void main(String[] args) {

   Car car = new Car();
   Truck truck = new Truck();
   System.out.println(car instanceof Object && truck instanceof Object);
}

Utdata: Sant Även här är logiken enkel: alla klasser i Java, inklusive klasser du skapar, härstammar från klassen Object(även om du inte skriver "extends Object" - det är redan underförstått). Hur och när skulle detta vara användbart? Operatören instanceofanvänds oftast när equals()metoden åsidosätts. Så här equalsimplementeras till exempel metoden i Stringklassen:

public boolean equals(Object anObject) {
   if (this == anObject) {
       return true;
   }
   if (anObject instanceof String) {
       String anotherString = (String) anObject;
       int n = value.length;
       if (n == anotherString.value.length) {
           char v1[] = value;
           char v2[] = anotherString.value;
           int i = 0;
           while (n-- != 0) {
               if (v1[i] != v2[i])
                       return false;
               i++;
           }
           return true;
       }
   }
   return false;
}

Innan man jämför a Stringmed det godkända objektet, testar metoden för att se om objektet ens är en sträng? Först då börjar den jämföra de två objektens egenskaper. Om det här testet inte fanns kunde vilket objekt som helst med värde- och längdfält skickas till metoden och jämföras med en sträng, vilket naturligtvis skulle vara fel.