En abstrakt klass i Java är en klass som inte kan instansieras direkt. Målet med detta är att fungera som en basklass från vilken de andra klasserna kan ärvas och förlängas. En av de viktiga egenskaperna hos en abstrakt klass har en förmåga att definiera konstruktörerna, som är kända som specialmetoder och som anropas när ett objekt i en klass skapas.

Regler som ska följas när du definierar konstruktörer i en abstrakt klass:

1. Abstrakta klasser kan ha konstruktörer, men de kan inte instansieras direkt. Konstruktörerna används när en konkret underklass skapas.
2. Det kan finnas en eller flera abstrakta metoder i en abstrakt klass, vilket betyder att dessa metoder inte implementeras med hjälp av klassen. För att instansieras bör en underklass som utökar en abstrakt klass med abstrakta metoder implementera metoderna. Det betyder att varje abstrakt metod som deklareras inom en abstrakt klass måste ha en implementering om en underklass behöver vara en konkret klass och kunna instansieras. Funktionaliteten som abstraktklassen lämnade öppen måste med andra ord fyllas i av underklassen.
3. När en underklass utökar en abstrakt klass med konstruktörer, måste underklassen anropa en av konstruktörerna i superklassen med hjälp av supernyckelord. Eftersom superklasskonstruktören initierar objektets tillstånd och förenar alla viktiga resurser. Om subklassen nu inte anropar någon av konstruktörerna i superklassen kommer objektet inte att vara väl initierat och kommer nu inte att fungera effektivt/korrekt.
4. Det är möjligt att definiera mer än en konstruktor i en abstrakt klass, liknande någon annan klass. Varje konstruktor måste dock definieras med en annan parameterlista. Det släpper in underklasser för att välja ut vilken konstruktör som ska anropas baserat på deras specifika behov.

Typer av konstruktörer implementerade med abstrakt klass:

Det finns tre typer av konstruktörer där de finns:

1. Standardkonstruktör
2. Parameteriserad konstruktör
3. Kopiera konstruktör

1. Standardkonstruktör: Konstruktorn skapas automatiskt via Java om ingen annan konstruktor är definierad i klassen. Den har inga parametrar och utför inga rörelser förutom att initiera standardvärden för klassfält.

ALGORITM:

Steg 1: Definiera en abstrakt klass som heter 'Shape'.

Steg 2: Deklarera två heltalsvariabler 'x' och 'y' som skyddade.

Steg 3: Skapa en standardkonstruktor för Shape-klassen och ställ in 'x' och 'y' till 0.

Steg 4: Skapa nu en metod 'getArea()' det är en abstrakt metod som kommer att returnera ett dubbelt värde

Steg 5: Skapa sedan två icke-abstrakta metoder 'printPosition()' och 'setPosition(int x, int y)' som tillhör Shape-klassen.

Steg 6: Metoden setPosition ställer in värdena för x och y.

Steg 7: Metoden printPosition skriver ut värdena för x och y.

Steg 8: Definiera en Circle-klass som utökar Shape-klassen.

Steg 9: Deklarera en dubbelvariabel med namnet 'radius' som skyddad i Circle-klassen.

Steg 10: Definiera en konstruktor för Circle-klassen som accepterar ett dubbelt värde för radien.

Steg 11: Implementera getArea-metoden för Circle-klassen som beräknar arean av cirkeln.

Steg 12: Definiera en Square-klass som utökar Shape-klassen.

Steg 13: Deklarera en dubbelvariabel med namnet 'side' som skyddad i Square-klassen.

Steg 14: Definiera en konstruktor för klassen Square som accepterar ett dubbelt värde för sidan.

Steg 15: Implementera getArea-metoden för Square-klassen som beräknar kvadratens area.

Steg 16: Definiera en huvudklass.

Steg 17: Definiera huvudfunktionen i klassen Main.

Steg 18: Skapa ett Circle-objekt och ett Square-objekt.

Steg 19: Anropa setPosition-metoden för både Circle- och Square-objekten.

Steg 20: Anropa getArea-metoden för både Circle- och Square-objekten och skriv ut resultaten.

Steg 21: Anropa metoden printPosition för både Circle- och Square-objekten och skriv ut resultaten.

Genomförande:

Här är implementeringen av ovanstående steg

Filnamn: DefaultMain.java

 import java.util.*; abstract class Shape { protected int x; protected int y; // default constructor public Shape() { // initialize default values for fields x = 0; y = 0; } // abstract method to calculate area public abstract double getArea(); // other methods public void setPosition(int x,int y) { this.x=x; this.y=y; } public void printPosition() { System.out.println('The Position: ('+x + ', '+ y +')'); } } class Circle extends Shape { protected double radius; // constructor public Circle(double radius) { this.radius=radius; } // implementation of getArea() for Circle public double getArea() { return Math.PI * radius * radius; } } class Square extends Shape { protected double side; // constructor public Square(double side) { this.side = side; } // implementation of getArea() for Square public double getArea() { return side * side; } } public class DefaultMain { public static void main(String args []) { // create a Circle object Circle circle = new Circle(5); circle.setPosition(2,3); // print the area and position of the Circle object System.out.println('Area of a circle is: '+circle.getArea()); circle.printPosition(); // create a Square object Square square = new Square(4); square.setPosition(5, 7); // print the area and position of the Square object System.out.println('Area of a square is: '+square.getArea()); square.printPosition(); } } 

Produktion:

 Area of a circle is: 78.53981633974483 The Position:(2, 3) Area of a square is: 16.0 The Position:(5, 7) 

2. Parameteriserad konstruktör: När du skapar ett objekt låter den här typen av konstruktorer dig skicka argument till det. När du vill initiera objektet med värden är det till hjälp. Den parameteriserade konstruktorn definieras med en eller extra parametrar, och medan ett objekt skapas används värdena som skickas till konstruktorn för att initiera motsvarande fält för objektet.

ALGORITM:

Steg 1: Definiera en abstrakt klass Shape.

Steg 2: Lägg till två skyddade instansvariabler av typen int med namnet x och y.

Steg 3: Skapa en parametriserad konstruktor som initierar instansvariablerna x och y och accepterar två parametrar av typen int, x och y.

Steg 4: Definiera en abstrakt klass Shape.

Steg 5: Lägg till två skyddade instansvariabler av typen int med namnet x och y.

Steg 6: Skapa en parametriserad konstruktor som initierar instansvariablerna x och y och accepterar två parametrar av typen int, x och y.

Steg 7: Definiera en klass Cirkel som utökar Shape.

Steg 8: Lägg till en skyddad instansvariabel av typen dubbelnamnad radie.

Steg 9: Definiera en parametriserad konstruktor som tar tre parametrar av typen int x, y och dubbelradie och initierar instansvariablerna x, y och radius med hjälp av nyckelordet super().

Steg 10: Implementera den abstrakta metoden getArea() genom att beräkna arean av Circle.

Steg 11: Definiera en klass Square som utökar Shape.

css wrap text

Steg 12: Lägg till en skyddad instansvariabel av typen dubbelnamnad sida.

Steg 13: Definiera en parametriserad konstruktor som tar tre parametrar av typen int x, y och dubbelsidig och initierar x-, y- och sidoinstansvariablerna med hjälp av nyckelordet super().

Steg 14: Implementera den abstrakta metoden getArea() genom att beräkna arean av Square.

Steg 15: Definiera en klass Main.

Steg 16: Definiera en statisk metod med namnet main() som är ingångspunkten för programmet.

Steg 17: Skapa ett Circle-objekt med hjälp av parametriserad konstruktor.

Steg 18: Skriv ut området och positionen för Circle-objektet med metoderna getArea() respektive printPosition().

Steg 19: Skapa ett kvadratiskt objekt med hjälp av parametriserad konstruktor.

Steg 20: Skriv ut arean och positionen för Square-objektet med metoderna getArea() respektive printPosition().

Steg 21: Slutet på programmet.

Genomförande:

Implementeringen av ovanstående steg som nämns nedan

Filnamn: ParameterizedMain.java

 import java.util.*; abstract class Shape { protected int x; protected int y; // parameterized constructor public Shape(int x,int y) { this.x=x; this.y=y; } // abstract method to calculate area public abstract double getArea(); // other methods public void setPosition(int x,int y) { this.x=x; this.y=y; } public void printPosition() { System.out.println('The position: ('+ x+', ' +y+')'); } } class Circle extends Shape { protected double radius; // parameterized constructor public Circle(int x,int y,double radius) { super(x,y); this.radius=radius; } // implementation of getArea() for Circle public double getArea() { return Math.PI * radius * radius; } } class Square extends Shape { protected double side; // parameterized constructor public Square(int x,int y,double side) { super(x, y); this.side = side; } // implementation of getArea() for Square public double getArea() { return side * side; } } public class ParameterizedMain { public static void main(String args []) { // create a Circle object with parameterized constructor Circle circle = new Circle(2, 3, 5); // print the area and position of the Circle object System.out.println('Area of circle is: '+circle.getArea()); circle.printPosition(); // create a Square object with parameterized constructor Square square = new Square(5, 7, 4); // print the area and position of the Square object System.out.println('Area of square is:' +square.getArea()); square.printPosition(); } } 

Produktion:

 Area of circle is: 78.53981633974483 The position: (2, 3) Area of square is:16.0 The position: (5, 7) 

3. Kopiera konstruktör: copy constructor används för att skapa ett nytt objekt med samma värden som ett befintligt objekt (dvs objektet skapas tidigare än). Det är användbart medan vi behöver skapa ett nytt objekt som kan vara en replika av ett objekt som redan finns/existerar. Kopieringskonstruktorn definieras med endast ett argument eller en parameter som är ett objekt av identisk klass. Sedan skapar konstruktorn ett nytt objekt med samma värden som ett parameterobjekt.

ALGORITM:

Steg 1: Deklarera en abstrakt klass med instansvariabler och standardkonstruktor.

Steg 2: Definiera en kopieringskonstruktor med en parameter av identisk klasstyp.

Steg 3: I copy constructor, anropa superklassen copy constructor med hjälp av supernyckelordet för att kopiera instansvariablerna från parameterobjektet till det nya objektet.

Steg 4: Tilldela värdena för eventuella extra instansvariabler inom underklassen till det nya objektet.

Steg 5: Implementera den abstrakta metoden för att beräkna arean.

Steg 6: Definiera eventuella andra metoder efter behov.

Steg 7: Skapa ett objekt i klassen i huvudfunktionen.

Steg 8: Ställ in positionen och eventuella andra instansvariabler efter behov.

Steg 9: Skapa ett nytt objekt med hjälp av kopieringskonstruktorn och skicka det ursprungliga objektet som en parameter.

Steg 10: Skriv ut området och positionen för både original och kopierade objekt.

Genomförande:

Implementeringen av ovanstående steg ges nedan

Filnamn: CopyMain.java

 import java.util.*; abstract class Shape { protected int x; protected int y; // copy constructor public Shape(Shape other) { this.x=other.x; this.y=other.y; } // default constructor public Shape() { // initialize default values for fields x=0; y=0; } // abstract method to calculate area public abstract double getArea(); // other methods public void setPosition(int x,int y) { this.x =x; this.y =y; } public void printPosition() { System.out.println('Position: (' +x+ ', ' +y+ ')'); } } class Circle extends Shape { protected double radius; // copy constructor public Circle(Circle other) { super(other); this.radius =other.radius; } // constructor public Circle(double radius) { this.radius =radius; } // implementation of getArea() for Circle public double getArea() { return Math.PI * radius * radius; } } class Square extends Shape { protected double side; // copy constructor public Square(Square other) { super(other); this.side =other.side; } // constructor public Square(double side) { this.side=side; } // implementation of getArea() for Square public double getArea() { return side * side; } } public class CopyMain { public static void main(String[] args) { // create a Circle object Circle circle1 = new Circle(5); circle1.setPosition(2,3); // create a copy of the Circle object using the copy constructor Circle circle2 = new Circle(circle1); // print the area and position of the original and copied Circle objects System.out.println('Original Area of circle: ' +circle1.getArea()); circle1.printPosition(); System.out.println('Copied Area of circle: '+circle2.getArea()); circle2.printPosition(); // create a Square object Square square1 =new Square(4); square1.setPosition(5,7); // create a copy of the Square object using the copy constructor Square square2 = new Square(square1); // print the area and position of the original and copied Square objects System.out.println('Original Area of square: '+square1.getArea()); square1.printPosition(); System.out.println('Copied Area of square: '+square2.getArea()); square2.printPosition(); } } 

Produktion:

 Original Area of circle: 78.53981633974483 Position: (2, 3) Copied Area of circle: 78.53981633974483 Position: (2, 3) Original Area of square: 16.0 Position: (5, 7) Copied Area of square: 16.0 Position: (5, 7)