Java-konstruktörer (med exempel)

I den här handledningen lär vi oss om Java-konstruktörer, deras typer och hur man använder dem med hjälp av exempel.

Vad är en konstruktör?

En konstruktör i Java liknar en metod som åberopas när ett objekt i klassen skapas.

Till skillnad från Java-metoder har en konstruktör samma namn som klassen och har ingen returtyp. Till exempel,

 klass Test (Test () (// konstruktör organ))

Här Test()är en konstruktör. Den har samma namn som klassen och har ingen returtyp.

Rekommenderad läsning: Varför returnerar konstruktörer inte värden

Exempel 1: Java Constructor

 class Main ( private String name; // constructor Main() ( System.out.println("Constructor Called:"); name = "Programiz"; ) public static void main(String() args) ( // constructor is invoked while // creating an object of the Main class Main obj = new Main(); System.out.println("The name is " + obj.name); ) )

Utgång :

 Constructor Called: Namnet är Programiz

I exemplet ovan har vi skapat en konstruktör med namnet Main(). Inuti konstruktören initialiserar vi värdet på namnvariabeln.

Lägg märke till uttalandet om att skapa ett objekt av huvudklassen.

 Main obj = new Main();

Här, när objektet skapas, Main()anropas konstruktören. Och värdet på namnvariabeln initialiseras.

Därför skriver programmet ut värdet på namnvariablerna som Programiz.

Typer av konstruktör

I Java kan konstruktörer delas in i tre typer:

  1. No-Arg Constructor
  2. Parameteriserad konstruktör
  3. Standardkonstruktör

1. Java No-Arg-konstruktörer

På samma sätt som metoder kan en Java-konstruktör ha eller inte ha några parametrar (argument).

Om en konstruktör inte accepterar några parametrar är den känd som en konstruktör utan argument. Till exempel,

 private Constructor() ( // body of the constructor )

Exempel 2: Java privat no-arg konstruktör

 class Main ( int i; // constructor with no parameter private Main() ( i = 5; System.out.println("Constructor is called"); ) public static void main(String() args) ( // calling the constructor without any parameter Main obj = new Main(); System.out.println("Value of i: " + obj.i); ) )

Utgång :

 Constructor kallas Value of i: 5

I exemplet ovan har vi skapat en konstruktör Main(). Här accepterar konstruktören inga parametrar. Därför är det känt som en konstruktör utan arg.

Lägg märke till att vi har förklarat konstruktören som privat.

När en konstruktör deklareras privatekan den inte nås från utsidan av klassen. Så det är förbjudet att skapa objekt utanför klassen med den privata konstruktören.

Här skapar vi objektet i samma klass. Därför kan programmet komma åt konstruktören. För att lära dig mer, besök Java Implement Private Constructor.

Men om vi vill skapa objekt utanför klassen måste vi deklarera konstruktören som public.

Exempel 3: Java-offentliga konstruktörer utan arg

 class Company ( String name; // public constructor public Company() ( name = "Programiz"; ) ) public class Main ( public static void main(String() args) ( // object is created in another class Company obj = new Company(); System.out.println("Company name = " + obj.name); ) )

Utgång :

 Företagsnamn = Programiz

Rekommenderad läsning: Java Access Modifier

2. Java-parametrerad konstruktör

En Java-konstruktör kan också acceptera en eller flera parametrar. Sådana konstruktörer är kända som parametrerade konstruktörer (konstruktör med parametrar).

Exempel 4: Parameteriserad konstruktör

 class Main ( String languages; // constructor accepting single value Main(String lang) ( languages = lang; System.out.println(languages + " Programming Language"); ) public static void main(String() args) ( // call constructor by passing a single value Main obj1 = new Main("Java"); Main obj2 = new Main("Python"); Main obj3 = new Main("C"); ) )

Utgång :

 Java-programmeringsspråk Python-programmeringsspråk C Programmeringsspråk

I exemplet ovan har vi skapat en konstruktör med namnet Main(). Här tar konstruktören en enda parameter. Lägg märke till uttrycket,

 Main obj1 = new Main("Java");

Här skickar vi det enda värdet till konstruktören. Baserat på argumentet passerat initialiseras språkvariabeln inuti konstruktören.

3. Java-standardkonstruktör

Om vi ​​inte skapar någon konstruktör skapar Java-kompilatorn automatiskt en konstruktion utan arg när programmet körs. Denna konstruktör kallas standardkonstruktör.

Exempel 5: Standardkonstruktör

 class Main ( int a; boolean b; public static void main(String() args) ( // A default constructor is called Main obj = new Main(); System.out.println("Default Value:"); System.out.println("a = " + obj.a); System.out.println("b = " + obj.b); ) )

Utgång :

 a = 0 b = falskt

Här har vi inte skapat några konstruktörer. Därför skapar Java-kompilatorn automatiskt standardkonstruktören.

Standardkonstruktören initialiserar alla oinitialiserade instansvariabler med standardvärden.

Typ Standardvärde
boolean falsk
byte 0
short 0
int 0
long 0L
char u0000
float 0,0f
double 0,0d
object Referens null

I ovanstående program, är variablerna a och b initialiseras med standardvärdet 0 och falserespektive.

The above program is equivalent to:

 class Main ( int a; boolean b; // a private constructor private Main() ( a = 0; b = false; ) public static void main(String() args) ( // call the constructor Main obj = new Main(); System.out.println("Default Value:"); System.out.println("a = " + obj.a); System.out.println("b = " + obj.b); ) )

The output of the program is the same as Example 5.

Important Notes on Java Constructors

  • Constructors are invoked implicitly when you instantiate objects.
  • The two rules for creating a constructor are:
    The name of the constructor should be the same as the class.
    A Java constructor must not have a return type.
  • If a class doesn't have a constructor, the Java compiler automatically creates a default constructor during run-time. The default constructor initializes instance variables with default values. For example, the int variable will be initialized to 0
  • Constructor types:
    No-Arg Constructor - a constructor that does not accept any arguments
    Parameterized constructor - a constructor that accepts arguments
    Default Constructor - a constructor that is automatically created by the Java compiler if it is not explicitly defined.
  • A constructor cannot be abstract or static or final.
  • A constructor can be overloaded but can not be overridden.

Constructors Overloading in Java

Similar to Java method overloading, we can also create two or more constructors with different parameters. This is called constructors overloading.

Example 6: Java Constructor Overloading

 class Main ( String language; // constructor with no parameter Main() ( this.language = "Java"; ) // constructor with a single parameter Main(String language) ( this.language = language; ) public void getName() ( System.out.println("Programming Langauage: " + this.language); ) public static void main(String() args) ( // call constructor with no parameter Main obj1 = new Main(); // call constructor with a single parameter Main obj2 = new Main("Python"); obj1.getName(); obj2.getName(); ) )

Output:

 Programming Language: Java Programming Language: Python

I exemplet ovan har vi två konstruktörer: Main()och Main(String language). Här initialiserar både konstruktören värdet på det variabla språket med olika värden.

Baserat på parametern som skickats under skapandet av objekt anropas olika konstruktörer och olika värden tilldelas.

Det är också möjligt att ringa en konstruktör från en annan konstruktör. För att lära dig mer, besök Java Call One Constructor från en annan.

Obs! Vi har använt thisnyckelord för att specificera variabeln i klassen. Om du vill veta mer om thisnyckelord, besök Java detta nyckelord.

Intressanta artiklar...