728x90

 

없는 값을 체크 할 때 위의 둘을 쓰게 되는데

뭐가 다를까?

 

1. isEmpty()

인스턴스는 생성 되어있는 상태

but 안에 값은 비어있는 상태(정확하게는 ""으로 값이 들어가있는 상태)

    -  null과 공백데이터는 엄연히 다르다

java 1.6버젼에서 추가됨

ex) 빈 항아리

 

2. == null

null은 인스턴스가 생성되지 않은 상태

즉, 아무런 주소값을 가지고 있지 않는 상태이며, 값 자체가 존재하지 않음

ex)항아리 자체가 없음

 

 

 

직접 테스트해보자

// isEmpty() vs == null 차이
String testEmpty = "";
String testNull = null;

// 1. 공백값 & isEmpty() 체크
if(testEmpty.isEmpty()){
    System.out.println("1 : "+testEmpty);
}  

// 2. null & isEmpty() 체크
if(testNull.isEmpty()){
    System.out.println("2 : "+testNull);
} 

// 3. 공백값 & null 체크
if(testEmpty == null){
    System.out.println("3 : " + testEmpty);
}  

// 4. null & null 체크
if(testNull == null){
    System.out.println("4 : "+ testNull);
}

 

 

2번인 13라인에 NullPointerException 발생

공백 값이지만 값을 체크하는 거기 때문에 애초에 값 자체가 들어오지 않았기 때문에 NullPointerException이 발생한 것

 

 

2번을 주석처리하고 다시 돌려보면

조건이 true인 것만 발동하니 1,4번만 출력되는 걸 알 수 있다

3번은 공백에 null을 체크한거라 애초에 인스턴스가 존재하기 때문에 null 자체가 아니니 false이다

 

 

※ 비슷한 주제

 == vs equals

 

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

 

클래스 : 원형

인스턴스 : 복제본

 

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

 

 

 

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를 부르면된다

	}
}

 

 

728x90
반응형
728x90

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();
	}
}
728x90
반응형
728x90

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

 

 

 

 

 

728x90
반응형
728x90

 

1.메소드 형태

 

 

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

 

 

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

마지막 결과값 중 null은

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

728x90
반응형
728x90

 

1.메소드

 

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

 

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

 

 

1.메소드

 

 

 

 

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

 

 

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

 

 

728x90
반응형
728x90

 

JAVA method - 9. 부록 - static

public에 이어 바로 옆에 붙어나오는 static을 알아보자

(이해가 어려우니 추후 객체지향 수업에서 또 다룰 것임)

    static - class method
 no static - instance method

스태틱이라는 키워드가 붙은 메소드는 클래스의 메소드

스태틱이 없는 메소드는 인스턴스의 메소드

 

 

// JAVA method - 9. 부록 - static
//
// static

// 	  static - class method	
// no static - instance method
// 스태틱이라는 키워드가 붙은 메소드는 클래의 메소드다
// 스태틱이 없는 메소드는 인스턴스의 메소드다
	
	
// void 의미 : 리턴값이 없다
// 비슷한 성격의 메소드를 정리정돈하는 도구 : 클래스

class Print{
	public String delimiter; // static 안씀. 바로 아래 a,b()메소드 ()안에 값도 삭제하고,
							 // println()안 값도 String delimiter → this.delimiter로 수정
//	public static void a(String delimiter) { 
//  	System.out.println(delimiter); 
	public void a() { 
		System.out.println(this.delimiter);  // 이 this.delimiter는 아래 t1.delimiter = "----";의값
		System.out.println("a");
		System.out.println("a");
	}
//	public static void b(String delimiter) {
//		System.out.println(delimiter); 
	public void b() {						 // 메소드가 인스턴스 소속일 때는 static 제거해야함
		System.out.println(this.delimiter);
		System.out.println("b");
		System.out.println("b");
	}
	public static void c(String delimiter) { // static 추가
		System.out.println(delimiter);		 
		System.out.println("c");
		System.out.println("c");
	}
}

public class method09 {

	
	public static void main(String[] args) {

	
//		a("----"); // a,b메소드 둘 다 클래스 Print로 묶고, Print.을 붙여줘서 경로지정
//		b("===="); // 경로 변경으로 인한 에러 해결
		
//		Print.a("----"); // 이 코드가 1억줄이라면, 구분자를 변경해야할 때마다 곤욕...
//		Print.b("----"); // 이를 위해 아래처럼 인스턴스를 사용한다
		
								// 데이터타입이 Print클래스인 변수 t1이고,
		Print t1 = new Print(); // Print 클래스 복제. 인스턴스 : new Print()
		t1.delimiter = "----";  // Print의 인스턴스 t1은 내부적으로 구분자의 값이 ----가 됨
		t1.a();					// 좌측처럼 구분자를 추가하지 않아도 자동적용됨
		t1.b();					// 위의 Print.b("----");는 각 메소드마다 구분자를 정해준 것이고,
								// 인스턴스를 사용한 이녀석은 메소드마다 지정안해줘도 된다
		
//		Print.a("====");		// 클래스 Print 소속으로 실행됨
//		Print.b("====");
		
		Print t2 = new Print(); // t1처럼 같은 클래스를 복제한 것 뿐인데, 왜 에러뜨고 작동하지 않을까?
		t2.delimiter = "====";  // static의 유무에 따라 에러 on&off
		t2.a();					// 이 a()메소드는 t2 '인스턴스 소속'으로 실행됨
		t2.b();					// Print.a("====");의 a는 '클래스 Print 소속'으로 실행됨
		
								// 메소드가 인스턴스 소속일 때는 static을 빼줘야함
								// 메소드가 클래스 소속일 때는 static이 있어야함
		// Print.a();에서 Print.은 클래스이고 이렇게 실행하면 작동이 안되고 에러
		// a()라는 메소드는 클래스 소속이 아니고 인스턴스 소속이기 때문에 에러. static이 없기에 작동x
		// Print.a();를 작동시킬려면 static을 넣으면 클래스를 쓸 수 있다. 
		
		Print.c("++++");		// 클래스 소속 메소드로써 잘 작동
								// static을 위에서 추가시켜뒀기 때문
	}
}

 

  • static - class method

mesod_try.c("@@@@"); 

 

  • no static - instance method

 

mesod_try m1 = new mesod_try();
m1.delimiter = "아자아자";
m1.a();
m1.b();

 

728x90
반응형
728x90

 

 

 

 

 

 

 

 

728x90
반응형
728x90

JAVA method - 6. 메소드의 활용

 

메소드 사용의 장점

1.코드의 가독성↑

 - 1억줄의 코드에서 수많은 로직이 얽힌 코드를 이해해야할 때...?

2.재사용 용이 : 호출만 하면 됨

3.유지보수 관리 용이

 

public class method06 {
	public static void main(String[] args) {
	
			double valueOfSupply = 10000.0;
			double vatRate = 0.1;
			double vat = valueOfSupply * vatRate;
			double total = valueOfSupply * vat;

			System.out.println("Value of supply : " + valueOfSupply);
			System.out.println("VAT : " + vat);
			System.out.println("Total : " + total);
	}
}

메소드를 사용해 위의 코드를 아래의 코드처럼 간결하고 유지보지가 용이하게 바꿔보자

public class method06 {
	public static double valueOfSupply = 10000.0; // 공급가액
	public static double vatRate = 0.1;           // 부가가치 세율
	// public static이라 붙이는 의미 : 위의 method06 클래스의 직접적인 소속이라는 것

	public static double getVAT() {
		return valueOfSupply * vatRate;
	}
	public static double getTotal() {
		return valueOfSupply + getVAT();
	}
	
	public static void main(String[] args) {
	
		
	// 지역변수
//	double vat = valueOfSupply * vatRate;  // 부가세
	double vat = getVAT(); // 위와 같은 코드. get메소드 get변수명의 변수값을 가져온다
//	double total = valueOfSupply + vat;    // 합계
	double total = getTotal();
	
	
	System.out.println("Value of supply : " + valueOfSupply);
	System.out.println("VAT : " + vat);
	System.out.println("Total : " + total);

	// 메소드 사용의 장점
	// 1.코드의 가독성↑
	// 2.재사용 용이 : 호출만 하면 됨
	// 3.유지보수 관리 용이
	}
}

반복되는 코드들을 메소드화해서 메인메서드 밖에서 만들고, 지역변수를 전역변수화해서 이 클래스 안 전체에서 사용 가능케 전환

 

  • public static 붙이는 의미 : 위의 method06 클래스의 직접적인 소속이라는 것
  • get메소드 : get변수명의 변수값을 가져온다

 

 

 


 

 

JAVA method - 7. 수업을 마치며

메소드는 서로 연관된 명령을 그루핑해서 이름을 붙인 것

클래스는 서로 연관된 메소드와 변수를 그루핑해서 이름을 붙인 것

 

클래스(class)

많은 컴퓨터 언어들이 클래스의 개념을 갖고있지 않거나 처음에는 없다가 나중에 추가된 경우가 많다

메소드만으로도 할 수 있는 것이 많고, 충분히 혁명적

 

객체지향 프로그래밍(Object Oriented Programming, OOP)

서로 연관된 메소드와 변수를 그루핑해서 이름을 붙인 것이 클래스

이 클래스를 복제해서 서로 다른 내부상태를 가지고 있는 복제본들을 인스턴스

 

class & instance & object

클래스와 인스턴스를 우선 객체라고 생각해도 좋다

객체를 뼈대로 하는 프로그램을 만들어가는 프로그래밍 방법론을 객체지향 프로그래밍이라고 한다

 

많은 컴퓨터언어와 소프트웨어 객체지향 프로그래밍에 따라서 만들어지고 있다.

또한 남들이 만든 라이브러리가 OOP 방법에 따라 만들어져 있을 수도 있다

객체지향은 입문자가 중급자가 되는 길목에 있는 개념이라고 할 수 있다

코드의 양이 많아지고 남들과 공유해야할 일이 많아지고 있다면 객체지향을 공부할 시기

 

728x90
반응형

+ Recent posts