힘내보자

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

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

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());    
	}
}

클래스 : 원형

인스턴스 : 복제본

원형본인 클래스에서 인스턴스를 만들고 새 변수에 담아두고 이 인스턴스의 메소드를 호출하므로써 이 인스턴스를 조작할 수 있게되는 메커니즘

Print05.delimiter = "----";	
Print05.A();					
Print05.A();	

Print05.delimiter = "====";	
Print05.B();
Print05.B();		

Print05.delimiter = "****";
Print05.A();
Print05.delimiter = "====";
Print05.B();

위와 같이 계속 변수의 파라미터를 계속 바꿔서 써야하는 상황이라면?

이럴 때 인스턴스 사용

print클래스 안에 있는 메소드들의 static들 삭제

static 역할

static 뒤에 오는 String(변수(?))이 클래스소속이라는 의미

 - 이렇기에 인스턴스 소속 메소드를 쓰는게 목적이므로 스태틱을 삭제하여 메소드를 클래스 소속에서 인스턴스 소속으로 변경해주는 것

인스턴스 사용의 장점

클래스를 재료로 사용할 때 세분화시키고 싶다면 인스턴스로 부분적으로 각각 다른 네이밍과 기능을 지정해 사용할 수 있다

 - 전처럼 중복된 코드를 계속 바꿀 필요 없이, 파라미터 ****가 필요하면 p1 인스턴스를 불러오고 +가 필요하면 p2를 부르면된다

전체코드

// OOP 5. 인스턴스

class Print05 {
	public String delimiter = ""; 
	public void A() {
		// ... 1억줄 코드
		System.out.println(delimiter); // printA() 메소드 안에  delimiter가 없다면
		System.out.println("A");	   // 이 파일 클래스(메인 메소드 위에)에서 찾아서 사용
		System.out.println("A");	   // 
	}
	public void B() {
		// ... 1억줄 코드
		System.out.println(delimiter);
		System.out.println("B");
		System.out.println("B");
	}
}

public class OOP05 {
	public static void main(String[] args) {
	
	// 클래스 : 원형본
	// 인스턴스 : 복제본
	//
	// 원형본인 클래스에서 인스턴스를 만들고 새변수에 담아두고 이 인스턴스의 메소드를 호출하므로써
	// 이 인스턴스를 조작할 수 있게되는 메커니즘
	
//		Print05.delimiter = "----";	
//		Print05.A();					
//		Print05.A();	
//	
//		Print05.delimiter = "====";	
//		Print05.B();
//		Print05.B();		
//	
//		Print05.delimiter = "----";
//		Print05.A();
//		Print05.delimiter = "====";
//		Print05.B();
		
		
	// 위와 같이 계속 변수의 파라미터를 계속 바꿔서 써야하는 상황이라면?
	// 이럴 때 인스턴스 사용
	
	// static : statice 뒤에 오는 String(변수(?))이 클래스소속이라는 의미
	// 고로 위에 클래스 안 메소드에서 static 삭제
	Print05 p1 = new Print05();
	p1.delimiter = "****";
	p1.A();
	p1.A();
	p1.B();
	p1.B();

	Print05 p2 = new Print05();
	p2.delimiter = "++++";
	p2.A();
	p2.A();
	p2.B();
	p2.B();
	// 전처럼 중복된 코드를 계속 바꿀 필요 없이,
	// 파라미터 ****가 필요하면 p1 인스턴스를 불러오고 +가 필요하면 p2를 부르면된다

	}
}

JAVA 객체 지향 프로그래밍 - 2. 남의 클래스 & 남의 인스턴스

OOP(objected Oriented Programming)

System.out.println(Math.PI);
// 결과값 : 3.141592653589793

math라고 하는 클래스에 PI라는 변수가 있는 것이고, 그 변수 안에 3.14의 구체적인 숫자가 적당한 정밀도로 적혀있는 것

System.out.println(Math.PI);
System.out.println(Math.floor(1.8)); // 내림
System.out.println(Math.ceil(1.8));  // 올림

Math는 클래스이고, 클래스 안에는 수학과 관련된 PI라고 하는 변수도 있고 floor,ceil과 같은 메소드들도 들어 있는 것.

즉, 코드가 많아짐에 따라서 서로 연관된 같은 주제를 가지고 있는 변수와 메소드를 그루핑한 껍데기가 클래스

FileWriter f1 = new FileWriter(”data.txt”)

new를 붙이므로써 FileWriter라는 클래스의 복제본f1을 만들겠다

FileWriter f1 = new FileWriter("data.txt"); // new를 붙이므로써 FileWriter라는 클래스의 복제본을 만들겠다
f1.write("Hello");
f1.write("Java");
f1.close();

일회용으로 작업을 끝내면 되는 것들은 메소드나 변수를 클래스에 소속된 그냥 클래스에 있는거 그냥 사용합니다

ex) Math.floor()나 Math.ceil()

하지만 긴 맥락을 가지고 작업해야하는 것들은 클래스를 직접 사용하지 않고 인스턴스를 사용해서 복제본을 사용해서 관리한다

ex) f1인스턴스를 계속 write write close까지 길게 여러번

		FileWriter f1 = new FileWriter("data.txt"); // FileWriter의 복사본
		f1.write("Hello");
		f1.write("Java");

				
		FileWriter f2 = new FileWriter("data2.txt"); // FileWriter의 또 다른 복사본
		f2.write("Hello");
		f2.write("Java2");
		f2.close();
		
		f1.write("!!!");  				// 긴 맥락의 작업
		f1.close();

아래에서

클래스 : System, Math, FileWriter

인스턴스 : f1, f2

import java.io.FileWriter;
import java.io.IOException;

public class OOP02 {

	public static void main(String[] args) throws IOException {
		// class : System, Math, FileWriter
		// Instance : f1, f2 
		System.out.println(Math.PI);
		System.out.println(Math.floor(1.8));
		System.out.println(Math.ceil(1.8));
		
		FileWriter f1 = new FileWriter("data.txt"); // FileWriter의 복사본
		f1.write("Hello");
		f1.write("Java");

				
		FileWriter f2 = new FileWriter("data2.txt"); // FileWriter의 또 다른 복사본
		f2.write("Hello");
		f2.write("Java2");
		f2.close();
		
		f1.write("!!!");  				// 긴 맥락의 작업
		f1.close();
	}
}

1.메소드
2.클래스 소속 메소드
3.인스턴스 소속 메소드

1.메소드 형태

2.클래스 소속 메소드 형태

3.인스턴스 소속 클래스 형태

마지막 결과값 중 null은

last3();에서 구분자 안줘서 null

1.메소드

2.클래스 소속 메소드 a,b,c,d

3.인스턴스 소속 메소드 a,b,c,d

1.메소드

2.클래스 소속 메소드 a,b,c,d

3.인스턴스 소속 메소드 a,b,c,d

JAVA1 - 14.9. 나의 앱 만들기 - 메소드(Method)

만약 아래의 변수에 들어가는 식이 엄청나게 복잡하다면….?

이 복잡한 식들을 getVAT()같은 이름으로 바꾸고 복잡한 식들을 숨겨놓은다면 이 앱이 더 심플해질 것

double valueOfSupply = Double.parseDouble(arg[0]);
double vatRate = 0.1;
double expenseRate = 0.3;
double vat = valueOfSupply * vatRate;
double total = valueOfSupply + vat;
double expense = valueOfSupply * expenseRate;
double income = valueOfSupply - expense;

double dividend1 = income * 0.5;
double dividend2 = income * 0.3;
double dividend3 = income * 0.2;

이클립스 Refactor - 메소드로 변경 기능

[바꾸기를 원하는 코드 선택 우클릭 Refactor ] - [Extract Method]

메소드 이름을 getVAT로 이름 지었고 아래에 private static… return 문장이 새로생겼다

메소드 작동 메커니즘

1번 변수valueOfSupply의 값인 10000.0이 2번 getVAT의 valueOfSupply로 넣어짐

2번의 2번을 거친 valueOfSupply는 다시 메소드로 만들어진 3번의 getVAT의 valueOfSupply 값이 넣어지고

4번은 메소드를 만드는 코드. 이 메소드에서 최종 계산된 값이 return코드를 통해 2반getVAT로 들어간다.

*이 메소드를 통해 1억줄의 코드도 간단하게 해결가능

코드를 더 깔끔하게 하고자 getVAT() 안에 값을 지운다면?

위의 valueOfSupply있어서 될 것 같은데 에러가난다 why?

valueOfSupply가 현재 main {} 안에서 선언됬기 때문

즉, main메소드 안에서만 작동하는 지역변수(local variable)

 - 해결 : 모든 매소드에서 접근할 수 있도록, main메소드 밖에서 선언해줄 것

이클립스 Refactor - 지역변수→전역변수 변경 기능

[바꾸기를 원하는 코드 위에서 좌클릭하고 우클릭 Refactor] - [Convert Local Variable to Field]

각 변수의 식마다 메소드 설정 & 지역변수 to 전역변수로 변경

프린트코드는 한번에 지정해서 메소드설정

*자바에서는 전역변수(Global Variable)를 필드(Field)라고함

메소드(Method)란?

서로 연관된 코드를 모아서 다시말해서 그루핑(grouping)해서 이름을 붙인 정리정돈의 상자다

JAVA1 - 14.10. 나의 앱 만들기 - 클래스(Class)

많은 라이브러리들이 객체지향 방법으로 만들어졌기에 객체지향이 대강 뭔지는 알아둘 필요가 있다

객체는 클래스라는 표현을 쓰기도 함(완전히 동일한건x)

클래스(Class)란?

서로 연관된 메소드와 변수를 그루핑(grouping)한 것. 그리고 거기에 naming한 것.

정리정돈의 상자이다

앱에 여러가지 기능들이 많이 붙고

변수와 메소드가 앱에 너무 많으면 햇갈리고 생산성이 많이 떨어지게 된다

이런 상황에서 도움이 되는 것이 바로 클래스(class)

컴퓨터로 치면 디렉토리로 파일 정리하는 격

클래스(Class)를 써서 정리하기

1)전역변수 세개를 Class Accounting 안으로 이동

(public static double valueOfSupply, vatRate, expenseRate;)

2)밑에 모여있는 메소드들도 Class Accounting 안으로 이동

 - 혹시 앞에 public이 아니라 private이라면 public으로

3)public static void main(String[] args) { 아래 valueOfSupply,vatRate, expenseRate,print 4개의 변수명 앞에

클래스명인 Accounting.을 붙여주면 전과 같은 기능으로 작동

*나중에 public과 private 차이 점 알아보자

JAVA1 - 14.11. 나의 앱 만들기 - 인스턴스(Instance)

인스턴스(Instance)는

하나의 클래스를 복제해서 서로 다른 데이터의 값과 서로 같은 메소드를 가진 복제본을 만드는 것이다

메인메소드 안에

Accounting.valueOfSupply = 10000.0;
Accounting.vatRate = 0.1;
Accounting.expenseRate = 0.3;
Accounting.print();

이런 물건들이 몇천개 있다고 할 때, 어쩌다가 새상품이 하나 들어왔다고 해보자

위의 4개코드의 과정을 새상품이 들어올 때마다 다 세팅해줘야한다

ex)

Accounting.valueOfSupply = 10000.0;
Accounting.vatRate = 0.1;
Accounting.expenseRate = 0.3;
Accounting.print();

Accounting.valueOfSupply = 20000.0;
Accounting.vatRate = 0.05;
Accounting.expenseRate = 0.2;
Accounting.print();

   . 
   .
   .

이런 과정이 여러번 반복되다보면

이 클래스의 내부적인 상태를 바꾸는 행위가 버그를 유발할 가능성이 굉장히 높다

프로그래밍을 잘하는 사람이라면 이렇게 바꿀 것

Accounting class의 이름을 Accounting1으로 변경하고 카피해서 Accounting2,3,4 계속 만들고

아래와 같이 클래스별로 따로 값을 관리한다

# main{} 안에 있는

Accounting1.valueOfSupply = 10000.0;
Accounting1.vatRate = 0.1;
Accounting1.expenseRate = 0.3;
Accounting1.print();

Accounting2.valueOfSupply = 20000.0;
Accounting2.vatRate = 0.5;
Accounting2.expenseRate = 0.2;
Accounting2.print();

클래스를 복제해서 서로 다른 상태, 서로 같은 메소드를 갖도록 한 것

하나의 클래스를 돌려막기한 것이 아니라, 복제된 클래스를 이용해서 더 편리하고 더 버그가 적은

코딩을 할 수 있게 된 것

그런데 이것도 좋지만 클래스의 정보를 바꿀려면 만든 모든 클래스의 정보를 바꿔줘야하기에

많이 번거로워질 것(클래스를 생성할 때마다, 정보를 일일히 다 추가해줘야함…)

자바를 만든 사람들은 클래스라는 것을 복제할 수 있는 기능을 만들었다

Accounting 앞에 new를 붙여 복제

new Accounting();

Accounting a1 = new Accounting();

변수a1 앞에 Accounting을 붙여서 a1변수값에는 반드시 Accounting의 복제본만 들어올 수 있다라고 명시를 해줌

Accounting a1 = new Accounting();
a1.valueOfSupply = 10000.0;
a1.vatRate = 0.1;
a1.expenseRate = 0.3;
a1.print();

Accounting a2 = new Accounting();
a2.valueOfSupply = 50000.0;
a2.vatRate = 0.5;
a2.expenseRate = 0.5;
a2.print();

이렇게 복제가 가능하고, 여기서 다시 a1.print();를 해도 정상적으로 잘 작동함

클래스를 복제하지 않아도 된다

인스턴스(Instance)란?

class 앞에 new를 붙여서 만들어진 무언가가 인스턴스

*인스턴스를 썼으면 맨 위에 class Accounting에서 public 다음 static이 사용되면 안되기에 지워야함

※ 자바에서는 메소드로 구조를 잡고

메소드와 변수를 grouping해서 클래스로 구조를 또 잡고

클래스를 복제한 인스턴스를 통해서 또 다른 구조를 만드는 구조가 자바와 다른 컴퓨터 언어들의 특징

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고 하는 클래스이름을 적는 것