java constructor class
W tym samouczku omówimy program Java Constructor, jego typy i koncepcje, takie jak przeciążanie konstruktorów i tworzenie łańcuchów konstruktorów z przykładami kodu:
Z naszych wcześniejszych samouczków wiemy, że instancja klasy nazywa się obiektem. Obiekt klasy tworzony jest za pomocą słowa kluczowego „new”. Specjalna metoda zwana „konstruktorem” jest wywoływana, gdy tworzymy obiekt z nowym słowem kluczowym lub gdy tworzony jest obiekt.
Konstruktor jest definiowany jako blok kodu służący do inicjalizacji obiektu klasy. Jest identyczna z metodą, ale nie jest metodą. Jednak w Javie można to określić jako „metodę specjalną”.
=> Zajrzyj tutaj, aby zobaczyć A-Z samouczków szkoleniowych Java tutaj.
jak uruchamiać pliki .torrent
Czego się nauczysz:
- Konstruktor Java
- Wniosek
Konstruktor Java
Konstruktor Java służy do inicjowania właśnie utworzonego obiektu. Obiekt musi mieć pewne dane, zanim zostanie użyty w programie. Dlatego używamy konstruktora, abyśmy mogli przypisać pewne dane początkowe do obiektu.
Jako prosty przykład rozważmy klasę ABC, dla której musimy utworzyć obiekt. Utwórzmy obiekt „myObj” dla klasy ABC za pomocą nowego słowa kluczowego.
ABC myObj = new ABC ();Powyższa instrukcja tworzy obiekt myObj. Podczas tworzenia tego obiektu wywoływany jest konstruktor klasy ABC bez argumentów (ABC () pokazuje, że nie ma argumentów dla konstruktora). Ponieważ nie ma żadnych argumentów dla powyższego konstruktora, pola składowe myObj zostaną zainicjowane do ich domyślnych wartości początkowych.
Na przykład,
- Liczbowe typy danych, takie jak int, są ustawione na 0.
- Wartość zmiennej typu danych Char jest ustawiona na znak null („ 0”).
- Referencje są ustawione na null.
W tym samouczku omówimy szczegółowo konstruktory wraz z różnymi konstruktorami używanymi w Javie.
Jak stworzyć konstruktor w Javie
Aby stworzyć konstruktor w Javie, musimy przestrzegać pewnych zasad, jak podano poniżej.
- Konstruktor klasy ma taką samą nazwę jak nazwa klasy.
- Nie może istnieć konstruktor ostateczny, abstrakcyjny, zsynchronizowany ani statyczny. Dzieje się tak, ponieważ Finał działa jako stała, abstrakcyjna nie może zostać utworzona. While synchronized jest używany w przypadku wielowątkowości, a słowo kluczowe static jest używane na poziomie klasy.
- W konstruktorach możemy używać modyfikatorów dostępu.
- Konstruktor nie może mieć typu zwracanego.
Na przykład,zdefiniujmy klasę Ucznia w następujący sposób:
class Student{ String name; int roll_no; } Możemy tworzyć obiekty powyższej klasy używając słowa kluczowego new. Podczas tworzenia obiektu możemy zainicjować zmienne dwuelementowe tej klasy, udostępniając konstruktor. Zauważ, że nawet jeśli nie udostępnimy konstruktora i po prostu wykonamy poniższą instrukcję,
Student student = nowy student ();
Mimo to Java wykona domyślny konstruktor, który zainicjuje zmienne dwuelementowe zgodnie z ich domyślnymi ustawieniami systemowymi. Teraz, jeśli chcemy, aby początkowa wartość Student.name to „Keith”, a roll_no wynosiła 27, to w tym celu możemy utworzyć następującą metodę konstruktora.
Student () { name = 'Keith'; roll_no = 27; } Kiedy tworzymy obiekt klasy studenckiej z poniższym stwierdzeniem
Student student = new Student ();Wtedy początkowe wartości zmiennych składowych name i roll_no będą wynosić odpowiednio Keith i 27.
Po utworzeniu konstruktora, kiedy zostanie wywołany?
Konstruktor jest wywoływany za każdym razem, gdy obiekt jest tworzony za pomocą słowa kluczowego new, jak w powyższym przypadku. Jak już wspomniano, jeśli nie podano konstruktora, Java udostępnia domyślny konstruktor, który jest wywoływany podczas tworzenia obiektu przy użyciu słowa kluczowego new.
Przykład konstruktora
Poniższy program przedstawia przykład konstruktora, w którym mamy prosty konstruktor bez żadnych argumentów. Ten konstruktor po prostu przypisuje wartości początkowe do swoich zmiennych składowych.
//class definition class classDemo{ int num1; int num2; //constructor classDemo(){ num1 = 100; num2 = 250; System.out.println('Inside ClassDemo::Constructor'); } public void display(){ System.out.println('num1 = '+ num1); System.out.println('num2 = '+ num2); } } class Main{ public static void main(String args[]){ classDemo cd1 = new classDemo(); //create object of ClassDemo cd1.display(); } }Wynik:
Domyślny konstruktor w Javie
Konstruktor domyślny jest również nazywany konstruktorem pustym . Ten konstruktor jest wstawiany przez kompilator języka Java do kodu klasy, w którym nie ma konstruktora zaimplementowanego przez programistę. Konstruktor domyślny jest wstawiany podczas kompilacji i dlatego pojawi się tylko w pliku „.class”, a nie w kodzie źródłowym.
Rozważmy następującą klasę Java.
plik źródłowy (.java) plik klasy (.class)
Na powyższym rysunku pierwszy rysunek przedstawia kod źródłowy, w którym nie określono żadnego konstruktora. Kiedy więc kompilujemy ten kod i generowany jest plik .class, widzimy, że kompilator Java wstawił domyślny konstruktor, jak pokazano na sąsiednim rysunku (w kolorze niebieskim).
Uwaga:
Czasami do opisu konstruktora bezargumentowego w Javie używany jest domyślny konstruktor. Ale te dwa terminy są w rzeczywistości różne. Konstruktor bezargumentowy to typ konstruktora w Javie określony przez programistę. Konstruktorem domyślnym jest konstruktor wstawiany przez kompilator języka Java.
Dlatego chociaż te dwa terminy są używane zamiennie przez większość programistów, zaleca się, aby ich nie mylić.
Gdy Java wstawia domyślny konstruktor, jeśli program ma jakieś zmienne, wówczas przypisywane są im wartości domyślne.
Poniższa tabela przedstawia domyślne wartości każdego typu danych.
| Rodzaj | Domyślna wartość |
|---|---|
| Obiekt | Odniesienie zerowe |
| boolean | fałszywy |
| bajt | 0 |
| krótki | 0 |
| int | 0 |
| długo | 0L |
| zwęglać | u0000 |
| pływak | 0.0f |
| podwójnie | 0.0d |
Poniższy program przedstawia przykład domyślnego konstruktora w Javie.
class Main { int num; boolean flag; public static void main(String[] args) { // A default constructor is called Main obj = new Main(); System.out.println('num:default value = ' + obj.num); System.out.println('flag:default value = ' + obj.flag); } }Wynik:
Typy konstruktorów w Javie
W Javie istnieją dwa typy konstruktorów, jak pokazano poniżej.
# 1) Konstruktor bezargumentowy
Konstruktor bez żadnych argumentów jest nazywany konstruktorem bez argumentów lub bez argumentów. Jeśli nie mamy konstruktora bez żadnych argumentów, to kompilator Java nie tworzy domyślnego konstruktora dla klasy.
Ogólnie rzecz biorąc, jeśli zdefiniujemy konstruktor w naszej klasie, to konstruktor domyślny nie zostanie wstawiony przez kompilator Javy.
Poniżej podano przykład konstruktora bezargumentowego
import java.io.*; class DemoClass { int num; String name; // no-args Constructor called when object is created DemoClass() { System.out.println('DemoClass::Constructor called'); System.out.println('Initial member variable values:'); System.out.println('num = ' + num + ' name = ' + name); } } class Main{ public static void main (String[] args) { // this will invoke no-args Constructor DemoClass dc1 = new DemoClass(); } } Wynik:
W tym programie udostępniliśmy konstruktor bez argumentów. Tutaj drukujemy komunikaty zawierające zmienne składowe. Na wyjściu widzimy, że wyświetlane są komunikaty z konstruktora wskazujące, że konstruktor no-args jest wykonywany.
# 2) Sparametryzowany konstruktor
Konstruktor sparametryzowany ma co najmniej jeden parametr. Możemy użyć sparametryzowanego konstruktora w przypadku, gdy musimy przekazać pewne wartości początkowe do zmiennej składowej klasy.
import java.io.*; class DemoClass { // data members of the class. String name; int id; // parameterized constructor called when object is created DemoClass(String name, int id) { this.name = name; this.id = id; } } class Main { public static void main (String[] args) { // this will invoke the parameterized constructor. DemoClass dc1 = new DemoClass('Java', 1); System.out.println('Tutorial Name :' + dc1.name + ', Id :' + dc1.id); } } Wynik:
Tutaj udostępniliśmy sparametryzowany konstruktor, który przyjmuje dwa argumenty, tj. Nazwę i identyfikator.
W treści konstruktora argumenty są przypisywane jako wartości odpowiednio do zmiennych składowych name i id.
Następnie w metodzie main, kiedy tworzymy nowy obiekt za pomocą słowa kluczowego new, przekazujemy dwie wartości do nazwy klasy po nowym słowie kluczowym. Oznacza to, że wywołujemy sparametryzowany konstruktor. Kiedy wyświetlamy zmienne składowe, widzimy, że mają one wartości, które przekazaliśmy podczas tworzenia obiektu.
Przeciążone konstruktory w Javie
Teraz pojawia się pytanie, czy klasa może mieć więcej niż jeden konstruktor, czy też klasa może mieć tylko jednego konstruktora?
Cóż, możemy mieć wiele konstruktorów w jednej klasie. Klasa może mieć dowolną liczbę konstruktorów, o ile są one odpowiednio przeciążone.
Więc co dokładnie oznacza Przeciążenie konstruktorów?
Przeciążanie konstruktorów to mechanizm, który pozwala klasie mieć tyle konstruktorów, aby wszystkie te konstruktory miały różne listy parametrów, niezależnie od typów parametrów lub kolejności parametrów.
Poniższy program demonstruje przeciążenie konstruktora.
//class with multiple constructors class DemoClass{ int val1; int val2; //no args Constructor DemoClass(){ val1 = 10; val2 = 20; System.out.println('DemoClass:: No argument Constructor'); } //Overloaded Constructor DemoClass(int num1){ val1 = num1; val2 = num1; System.out.println('DemoClass:: Overloaded Constructor with one argument'); } //Overloaded DemoClass(int num1,int num2){ val1 = num1; val2 = num2; System.out.println('DemoClass:: Overloaded Constructor with two arguments'); } public void display(){ System.out.println('val1 === '+val1 + ' ; val2 === '+val2 ); } } class Main{ public static void main(String args[]){ DemoClass d1 = new DemoClass(); //object with no-args Constructor d1.display(); DemoClass d2 = new DemoClass(10); //object with 1 arg Constructor d2.display(); DemoClass d3 = new DemoClass(20,40); //object with 2 arg Constructor d3.display(); } }Wynik:
W powyższym programie mamy klasę zawierającą trzy konstruktory. Pierwszy konstruktor jest konstruktorem bez argumentów, a następnie mamy po jednym, każdy z odpowiednio jednym argumentem i dwoma argumentami. Ponieważ konstruktor ma unikalną listę parametrów, możemy powiedzieć, że konstruktory są przeciążone.
Konstruktor „this ()” w języku Java
A co jeśli w klasie zawierającej wiele konstruktorów chcemy wywołać jeden konstruktor z innego konstruktora w tej klasie?
W tym celu używamy słowa kluczowego „this” wewnątrz konstruktora, z którego chcemy wywołać inny konstruktor.
Tak więc, gdy klasa ma wiele konstruktorów, konstruktor bezargumentowy i konstruktor sparametryzowany, używamy słowa kluczowego „this”, aby wywołać sparametryzowany konstruktor z konstruktora bez argumentów. Nazywa się to również „Jawne wywołanie konstruktora”.
Dlaczego potrzebujemy tego słowa kluczowego?
Potrzebujemy tego, ponieważ jawne wywołanie konstruktorów nie jest możliwe bezpośrednio przy użyciu tylko nazwy konstruktora.
Punkty do zapamiętania:
- Słowo kluczowe „this” powinno być pierwszą instrukcją w konstruktorze wywołującym.
- Jeśli konstruktor ma słowo kluczowe „this”, to nie może mieć słowa „super”. Oznacza to, że konstruktor może mieć super lub this.
class TestClass { TestClass() { //calling Parameterized Constructor this('SoftwareTestingHelp'); System.out.println('TestClass::No-args Constructor'); } TestClass(String str) { System.out.println('TestClass:: Parameterized Constructor(String):' + str); } } class Main{ public static void main(String[] args) { TestClass obj = new TestClass(); } }Wynik:
W powyższym programie mamy „TestClass” z dwoma konstruktorami. Nazywamy to („SoftwareTestingHelp”) z konstruktora no-args. To jest jawne wywołanie sparametryzowanego konstruktora.
Kopiuj konstruktor w Javie
Wiemy o konstruktorze kopiującym w C ++. Konstruktor kopiujący to konstruktor, który ma odwołanie do obiektu jako argument, a nowy obiekt jest tworzony przy użyciu danych obiektu referencyjnego.
C ++ udostępnia domyślny konstruktor kopiujący, jeśli nie jest dostarczony w programie.
Java zapewnia również obsługę konstruktora kopiującego, ale nie zapewnia domyślnego konstruktora kopiującego.
Poniższy program w języku Java demonstruje konstruktor kopiujący na klasycznym przykładzie liczb zespolonych zawierających składniki rzeczywiste i urojone.
class Complex { private double real, imaginary; // parametrized constructor public Complex(double real, double imaginary) { System.out.println('Complex:: parametrized constructor'); this.real = real; this.imaginary = imaginary; } // copy constructor Complex(Complex c) { System.out.println('Complex::Copy constructor called'); real = c.real; imaginary = c.imaginary; } // Overriding the toString of Object class @Override public String toString() { return '(' + real + ' + ' + imaginary + 'i)'; } } public class Main { public static void main(String[] args) { Complex c1 = new Complex(1, 5); //calls parametrized constructor System.out.println('C1 = ' + c1); // copy constructor called Complex c2 = new Complex(c1); System.out.println('C2 = ' + c2); // this is a simple assignment operator Complex c3 = c2; } } Wynik:
Powyższy program ma klasę „Complex”, która ma sparametryzowany konstruktor i konstruktor kopiujący. W metodzie głównej najpierw tworzymy obiekt c1 za pomocą sparametryzowanego konstruktora. Następnie używając poniższego oświadczenia,
Complex c2 = new Complex (c1); Powyższa instrukcja wywołuje konstruktor kopiujący, ponieważ referencja c1 jest przekazywana do konstruktora podczas tworzenia nowego obiektu c2.
Tworzenie łańcuchów konstruktorów w Javie
Tworzenie łańcuchów konstruktorów to proces, w którym jeden konstruktor wywołuje inny konstruktor tej samej klasy.
Nawet jeśli odziedziczyliśmy po klasie bazowej, konstruktor klasy bazowej jest wywoływany jako pierwszy podczas tworzenia obiektu klasy potomnej. Jest to również przykład tworzenia łańcuchów konstruktorów.
W Javie tworzenie łańcuchów konstruktorów można osiągnąć na dwa sposoby:
- W tej samej klasie : Kiedy wywołujemy jeden konstruktor z innego konstruktora tej samej klasy, możemy użyć słowa kluczowego this ().
- Z klasy bazowej: Konstruktor klasy bazowej można wywołać za pomocą klasy pochodnej, używając słowa kluczowego super.
Dlaczego potrzebujemy tworzenia łańcuchów konstruktorów?
Kiedy chcemy wykonać wiele zadań w naszym konstruktorze, zamiast wykonywać każde zadanie w jednym konstruktorze, dzielimy zadania na wiele konstruktorów, a następnie wywołujemy konstruktory od siebie, co powoduje tworzenie łańcuchów konstruktorów.
Poniżej podano niektóre zasady, których musimy przestrzegać podczas wykonywania łańcuchów konstruktorów.
- Tworzenie łańcuchów konstruktorów odbywa się w dowolnej kolejności i daje takie same wyniki.
- Słowo kluczowe „this” powinno być pierwszym wyrażeniem w konstruktorze.
- Powinniśmy mieć przynajmniej jeden konstruktor bez tego słowa kluczowego.
Gdy mamy dziedziczenie w naszym programie, możemy również wykonać łańcuch konstruktora. W takim przypadku podklasa wywoła konstruktora klasy bazowej. Wykonując tę podklasę, tworzenie obiektów rozpoczyna się od inicjalizacji członków nadklasy.
Teraz zaimplementujemy łańcuch konstruktora w Javie, używając powyższych podejść.
# 1) Tworzenie łańcucha konstruktora w tej samej klasie
class DemoClass { // No args constructor DemoClass() { System.out.println('DemoClass::No args constructor'); } // parameterized constructor DemoClass(int val1) { // calls default constructor this(); System.out.println('DemoClass::Constructor with 1 argument: ' + val1); } // parameterized constructor DemoClass(int val1, int val2) { // invokes parameterized constructor with 1 argument this(5); System.out.print('DemoClass::constructor with 2 arguments:'); System.out.println('Product of 2 arguments = ' + val1 * val2); } } class Main{ public static void main(String args[]) { // call parameterized constructor with 2 arguments new DemoClass(10, 15); } } Wynik:
Jak już wspomniano, łańcuch konstruktora w tej samej klasie uzyskujemy za pomocą słowa kluczowego „this”. W powyższym programie mamy trzy konstruktory i wywołujemy jeden konstruktor z innego za pomocą słowa kluczowego „this”.
Z klasy bazowej
Gdy klasa dziedziczy inną klasę, konstruktor klasy nadrzędnej jest wywoływany jako pierwszy, gdy tworzymy obiekt klasy pochodnej, który jest powiązany z konstruktorem.
Jeśli chcemy jawnie wywołać konstruktor klasy bazowej w klasie pochodnej, powinniśmy w tym celu użyć słowa kluczowego „super”. Używając słowa kluczowego „super”, możemy wywoływać konstruktory nadklasy w hierarchii dziedziczenia, aż osiągniemy najwyższą klasę.
Poniższy program demonstruje użycie słowa kluczowego „super” do tworzenia łańcuchów konstruktorów.
class BaseClass { String name; // no args constructor BaseClass() { this(''); System.out.println('BaseClass::No-argument constructor'); } // Parameterized constructor BaseClass(String name) { this.name = name; System.out.println('BaseClass::Parameterized constructor'); } } class DerivedClass extends BaseClass { // No-argument constructor DerivedClass() { System.out.println('DerivedClass::No-argument constructor'); } // parameterized constructor DerivedClass(String name) { super(name); // invokes Parameterized constructor of BaseClass System.out.println('DerivedClass::Parameterized constructor'); } } class Main { public static void main(String args[]) { // invokes DerivedClass parameterized constructor DerivedClass obj = new DerivedClass('Java'); } }Wynik:
W powyższym programie wywołujemy sparametryzowany konstruktor klasy pochodnej z wartością „Java”. Ten konstruktor z kolei wywołuje konstruktor klasy bazowej przy użyciu „super (nazwa)”; który wykonuje sparametryzowany konstruktor klasy bazowej.
Często Zadawane Pytania
P # 1) Jak utworzyć konstruktora w Javie?
jak dodać ip za darmo
Odpowiedź: Konstruktor tworzymy jako specjalną metodę, która ma taką samą nazwę jak nazwa klasy. Konstruktor również nie może mieć typu zwracanego. Może mieć modyfikatory dostępu, ale nie może być ostateczna, statyczna, abstrakcyjna ani zsynchronizowana.
Jeśli ABC jest klasą, to możemy zdefiniować jej konstruktor jako
ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructorPytanie 2) Jakie są zalety konstruktora w Javie?
Odpowiedź: Korzystając z konstruktora, możemy zainicjować elementy klasy jako pierwszą czynność w momencie tworzenia obiektu. Konstruktor eliminuje potrzebę niejawnego wywoływania normalnych metod.
W konstruktorze możemy wykonywać różne zadania związane z inicjalizacją, uruchamianiem zadań itp., Ponieważ konstruktory są wywoływane na etapie tworzenia obiektu.
P # 3) Dlaczego używa się konstruktorów?
Odpowiedź: Konstruktory są używane głównie do inicjowania członków klasy i są wywoływane podczas tworzenia obiektu klasy.
P # 4) Czy Constructor może być prywatny?
Odpowiedź: Tak, możemy mieć prywatnego konstruktora. Gdy konstruktor jest prywatny, można zapobiec tworzeniu wystąpienia klasy.
P # 5) Czy Constructor może być ostateczny?
Odpowiedź: Nie, nie możemy mieć końcowego konstruktora.
Wniosek
W tym samouczku rozpoczęliśmy dyskusję na temat konstruktorów w Javie. Poznaliśmy podstawy konstruktora, jego tworzenie i zasady, którymi należy się kierować. Omówiliśmy również konstruktory kopiujące w Javie.
Przedstawiono przykłady domyślnego konstruktora i typów konstruktorów oraz pojęć, takich jak przeciążanie konstruktorów i tworzenie łańcuchów konstruktorów. W ramach tych tematów widzieliśmy również użycie słowa kluczowego „this” w konstruktorach.
=> Przeczytaj serię szkoleń Easy Java.
rekomendowane lektury
- Obiekt klasy Java Vs - jak używać klasy i obiektu w języku Java
- Podstawy języka Java: składnia języka Java, klasa języka Java i podstawowe pojęcia dotyczące języka Java
- Klasa Java Integer i Java BigInteger z przykładami
- Samouczek klasy skanera Java z przykładami
- Java Array Class Tutorial - klasa java.util.Arrays z przykładami
- Co to jest wektor Java | Samouczek klasy wektorowej Java z przykładami
- Interfejs Java i samouczek klasy abstrakcyjnej z przykładami
- Klasa Robot w Selenium WebDriver z Javą