java constructor class
이 튜토리얼에서는 코드 예제를 통해 Java 생성자, 생성자 오버로딩 및 생성자 체인과 같은 유형 및 개념에 대해 설명합니다.
이전 튜토리얼에서 우리는 클래스의 인스턴스를 객체라고합니다. 클래스의 객체는 'new'키워드를 사용하여 생성됩니다. 새 키워드로 객체를 만들거나 객체가 인스턴스화 될 때 '생성자'라는 특수 메서드가 호출됩니다.
생성자는 클래스 객체를 초기화하는 코드 블록으로 정의됩니다. 방법과 동일하지만 방법이 아닙니다. 그러나 Java에서는 '특별한 방법'이라고 할 수 있습니다.
=> 여기에서 Java 교육 자습서의 A-Z를 보려면 여기를 확인하십시오.
학습 내용 :
자바 생성자
Java 생성자는 방금 생성 된 객체를 초기화하는 데 사용됩니다. 개체는 프로그램에서 사용되기 전에 일부 데이터가 있어야합니다. 따라서 객체에 초기 데이터를 할당 할 수 있도록 생성자를 사용합니다.
간단한 예로, 객체를 생성해야하는 클래스 ABC를 고려하십시오. 새 키워드를 사용하여 클래스 ABC에 대한 'myObj'개체를 만들어 보겠습니다.
ABC myObj = new ABC ();위의 문은 myObj 개체를 만듭니다. 이 객체가 생성 될 때 인수가없는 클래스 ABC의 생성자가 호출됩니다 (ABC ()는 생성자에 대한 인수가 없음을 나타냄). 위의 생성자에 제공된 인수가 없기 때문에 myObj의 멤버 필드는 기본 초기 값으로 초기화됩니다.
예를 들면
- int와 같은 숫자 데이터 유형은 0으로 설정됩니다.
- Char 데이터 유형 변수 값이 널 (‘ 0’) 문자로 설정되었습니다.
- 참조가 null로 설정됩니다.
이 튜토리얼에서는 Java에서 사용되는 다양한 생성자와 함께 생성자에 대해 자세히 설명합니다.
Java에서 생성자를 만드는 방법
Java로 생성자를 생성하려면 아래와 같은 특정 규칙을 따라야합니다.
- 클래스 생성자는 클래스의 이름과 동일합니다.
- 최종, 추상, 동기화 또는 정적 생성자는있을 수 없습니다. 이는 Final이 상수로 작동하고 추상은 인스턴스화 될 수 없기 때문입니다. 반면 동기화는 멀티 스레딩의 경우 사용되며 static 키워드는 클래스 수준에서 사용됩니다.
- 생성자와 함께 액세스 수정자를 사용할 수 있습니다.
- 생성자는 반환 유형을 가질 수 없습니다.
예를 들면다음과 같이 Student 클래스를 정의하겠습니다.
class Student{ String name; int roll_no; } new 키워드를 사용하여 위 클래스의 객체를 만들 수 있습니다. 객체가 생성되는 동안 생성자를 제공하여이 클래스의 두 멤버 변수를 초기화 할 수 있습니다. 생성자를 제공하지 않고 아래 명령문을 실행하더라도
학생 학생 = 새 학생 ();
그래도 Java는 두 멤버 변수를 시스템 기본값으로 초기화하는 기본 생성자를 실행합니다. 이제 Student.name의 초기 값이 'Keith'이고 roll_no가 27이되도록하려면 다음 생성자 메서드를 만들 수 있습니다.
Student () { name = 'Keith'; roll_no = 27; } 아래 문장으로 학생 클래스의 객체를 만들 때
Student student = new Student ();그러면 멤버 변수 이름과 roll_no의 초기 값은 각각 Keith와 27이됩니다.
생성자가 생성되었으므로 언제 호출됩니까?
생성자는 위와 같이 new 키워드로 객체가 생성 될 때마다 호출됩니다. 이미 언급했듯이 생성자가 제공되지 않으면 Java는 new 키워드를 사용하여 객체를 만들 때 호출되는 기본 생성자를 제공합니다.
생성자 예
다음 프로그램은 인수없이 간단한 생성자가있는 생성자 예제를 보여줍니다. 이 생성자는 단순히 초기 값을 멤버 변수에 할당합니다.
//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(); } }산출:
자바의 기본 생성자
기본 생성자는 빈 생성자라고도합니다. . 이 생성자는 프로그래머가 구현 한 생성자가없는 클래스 코드에 Java 컴파일러에 의해 삽입됩니다. 기본 생성자는 컴파일 중에 삽입되므로 소스 코드가 아닌‘.class’파일에만 나타납니다.
다음 Java 클래스를 고려하십시오.
소스 파일 (.java) 클래스 파일 (.class)
위 그림에서 첫 번째 그림은 생성자를 지정하지 않은 소스 코드를 보여줍니다. 따라서이 코드를 컴파일하고 .class 파일이 생성되면 Java 컴파일러가 인접한 그림 (파란색)과 같이 기본 생성자를 삽입했음을 알 수 있습니다.
노트 :
때때로 기본 생성자는 Java에서 인수가없는 생성자를 설명하는 데 사용됩니다. 그러나이 두 용어는 실제로 다릅니다. 인수가없는 생성자는 프로그래머가 지정한 Java의 생성자 유형입니다. 기본 생성자는 Java 컴파일러에 의해 삽입되는 생성자입니다.
소프트웨어에서 회귀 테스트는 무엇입니까
따라서 대부분의 프로그래머는이 두 용어를 같은 의미로 사용하지만이 두 용어를 혼동하지 않는 것이 좋습니다.
Java가 기본 생성자를 삽입 할 때 프로그램에 변수가 있으면 기본값이 할당됩니다.
아래 표는 각 데이터 유형의 기본값을 보여줍니다.
| 유형 | 기본값 |
|---|---|
| 숯 | u0000 |
| 목적 | 참조 null |
| 부울 | 그릇된 |
| 바이트 | 0 |
| 짧은 | 0 |
| int | 0 |
| 긴 | 0L |
| 흙손 | 0.0f |
| 더블 | 0.0d |
다음 프로그램은 Java의 기본 생성자의 예를 제공합니다.
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); } }산출:
Java의 생성자 유형
Java에는 아래와 같이 두 가지 유형의 생성자가 있습니다.
# 1) 인수없는 생성자
인수가없는 생성자를 인수없는 생성자 또는 인수없는 생성자라고합니다. 인수가없는 생성자가 없으면 Java 컴파일러는 클래스에 대한 기본 생성자를 생성하지 않습니다.
일반적으로 클래스에 생성자를 정의하면 기본 생성자는 Java 컴파일러에 의해 삽입되지 않습니다.
다음은 인수가없는 생성자의 예입니다.
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(); } } 산출:
이 프로그램에서는 인수가없는 생성자를 제공했습니다. 여기에서 멤버 변수를 포함한 일부 메시지를 인쇄합니다. 출력에서 생성자의 메시지가 표시되어 인수가없는 생성자가 실행되었음을 알 수 있습니다.
# 2) 매개 변수화 된 생성자
매개 변수화 된 생성자에는 하나 이상의 매개 변수가 있습니다. 클래스의 멤버 변수에 초기 값을 전달해야하는 경우 매개 변수화 된 생성자를 사용할 수 있습니다.
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); } } 산출:
여기서 우리는 이름과 ID라는 두 개의 인수를받는 매개 변수화 된 생성자를 제공했습니다.
생성자 본문 내에서 인수는 멤버 변수 이름과 ID에 각각 값으로 할당됩니다.
그런 다음 main 메소드에서 new 키워드를 사용하여 새 객체를 만들 때 새 키워드 다음에 두 개의 값을 클래스 이름에 전달합니다. 이것은 매개 변수화 된 생성자를 호출하고 있음을 나타냅니다. 멤버 변수를 표시하면 개체를 생성하는 동안 전달한 값이 있음을 알 수 있습니다.
자바에서 오버로드 된 생성자
이제 질문은 클래스가 둘 이상의 생성자를 가질 수 있는지 아니면 클래스가 하나의 생성자 만 가질 수 있는지에 대한 것입니다.
글쎄, 우리는 클래스에 여러 생성자를 가질 수 있습니다. 클래스는 적절하게 오버로드되는 한 많은 생성자를 가질 수 있습니다.
그렇다면 생성자의 오버로딩이 정확히 무엇을 의미합니까?
생성자 오버로딩은 클래스가 많은 생성자를 가질 수 있도록하는 메커니즘으로, 이러한 모든 생성자는 매개 변수 유형 또는 매개 변수 순서에 따라 다른 매개 변수 목록을 갖도록합니다.
아래 프로그램은 생성자 오버로딩을 보여줍니다.
//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(); } }산출:
위 프로그램에는 세 개의 생성자가 포함 된 클래스가 있습니다. 첫 번째 생성자는 인수가없는 생성자이며 각각 하나의 인수와 두 개의 인수가 있습니다. 생성자에는 고유 한 매개 변수 목록이 있으므로 생성자가 오버로드되었다고 말할 수 있습니다.
자바의‘this ()’생성자
여러 생성자를 포함하는 클래스에서이 클래스의 다른 생성자에서 하나의 생성자를 호출하려면 어떻게해야합니까?
이를 위해 다른 생성자를 호출하려는 생성자 내부에서 'this'키워드를 사용합니다.
따라서 클래스에 여러 생성자, 인수없는 생성자 및 매개 변수화 된 생성자가있는 경우 'this'키워드를 사용하여 인수없는 생성자에서 매개 변수화 된 생성자를 호출합니다. 이것은 또한 '생성자의 명시 적 호출'.
이 키워드가 필요한 이유는 무엇입니까?
생성자의 명시 적 호출은 생성자 이름만을 사용하여 직접적으로 가능하지 않기 때문에 필요합니다.
참고 사항 :
- 키워드 'this'는 호출 생성자에서 첫 번째 문이어야합니다.
- 생성자에 'this'키워드가 있으면 'super'를 가질 수 없습니다. 이것은 생성자가 super 또는 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(); } }산출:
Windows 10 용 무료 정리 도구
위의 프로그램에는 두 개의 생성자가있는 'TestClass'가 있습니다. 인수가없는 생성자에서 이것을 ( 'SoftwareTestingHelp')라고합니다. 이것은 매개 변수화 된 생성자의 명시 적 호출입니다.
자바에서 생성자 복사
우리는 C ++의 복사 생성자를 알고 있습니다. 복사 생성자는 개체 참조를 인수로 갖는 생성자이며 참조 개체의 데이터를 사용하여 새 개체를 만듭니다.
C ++는 프로그램에서 제공되지 않는 경우 기본 복사 생성자를 제공합니다.
Java는 복사 생성자에 대한 지원도 제공하지만 기본 복사 생성자를 제공하지 않습니다.
다음 Java 프로그램은 실수 및 허수 구성 요소가있는 복소수의 고전적인 예를 사용하여 복사 생성자를 보여줍니다.
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; } } 산출:
위 프로그램에는 매개 변수화 된 생성자와 복사 생성자가있는 '복합'클래스가 있습니다. 먼저 main 메서드에서 매개 변수가있는 생성자를 사용하여 c1 개체를 만듭니다. 그런 다음 아래 문을 사용하여
Complex c2 = new Complex (c1); 위의 문은 새 개체 c2를 만드는 동안 참조 c1이 생성자에 전달 될 때 복사 생성자를 호출합니다.
자바에서 생성자 체이닝
생성자 체이닝은 동일한 클래스의 다른 생성자를 호출하는 생성자의 프로세스입니다.
기본 클래스에서 상속 된 경우에도 자식 클래스 개체가 생성 될 때 기본 클래스의 생성자가 먼저 호출됩니다. 이것은 또한 생성자 체인의 예입니다.
Java에서 생성자 체인은 두 가지 접근 방식을 사용하여 수행 할 수 있습니다.
- 같은 클래스 내 : 같은 클래스의 다른 생성자에서 하나의 생성자를 호출 할 때 this () 키워드를 사용할 수 있습니다.
- 기본 클래스에서 : 기본 클래스의 생성자는 super 키워드를 사용하여 파생 클래스의 생성자에 의해 호출 될 수 있습니다.
생성자 체인이 필요한 이유는 무엇입니까?
생성자에서 여러 작업을 수행하려면 하나의 생성자에서 각 작업을 수행하는 대신 작업을 여러 생성자로 나누고 생성자를 서로 호출하여 생성자 체인을 만듭니다.
다음은 생성자 체인을 수행하는 동안 따라야하는 몇 가지 규칙입니다.
- 생성자 체인은 임의의 순서로 수행되며 동일한 결과를 생성합니다.
- 표현식‘this’키워드는 생성자에서 첫 번째 표현식이어야합니다.
- 이 키워드가없는 생성자가 하나 이상 있어야합니다.
프로그램에 상속이 있으면 생성자 체인도 수행 할 수 있습니다. 이 경우 하위 클래스는 기본 클래스의 생성자를 호출합니다. 이렇게하면 서브 클래스 객체의 생성은 수퍼 클래스 멤버의 초기화로 시작됩니다.
이제 위의 접근 방식을 사용하여 Java에서 생성자 체인을 구현합니다.
# 1) 동일한 클래스 내 생성자 체인
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); } } 산출:
이미 언급했듯이 'this'키워드를 사용하여 동일한 클래스 내에서 생성자 체인을 달성합니다. 위의 프로그램에는 세 개의 생성자가 있으며 'this'키워드를 사용하여 다른 생성자에서 하나의 생성자를 호출합니다.
기본 클래스에서
클래스가 다른 클래스를 상속하면 생성자 체인 인 파생 클래스의 객체를 만들 때 부모 클래스의 생성자가 먼저 호출됩니다.
파생 클래스에서 기본 클래스 생성자를 명시 적으로 호출하려면이 목적을 위해 키워드 'super'를 사용해야합니다. 'super'키워드를 사용하면 최상위 클래스에 도달 할 때까지 상속 계층 구조에서 슈퍼 클래스 생성자를 호출 할 수 있습니다.
아래 프로그램은 생성자 연결을위한 'super'키워드의 사용을 보여줍니다.
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'); } }산출:
위의 프로그램에서 'Java'값으로 파생 클래스의 매개 변수화 된 생성자를 호출합니다. 이 생성자는 차례로 'super (name);'을 사용하여 기본 클래스 생성자를 호출합니다. 기본 클래스의 매개 변수화 된 생성자를 실행합니다.
자주 묻는 질문
Q # 1) Java에서 생성자를 어떻게 생성합니까?
대답: 클래스 이름과 같은 이름을 가진 특수 메서드로 생성자를 만듭니다. 생성자는 반환 유형도 가질 수 없습니다. 액세스 수정자를 가질 수 있지만 최종, 정적, 추상 또는 동기화 될 수 없습니다.
ABC가 클래스 인 경우 생성자를 다음과 같이 정의 할 수 있습니다.
ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructorQ # 2) Java에서 생성자의 이점은 무엇입니까?
대답: 생성자를 사용하여 순간 객체가 생성되는 첫 번째로 클래스의 멤버를 초기화 할 수 있습니다. 생성자는 일반 메서드를 암시 적으로 호출 할 필요가 없습니다.
객체 생성 단계에서 생성자가 호출되므로 생성자에서 초기화, 작업 시작 등과 관련된 다양한 작업을 수행 할 수 있습니다.
Q # 3) 생성자가 사용되는 이유는 무엇입니까?
대답: 생성자는 주로 클래스의 멤버를 초기화하는 데 사용되며 클래스의 객체가 생성 될 때 호출됩니다.
Q # 4) 컨스트럭터는 비공개가 될 수 있나요?
대답: 예, 개인 생성자를 가질 수 있습니다. 생성자가 private이면 클래스가 인스턴스화되지 않도록 할 수 있습니다.
Q # 5) 생성자가 최종일 수 있습니까?
대답: 아니오, 최종 생성자를 가질 수 없습니다.
결론
이 튜토리얼에서는 Java의 생성자에 대한 논의를 시작했습니다. 생성자의 기본, 생성 및 따라야 할 규칙을 배웠습니다. 또한 Java의 복사 생성자에 대해서도 논의했습니다.
기본 생성자 및 생성자 유형과 생성자 오버로딩 및 생성자 체이닝과 같은 개념이 예제와 함께 간략하게 설명되었습니다. 이 주제의 일부로 생성자에서 'this'키워드를 사용하는 것도 확인했습니다.