728x90

 

상속(Inheritance) 정의

특정 클래스의 변수, 메소드확장,상속해서 다른 클래스갖도록 하는 것

 

상속의 장점

  1. 코드의 재사용성up
  2. 유지보수 편의성 up
  3. 가독성 up
  4. 코드의 양 down

 

 

 

  • 부모클래스(=superClass)
  • 자식클래스(=subClass)

 

부모 클래스 기능에서 자식 클래스추가 & 재정의(오버라이딩) 가능

 

오버라이딩(Overriding)

부모가 가진 기능재정의(수정)하는 것을 오버라이딩(Overriding)

예시)

class Cal33 extends Cal11{		// extends : Cal1을 상속
	public int minus(int v1, int v2) {
		return v1-v2;			// Cal3는 이제 부모 클래스가 없는 마이너스 기능도 탑재
	}
	public int sum(int v1, int v2) {
		System.out.println("Cal3!!");
		return v1+v2;    // 부모가 가진 기능을 재정의(수정)
	}
}

 

 

오버로딩(Overloading)

뜻 : 과적하다

부모클래스도 자식클래스도 오버로딩 가능. 자식 클래스는 부모 클래스를 오버라이딩, 오버로딩 둘 다 가능

자바는 형태다르같은 이름메소드를 같은 클래스 내에서도 여러개 사용 가능

class Cal11 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int sum(int v1, int v2, int v3) { // 같은 이름 메소드 // int v3 추가
		return v1+v2+v3;
	}
}

 

 


 

 

this는 자기 자신

class Cal111 {
	// this
	// 자기 자신을 뜻함
	public int sum(int v1, int v2, int v3) { 
		return this.sum(v1,v2)+v3;	    // .sum() 자기자신
	}
}

 

 

super는 자신의 부모

자식 클래스의 메소드가 부모 클래스의 메소드를 호출하고 그 결과를 이용할 수 있게 하는 것

super.부모클래스의 메소드명;

breakpoint로 디버깅체크 가능

public int sum(int v1, int v2){
		return super.sum(v1,v2);
}

super의 사용 예시

class Cal1111 {
	int v1,v2;				  	        // 정수 데이터타입 세팅
	Cal1111(int v1, int v2) { 	  // 생성자 
		this.v1 = v1; this.v2 = v2; // this.v1의 v1은 class Cal1111 { 아랫줄 int v1
		//매개변수에 들어온 값				// this.v1 = v1;에서 v1;은 Cal1111(int v1, int v2)에서 int v1
		System.out.println("Cal init!!!");
	}
}
class Cal3333 extends Cal1111{  // extends : Cal1을 상속
	Cal3333(int v1, int v2) {
		**super**(v1, v2);	// **super**=부모클래스. 즉,부모클래스의 생성자를 실행시킴. 
						// 부모클래스의 생성자는 아래와 같다
						// Cal1111(int v1, int v2) {
						// 		this.v1 = v1; this.v2 = v2;
	System.out.println("Cal3 init!!!");
	}
}
public class Inheritance05 {
	public static void main(String[] args) {
		// new cal() 안에 입력값 2,1 새로 입력
		Cal1111 c1 = new Cal1111(2,1); // 출력 : 클래스cal1에서 println() 한번만 출력 
		Cal3333 c3 = new Cal3333(2,1); // 출력 : super(v1, v2); 이 문구가 
									   // 클래스cal1에서 println() 한번 출력시키고
									   // 클래스cal3에서 println() 한번 출력시켜 두번출력
	}
}

 

 

생성자(Constructor)

자식 클래스에서 부모클래스를 계승 받아 실행하게 될 때, 반드시 부모클래스의 생성자를 실행해야한다

ex)

class Cal1111 {
	int v1,v2;				  	      // 정수 데이터타입 세팅
	Cal1111(int v1, int v2) { 	// 생성자 
		this.v1 = v1; this.v2 = v2;
		//매개변수에 들어온 값
	}
}
class Cal3333 extends Cal1111{    // error 발생
}
public class Inheritance05 {
	public static void main(String[] args) {
		
		Cal1111 c1 = new Cal1111(2,1); // new cal() 안에 입력값 2,1입력
		Cal3333 c3 = new Cal3333();
	}
}

생성자(Constructor) 메커니즘

오리지널 클래스(cal)를 제대로 계승했다면, Cal이 인스턴스로 만들어질 때 반드시 해야되는 일들이 생성자에 들어있다. 때문에 이 생성자를 Cal3도 실행시켜야만 제대로 작동한다

 

 


 

다형성(Polymorphism)

자식 클래스를 부모클래스로써 동작하도록 규제하는 기능

ParentClass obj = new ChildClass()

 

다형성(polymorphism)이란 하나의 객체여러 가지 타입을 가질 수 있는 것

자바에서는 이러한 다형성을 부모 클래스 타입의 참조 변수로 자식 클래스 타입의 인스턴스를 참조할 수 있도록 하여 구현

 

접근제어자(Access Modifers)

public, default, protected, private

클래스,메소드,변수를 사용자들이 아무거나 건드리지 못하게 제한하는 기능

 

Final

내가 만든 클래스를 다른 사람이 더이상 상속하게 하고 싶지 않을 때

메소드를 오버라이딩(Overriding)하게 하고 싶지않을 때

변수를 다른 사람이 마음대로 수정하게 하고 싶지 않을 때

이런 규제를 하고 싶다면 final을 사용

 

Abstract

final과 반대

클래스를 상속해서 사용하려는 사람에게 어떤 특정 메소드는 꼭 구현해라라고 강제하고 싶은 메소드가 있다면 사용

상속자가 직접 구현해야 하는 기능을 구현하도록 강제할 수 있다

Abstract Class Imcompletion

 

 

728x90
반응형
728x90

 

상속(Inheritance)의 생성자(Contructor)

 

Cal 클래스가 생성자가 있다고하면 어떻게 될지 보자

class Cal1111 {
	int v1,v2;				  	      // 정수 데이터타입 세팅
	Cal1111(int v1, int v2) { 	// 생성자 
		this.v1 = v1; this.v2 = v2;
		//매개변수에 들어온 값
	}
}
class Cal3333 extends Cal1111{    // error 발생
}
public class Inheritance05 {
	public static void main(String[] args) {
		
		Cal1111 c1 = new Cal1111(2,1); // new cal() 안에 입력값 2,1입력
		Cal3333 c3 = new Cal3333();
	}
}

위와 같이 코드를 작성하니 아래와 같이 에러가 발생했다

오리지널 클래스(cal)을 제대로 계승했다면, Cal이 인스턴스로 만들어질 때 반드시 해야되는 일들이 생성자에 들어있다. 때문에 이 생성자를 Cal3도 실행시켜야만 제대로 작동한다

자식 클래스에서 부모클래스를 계승 받아 실행하게 될 때, 반드시 부모클래스생성자실행하도록 규칙을 만들어 놓은 것.

 

 

아래의 코드를 실행할 경우

부모클래스인 cal1에서 println() 한번 : Cal init!!!

자식클래스인 cal3에서 println() 두번 : Cal init!!! & Cal3 init!!!

자식클래스인 cal3에서 super(v1, v2);가 부모클래스 생성자를 실행키는데 이 코드가 부모코드의 println()을 한번 더 실행켜서 cal 한번 cal3 자체에서 한번 더 실행되서 총 두번이 출력되는 것

class Cal1111 {
	int v1,v2;				  	// 정수 데이터타입 세팅
	Cal1111(int v1, int v2) { 	// 생성자 
		this.v1 = v1; this.v2 = v2;
		//매개변수에 들어온 값
		System.out.println("Cal init!!!");
	}
}
class Cal3333 extends Cal1111{  // extends : Cal1을 상속
	Cal3333(int v1, int v2) {
		**super**(v1, v2);	// **super**=부모클래스. 즉,부모클래스의 생성자를 실행시킴. 
						// 부모클래스의 생성자는 아래와 같다
						// Cal1111(int v1, int v2) {
						// 		this.v1 = v1; this.v2 = v2;
	System.out.println("Cal3 init!!!");
	}
}
public class Inheritance05 {
	public static void main(String[] args) {
		// new cal() 안에 입력값 2,1 새로 입력
		Cal1111 c1 = new Cal1111(2,1); // 출력 : 클래스cal1에서 println() 한번만 출력 
		Cal3333 c3 = new Cal3333(2,1); // 출력 : super(v1, v2); 이 문구가 
									   // 클래스cal1에서 println() 한번 출력시키고
									   // 클래스cal3에서 println() 한번 출력시켜 두번출력
	}
}

전체코드

728x90
반응형
728x90

어떨 때에 인스턴스를 쓰는게 좋을까?

<클래스화를 계속 써야할 상황>

1)공급가액 파라미터가 한번 세팅이 되고나서 내부적 상태가 바뀌지 않고 getVAT(), Total() 같은메소드들로 부가가치세, 총액 같은 값만 받으면 되는 간단한 상태면 클래스 사용하면 된다

또는

2)내부적인 상태가 한번 세팅이되면 여러 작업들이 끝나고 그 다음에 새로운 내부적인 상태가 변화가 오는 케이스에서도 클래스를 인스턴스화 시킬 필요는 없다고 본다

 

<인스턴스화를 써야할 상황>

그런데 클래스의 상태가 계속 바뀌어야하는 상황이라면?

ex) 공급가액(vauleOfSupply) 1만 세팅에서 2만,3만 등 경우의수가 엄청나게 많아지고 계속 바꿔가면서 써야한다면?

(즉, 클래스의 상태가 계속 바뀌어야하는 상태일 때는?)

Accounting08_2.valueOfSupply = 10000.0;		
System.out.println("Value of supply : " + Accounting.valueOfSupply);
System.out.println("VAT : " + Accounting.getVAT());
System.out.println("Total : " + Accounting.getTotal());

Accounting08_2.valueOfSupply = 20000.0;		
System.out.println("VAT : " + Accounting.getVAT());

Accounting08_2.valueOfSupply = 50000.0;		
System.out.println("VAT : " + Accounting.getVAT());

Accounting08_2.valueOfSupply = 900.0;		
System.out.println("Total : " + Accounting.getTotal());

 

공급가액(vauleOfSupply)이 하나가 아닌 내부적으로 수십개의 값들이 있고 계속 바꿔야한다면 버그 발생 확률 고위험

하나의 클래스여러 상태에서 돌려써서 버그발생 확률이 높아지게 되는 것

이럴 때 인스턴스화

독립된 인스턴스기에 상태별로 인스턴스를 만들어서 분리시키고 개별맞춤으로 관리가능

 

 

인스턴스가 생성될 때, 인스턴스가 내부적으로 꼭 가져야될 값(valueOfSupply)을 생성자 레벨에서 강제하고 싶다면?

A.아래의 코드 추가 및 인스턴스 생생코드 new Accounting(생성자); 생성자 인자부분 채우기

// 생성자가 호출될 때 인자를 매개변수로 전달하고 싶기에 public accounting() {}에 valueOfSupply를 넣는다
public Accounting08_3(double valueOfSupply) { 
		this.valueOfSupply = valueOfSupply;
}
// 생성자 인자 넣기
Accounting08_3 a1 = new Accounting08_3(**10000.0**);
        a1.valueOfSupply = 10000.0;

public accounting() {} 구현해주면 된다

생성자가 호출될 때 인자를 매개변수로 전달하고 싶기에 public accounting() {}에 valueOfSupply를 넣어주고 this.valueOfSupply 추가

 

 

위의 코드 this.valueOfSupply와 = valueOfSupply;가 가리키는 곳은?

this 키워드

 

 

 

전체코드

// OOP 8.2. 활용 - 인스턴스화

// 클래스화 to 인스턴스화

 
//class Accounting08_2{		// 클래스화
//
//    public static double valueOfSupply;		
//    public static double vatRate = 0.1;		
//    public static double getVAT() {
//        return valueOfSupply * vatRate;
//    }
//    public static double getTotal() {
//        return valueOfSupply + getVAT();
//    }
//}
//					클래스화
//      ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
//					인스턴스화

class Accounting08_2{		// 인스턴스화
	// 인스턴스 소속, static 제거
	// static은 클래스소속이고 클래스가 인스턴스에 접근하면 에러나는건 어떤 인스턴스인지 모르기때문 a1?a2?
	public double valueOfSupply;		
	public static double vatRate = 0.1;	// 부가가치세는 어느 인스턴스나 10% 고정이기에 static설정이 유리	
	public double getVAT() {			// 인스턴스 만들 때마다 메모리 사용하지 않아도 되고, 
	    return valueOfSupply * vatRate; // vatRate파라미터는 얘 하나로 조절 가능해서 유지보수 용이
	}
	public double getTotal() {
	    return valueOfSupply + getVAT();
	}
}

public class OOP08_2 {
	public static void main(String[] args) {		

//        Accounting08_2.valueOfSupply = 10000.0;		
//        System.out.println("Value of supply : " + Accounting.valueOfSupply);
//        System.out.println("VAT : " + Accounting.getVAT());
//        System.out.println("Total : " + Accounting.getTotal());
//        
//        Accounting08_2.valueOfSupply = 20000.0;		
//        System.out.println("VAT : " + Accounting.getVAT());
//        
//        Accounting08_2.valueOfSupply = 50000.0;		
//        System.out.println("VAT : " + Accounting.getVAT());
//        
//        Accounting08_2.valueOfSupply = 900.0;		
//        System.out.println("Total : " + Accounting.getTotal());
    
				Accounting08_2 a1 = new Accounting08_2();
		    a1.valueOfSupply = 10000.0;
		    
		    Accounting08_2 a2 = new Accounting08_2();
		    a2.valueOfSupply = 20000.0;
		    
		    System.out.println("Value of supply : " + a1.valueOfSupply);
		    System.out.println("Value of supply : " + a2.valueOfSupply);
		    
		    System.out.println("VAT : " + a1.getVAT());
		    System.out.println("VAT : " + a2.getVAT());
		    
		    System.out.println("Total : " + a1.getTotal());
		    System.out.println("Total : " + a2.getTotal());    
	}
}
728x90
반응형
728x90

 

생성자(constructor)

  • 해당 클래스와 똑같은 이름을 정의하면, 얘가 바로 생성자(constructor)
  • 초기에 주입할 필요가 있는 값(초기값)을 전달하거나 초기에 작업을 수행할 때 쓴다
  • 리턴값이 없으며, 모든 클래스는 생성자가 반드시 한개이상 존재한다.
  • 따로 선언하지 않아도 보이지 않는 default constructor가 자동으로 추가된다.

 

 

this 키워드

  • 클래스인스턴스화 되었을 때인스턴스를 가리키게 하는 특수한 키워드
  • 자바에서 this는 자기자신을 뜻함

 

 

생성자(constructor)는 왜 써야할까?(과정설명)

파일수정 시 어떤파일을 수정할지 파일 지정해줘야하는데 파일지정 행위를 까먹거나 나중에 하게되면 문제발생

  1. 인스턴스 생성시점에서 ("data.txt")처럼 파일을 지정할 수 있다면 까먹지 않고 안정성 상승
  2. 인스턴스가 생성될 때, 처리되어야할 어떤 작업(초기값 등)이 있을 때, 또는 생성될 때 실행되어야하는 작업들을 하고 싶을 때 생성자(constructor)로 해결 가능

 

어떤 클래스가 어떤 작업을 처리하기전 delimiter값을 세팅해야 우리작업을 할 수 있는 상황이라고하면,

이 파라미터값 조정을 까먹기가 상당히 쉽다.

개선책

인스턴스 생성시, delimiter값을 지정하지 않으면 클래스가 인스턴스화되지 못하도록 하면서 개발자가 실수할 가능성 차단가능. 인스턴스를 생성할 때 delimiter값을 지정하는 것을 해볼 것. 생성자constructor를 정의해야한다.

 

자바에서의 클래스는 생성자(constructor)라는 특수한 메소드를 구현할 수 있는 기능을 제공하며, 중요기능은 초기화이다. 해당 클래스와 똑같은 이름을 정의하면, 얘가 바로 생성자(constructor)

인스턴스를 생성할 때, 자바는 이 클래스와 동일한 메소드가 있다면 그 메소드를 호출하도록 약속 되어있기에 우리는 그 클래스가 인스턴스화 될 때 실행되어야할 코드를 construct method 안에 정의 하는 걸 통해서 초기화의 목적을 달성할 수 있는 것

 

print클래스가 인스턴스화 될 때 구분자를 인자로써 받을 것이기에 print메소드의 매개변수로 delimiter를 받으면됨

 

생성자(constructor) 모양새

class Print00 {
	public String delimiter = "";
	public Print00(String delimiter) {  // print00의 ()이 생성자

 

 


 

class Print00 { 
	public String delimiter = ""; 
	public Print00(String _delimiter) {
			delimiter = _delimiter;  // 이 클래스의 인스턴스 변수인 delimiter 값은 _delimiter의 값은 "----"
	}  // 밑에 A()메소드를 호출하면 println(delimiter)값에 "----" 들어가게됨
	public void A() { 
		System.out.println(delimiter); // 인자값에 "----"
		System.out.println("A");
	}
	public void B() {
		System.out.println(delimiter);
		System.out.println("B");

}

이 클래스의 인스턴스 변수인 delimiter 값은 _delimiter의 값은 "----" 밑에 A()메소드를 호출하면 println(delimiter)값에 "----" 들어가게됨

 

만약 언더바를 빼고 delimiter = delimiter;라고 한다면

Q.왼쪽 delimiter는 인스턴스 변수delimiter일까 생성자 메소드의 delimiter매개변수일까?

A. delimiter매개변수

※ 확인방법 ※ 

실행해보면 구분자가 출력이 안되어 나오는데, String delimiter = "";에 세팅이 안됬기 때문. 또한 이클립스에서 같은변수인지 색표시에서도 각각 구별되어져 보임. 이런 경우 앞에 this.를 붙여준다. this키워드 붙인 후 연결되는 delimiter가 바뀌는게 보인다.

this는 우리가 생성한 인스턴스를 가리키는 것 this.delimiter는 인스턴스의 변수를 가리키니까 String delimiter = "";의 delimiter를 가리키며, 생성자메소드 뿐 아니라 클래스 아래있는 메소드들의 delimiter에도 this.를 붙여 명시적으로 해두는게 좋다

 

생성자(constructor)는 초기에 주입할 필요가 있는 값(초기값)을 전달하거나 초기에 작업을 수행할 때 쓴다

this는 클래스가 인스턴스화 되었을 때에 인스턴스를 가리키는 특수한 이름

 

 

 

전체코드

// OOP 7. 생성자(constructor)와 this

// 생성자(constructor)
// 초기에 주입할 필요가 있는 값을 전달하거나 초기에 작업을 수행할 때 쓴다
// 리턴값이 없으며, 모든 클래스는 생성자가 반드시 한개이상 존재한다. 
// 따로 선언하지 않아도 보이지 않는 default constructor가 자동으로 추가된다.

// this 키워드
// 클래스가 인스턴스화 되었을 때에 인스턴스를 가리키게 하는 특수한 키워드
// 자바에서 this는 자기자신을 뜻함

public class OOP07 {
	public static void main(String[] args) {
	
//	 생성자(constructor)는 왜 써야할까?
//	 파일수정 시 어떤파일을 수정할지 파일 지정해줘야하는데 파일지정 행위를 까먹거나 나중에 하게되면 문제발생
//	 1)인스턴스 생성시점에서 ("data.txt")처럼 파일을 지정할 수 있다면 까먹지 않고 안정성 상승
//	 2)인스턴스가 생성될 때, 처리되어야할 어떤 작업(초기값 등)이 있을 때,
//	 또는 생성될 때 실행되어야하는 작업들을 하고 싶을 때 생성자(constructor)로 해결 가능
	
	
//	 print클래스는 어떤 작업을 처리하기전 delimiter값을 세팅해야 우리작업을 할 수 있는 상황이라고하면,
//	 이 파라미터값 조정을 까먹기가 상당히 쉽다.
//	 개선책
//	 인스턴스 생성시, delimiter값을 지정하지 않으면 클래스가 인스턴스화되지 못하도록 하면서 개발자가 실수할 가능성 차단가능
//	 인스턴시 생성할 때 delimiter값을 지정하는 것을 해볼 것. 생성자constructor를 정의해야함
	
//	 자바에서의 클래스는 생성자라는 특수한 메소드를 구현할 수 있는 기능을 제공하며, 중요기능은 초기화
//	 해당 클래스와 똑같은 이름을 정의하면, 얘가 바로 생성자(constructor)
//	 인스턴스를 생성할 때 자바는 이 클래스와 동일한 메소드가 있다면 그 메소드를 호출하도록 약속 되어있기에
//	 우리는 그 클래스가 인스턴스화 될 때 실행되어야할 코드를 construct method 안에 
//	 정의 하는 걸 통해서 초기화의 목적을 달성할 수 있는 것
		
//	 print클래스가 인스턴스화 될 때 구분자를 인자로써 받을 것이기에 print메소드의 매개변수로 delimiter를 받으면됨
				
	Print00 p1 = new Print00("----");		// new가 없으면 메소드를 호출하는 것과 같다
    p1.A();
    p1.B();

    Print00 p2 = new Print00("====");
    p2.A();
    p2.B();    
	}
}

class Print00 {
	public String delimiter = "";
	public Print00(String delimiter) {  // print00의 ()이 생성자
		this.delimiter = delimiter; 	// _delimiter는 이 맥락에서 "----"
	}
	// 이 클래스의 인스턴스 변수인 delimiter 값은 _delimiter의 값은 "----"
	// 밑에 A()메소드를 호출하면 println(delimiter)값에 "----" 들어가게됨
	// 만약 언더바를 빼고 delimiter = delimiter;라고 한다면 왼쪽 delimiter는 
	// 인스턴스 변수delimiter일까 생성자 메소드의 delimiter매개변수일까? 
	// delimiter매개변수이다
	// 확인방법은 실행해보면 구분자가 출력이 안되어 나오는데,  String delimiter = "";에 세팅이 안됬기 때문
	// 이클립스에서 같은변수인지 색표시에서도 구별되어져 보임. 이런 경우 앞에 this.를 붙여준다.
	// this는 우리가 생성한 인스턴스를 가리키는 것
	// this.delimiter는 인스턴스의 변수를 가리키니까 String delimiter = "";의 delimiter를 가리킴
	// 생성자메소드 뿐 아니라 클래스 아래있는 메소드들의 delimiter에도 this.를 붙여 명시적으로 해두는게 좋다
	
	// 생성자(constructor)는 초기에 주입할 필요가 있는 값을 전달하거나 초기에 작업을 수행할 때 쓴다
	// this는 클래스가 인스턴스화 되었을 때에 인스턴스를 가리키는 특수한 이름
	public void A() {
		System.out.println(this.delimiter);
		System.out.println("A");
	}
	public void B() {
		System.out.println(this.delimiter);
		System.out.println("B");
	}
}

 

728x90
반응형
728x90

 

JAVA1 - 13.3. 자바 문서 보는 법 - 클래스

 

Math.PI 파이 3.1415...구체적인 값이 적당한 정밀도로 저장되어 있는 변수 PI PI Math라는 클래스에 소속되어 있는

 

클래스(Class)

클래스의 인상은 디렉토리

클래스 서로 연관된 변수와 메소드를 그룹핑한다

 

1)내림

System.out.println(Math.floor(1.6));  // Math.floor()

결과값 1.0

2)올림

System.out.println(Math.ceil(1.6)); // Math.ceil()

결과값 2.0

 

 


 

 

JAVA1 - 13.4. 자바 문서 보는 법 - 인스턴스 & Constructor생성자

result1.txt이라는 파일에 hello1이라는 텍스트를 자바를 이용해서 작성해볼 예정

이를 해결하기 위해서 검색,질문해서 알아내고 사용하는 예제 같은 것들을 찾아낸 후 그래도 이해가 안가는 것들은 API다큐먼트를 사용해서 오랜시간에 걸쳐 분석해서 알아내야함 (알아냈다고 가정하고 수업진행) 

 

인스턴스(Instance)

 

new : 복사본 만드는 커맨드

PrintWriter p1 = new PrintWriter("파일명.txt");  // 이렇게만 쓰면 빨간줄(에러발생) 
                                                //PrintWriter는 import해서 java.io에서 불러와야한다

 

import java.io.PrintWriter;

public class practice12 {
	public static void main(String[] args) {

	PrintWriter p1 = new PrintWriter("result1.txt");
    
	}

}

 

아직도 빨간 줄이 있는데 PrintWriter 파일을 읽어하는데 파일이 없으면 문제가 된다.

이러한 경우를 자바에서는 예외상황이라고 부르는데 이러한 예외를 어떻게 처리할지 정해줘야하는데 지금은 어려우니 스킵하고 add throw declaration 클릭해둘

 

 

PrintWriter p1 = new PrintWriter("result1.txt");
p1.write("Hello 1");
p1.close();


PrintWriter p2 = new PrintWriter("result2.txt");
p2.write("Hello 2");
p2.close();

 

수업 주제인 인스턴스로 돌아와보자

변수p1이 인스턴스

1 PrintWriter p1 = new PrintWriter("result1.txt");  의미 : result1.txt 파일 만들어라

2 System.out.println(Math.floor(1.6)); Math클래스는 클래스에 변수이름을 썼다

 

1번은 굳이 복제해서 변수에 담았고, 2번은 그냥했는가의 차이가 뭘까?

위의 Math클래스는 그냥 클래스에다 변수이름을 썼는데 PrintWriter 그냥 안쓰고 new 붙여서 복제하여 복제물을 p1이라는 변수에 담았다는 차이점이 있다

 


 

만약 인스턴스를 쓰지 않는다면 어떤 불편함이 있는가 알아보자

math 간단하게 끝낼 있는 일회용 작업들을 처리하지만,

PrintWriter p1 = new PrintWriter() 같은 경우 파일 생성과 동시에 하나만이 아닌 여러가지 작업들이 수만번 수반될 있기에 하나의 클래스를 사용하기 보다는 클래스를 복제해서 변수(인스턴스) 넣는 것이 작업의 효율이 높기에 클래스의 제작자들이 구조를 이렇게 설계한

 

 

※ Math. PrintWriter() 차이 : 생성자(Constructor)

PrintWriter() constructor(생성자)라는 것이 있고 Math 없다

constructor 없는 애들은 일단 일회용이라고 생각해라

 

constructor 있는 애들은 이를 이용해서 instance 만드는 것이 허용되어 있다고 생각하면

 ex) PrintWriter p1 = new PrintWriter("result1.txt"); // 좌측의 컨스트럭터는 PrintWriter(String fileName)

 

해당 클래스를 만든 사람이 해당 클래스가 인스턴스로써 활용하기를 원한다면 constructor 생성자를 가지고 있고, new 뒤에 붙은 것들이 constructor생성자이다.

 

 

Class constructor 메커니즘

constructor 앞에 new 붙이면 얘가 복제되서 인스턴스가 되고, 인스턴스에 어떤 값이 오는지를 규제하기 위해서 앞에다가 PrintWriter 하는 클래스이름을 적는

728x90
반응형

+ Recent posts