플레이스토어 병아리게임 출시!!!~~ [많은 이용 부탁드립니다!]

package token;

import java.util.StringTokenizer;

public class ToeknExam {

	public static void main(String[] args) {
	
		String text = "홍길동/이수홍/박연수";
		
		StringTokenizer st = new StringTokenizer(text,"/");
		// "/" 기준으로 분리함
		int countTokens = st.countTokens();
		for (int i = 0 ; i < countTokens; i++) {
			String token = st.nextToken(); // 토큰 한개 pop
			System.out.println(token);
		}
		
		System.out.println();

			st = new StringTokenizer(text,"/");
			while(st.hasMoreTokens()) { // 토큰이 남아있는가
				String token = st.nextToken();
				System.out.println(token);
			}
	}
}

토큰이란 계주를 하는 것과 비슷합니다. 바톤을 들고 자기 역할을 다 하면 다른 사람한테 전달해주는 거 처럼

자기가 토큰이란 걸 가지고 있다가 자기가 할 일을 다 하면 전달해주는 거라고 생각하시면 됩니다.

이걸로 어떤 일을 할 수 있냐면 위에 코드와 같이 StringTokenizer로 /로 구분되어 있는 String형을 받아서

"/"로 나눠서 배열에 저장하는 거마냥 구분합니다.

그리고 countTokens로 몇개로 구분되어 있는지 갯수를 셉니다.

그리고 처음 토큰은 0번째 인덱스라고 해야할까요 홍길동한테 있지 않고 아예 다른 곳에 보존되어 있습니다.

그걸 nextToken()을 통해서 넘겨줍니다. 이런식으로 for문을 countTokens만큼 돌 수도 있지만

hasMoreTokens()라는 메소드를 통해서 토큰이 아예 다른 곳에 보존된 곳 홍길동 이수홍 박연수가 가지고 있는지 

확인시키고 가지고 있을시 True를 반환해줍니다.

결국 박연수가 자기 다음으로 토큰반환소에 주면 false를 반환해서 while문을 탈출합니다.

https://github.com/SungJLee/My_Java_World.git

package casting_methods;

public class CastingMethods {

	public static void main(String[] args) {

		System.out.println("*********** 문자열 -> 기본타입(정수, 실수) 변환Test ******");
		
		int value1 = Integer.parseInt("10");
		
		double value2 = Double.parseDouble("3.14");
		
		System.out.println("Value1 : " + value1);
		System.out.println("Value2 : " + value2);
		
		System.out.println("*********** 기본타입(정수, 실수) -> 문자열 변환Test ******");
		
		String str1 = String.valueOf(10); 
		String str2 = String.valueOf(10.5);
		
		System.out.println(str1);
		System.out.println(str2);
		
		System.out.println("*********** 객체 -> 문자열 변환Test ******");
		
		Integer obj1 = 300;
		Double obj2 = 111.11;
		
		String str3 = Integer.toString(obj1);
		String str4 = Double.toString(obj2);
		
		System.out.println(str3);
		System.out.println(str4);

	}

}

형변환하는 메소드에 대해서 알아보도록 하겠습니다.

Integer.parseInt는 문자열을 int형으로 변환시킵니다.

Double.parseDouble은 문자열을 double형으로 변환시킵니다.

여기서 공통점이 있죠? 바꿀 기본자료형.parse바꿀 기본자료형으로 하시면 됩니다(첫 글자는 대문자!!)

다시 String형으로 바꾸려면 String.valueOf를 사용할 수도 있고

Integer.toString() 즉 자료형.toString으로 쓸수도 있습니다.

https://github.com/SungJLee/My_Java_World.git

package java_method;

public class Methods {

	public static void main(String[] args) {
		
		Object obj = new Object();
		System.out.println(obj.toString()); // toString() Object를 문자열로 표현
		
//		----------------------------------------------------------------------------------------
		
		long time1 = System.currentTimeMillis(); 
		int sum = 0;
		
		for (int i = 1 ; i <= 1000000; i++) {
			sum = sum + i;
		}
		
		long time2 =  System.currentTimeMillis();

		System.out.println("1 ~ 1000000까지 합 "+sum);
		System.out.println("계산에 " + (time2 - time1) + "밀리초가 소요되었습니다.");
		
//		----------------------------------------------------------------------------------------
		
		String ssn = "7345354252";
		int length = ssn.length();
		
		if (length == 13) {
			System.out.println("주민번호 자리수가 맞습니다.");
		}else
		{
			System.out.println("주민번호 자리수가 틀립니다.");
		}
		
//		----------------------------------------------------------------------------------------
		
		String oldStr = "자바는 객체지향언어 입니다. 자바는 풍부한 API를 지원합니다.";
		String newStr = oldStr.replace("자바", "Java"); // 자바라는 것을 Java로 바꾼다
		
		System.out.println(oldStr);
		System.out.println(newStr);
		
//		----------------------------------------------------------------------------------------
		
		String ssn2 = "880815-1234567 ";
		
		String firstNum = ssn2.substring(0,6); // 880815 : 0 ~ 6까지
		System.out.println(firstNum);
		
		String secondNum = ssn2.substring(3); // 815-1234567 : 3개 제외한 모든 것 (공백 들어가있음)
		System.out.println(secondNum);
		
//		----------------------------------------------------------------------------------------
		String str1 = "Java Programing";
		String str2 = "JAVA Programing";
		
		System.out.println(str1.equals(str2)); // false
		
//		----------------------------------------------------------------------------------------
		
		String lowerStr1 = str1.toUpperCase(); // 대문자 변환 JAVA PROGRAMING
		System.out.println(lowerStr1);
		
		String lowerStr2 = str2.toLowerCase(); // 소문자 변환 java programing
		System.out.println(lowerStr2);

//		----------------------------------------------------------------------------------------
		
		String tel1 = " 02"; 
		String tel2 = "123   ";
		String tel3 = "    1234  ";
		
		String tel = tel1.trim() + tel2.trim() + tel3.trim(); // 공백 없애기
		
		System.out.println(tel); //021231234

//		----------------------------------------------------------------------------------------
		
		String str3 = String.valueOf(10); // 문자열로 변환
		String str4 = String.valueOf(10.5); // 문자열로 변환
		String str5 = String.valueOf(true); // 문자열로 변환
		
		System.out.println(str3); // 10
		System.out.println(str4); // 10.5
		System.out.println(str5); // true
		
//		----------------------------------------------------------------------------------------
		
		String str6 = "togeth";
		String str7 = "er";
		
		String str8 = str6.concat(str7); // together
		System.out.println(str8);
		
		String str9 = str6 + str7; // together
		System.out.println(str9);
		
		
	}

}

toString()

     String형으로 형변환하는 것을 의미합니다.

Object obj = new Object(); 여기에서 Object라는게 있는데 Object도 자료형입니다.

기본 int float 등의 자료형을 모두 포함하는 조상 자료형입니다.

float가 int형보다 더 많이 표현 가능하고 int형을 다 표현할 수 있는 거 처럼 모든 자료형들의 조상입니다.

여기에서 보면 우리가 클래스를 만들 때 무심코 지나쳤지만

java.lang.Object라고 되어있죠? 기본적으로 Object형을 상속받아서 쓴다는 의미입니다.

또한 컨트롤 누르고 Object에 가져다대면 밑줄이 나오는데 그걸 누르면

그 Objec에 관한 클래스 정보가 들어있는 곳으로 이동이 가능합니다.

이런식으로 자바를 만든 사람이 사람들이 쓰기 편하라고 String Array등 이런식으로 만들어놨기 때문에

우리는 편하게 쓰기만 하면 되는 겁니다.

currentTimeMillis()

     실행하고 저 함수를 쓴 부분까지의 밀리초를 재줍니다.

length()

     문자열의 길이를 재줍니다.

replace()

     문자를 바꿔줍니다.

substring()

     문자열의 범위로 표현해줍니다.

equals()

     객체를 비교할 때 씁니다. == 와 혼동할 수 있는데 기본 자료형 제외하고

     String같은 객체는 무조건 equals로 해야합니다. 그에 대한 이유는 메모리 저장구조에 있는데

     참조형(Reference Type)의 데이터 타입을 갖는 객체, 배열 등은 Heap 영역에 데이터가 저장됩니다.

     데이터는 Heap 영역에 저장되고 그에 해당하는 객체들이 데이터를 가르킵니다. 이렇기 때문에

     equals로 주소값을 비교한다고 생각하시면 됩니다.

toUpperCase()

     소문자 문자열을 대문자로 다 바꿔줍니다.

toLowerCase()

     대문자를 소문자로 다 바꿔줍니다.

trim()

     문자열에 들어있는 공백을 없애줍니다.

String.valueOf(), 

     문자열로 변환시켜줍니다. 

     toString()은 null값일시 NullPointException 오류를 내보냅니다.

     String.valueOf()은 파라미터가 null이면 문자열 "null"을 만들어서 반환을 하는 점에서 자릅니다.

concat()

     문자열과 문자열을 연결해주는 역할을 해줍니다.

https://github.com/SungJLee/My_Java_World.git

package interface_inheritance;

public interface Animal {
	void species();
	void sex();
}

package interface_inheritance;

public interface Human {
	void name();
	void age();
}

package interface_inheritance;

public class Integreated implements Animal, Human{
	String name;
	int age;
	String sex;
	String species;
	
	public Integreated(String name, int age , String sex , String species) {
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.species = species;
	}

	@Override
	public void species() {
		System.out.println("이 동물은 " + this.species);
	}

	@Override
	public void sex() {
		System.out.println("성별은 " + this.sex);
		
	}

	@Override
	public void name() {
		System.out.println("이름은 " + this.name);
	}

	@Override
	public void age() {
		System.out.println("나이는 " + this.age);
	}
}

package interface_inheritance;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integreated it = new Integreated("king",25,"Lion","수컷");
		
		it.age();
		it.name();
		it.sex();
		it.species();
	}

}

public class Integreated implements Animal, Human 이런식으로 다중으로 interface를 상속받을 수 있습니다.

public class 클래스명 implements 인터페이스명, 인터페이스명

이번에는 interface에 쓰이는 default와 고정상수에 대해서 알아보겠습니다.

코드는 어디서 가져온 거라 꽤 긴데 중요한 부분만 이야기하겠습니다.

package interface_exam2;

public interface Bank {
	//상수 : 인터페이스에서 값을 정해줄테니 함부로 바꾸지 말고 제공해주는 값만 참조해라 (절대적)
    public int MAX_INTEGER = 10000000;
     
    //추상메소드(인출하는 메소드)
    void withDraw(int price);
     
    //추상메소드(입금하는 메소드)
    void deposit(int price);
     
    //JAVA8에서 가능한 defualt 메소드(고객의 휴면계좌 찾아주는 메소드 : 필수구현은 선택사항)
    //디폴트메소드 : 인터페이스에서 기본적으로 제공해주지만, 맘에 안들면 각자 구현해서 써라. (선택적) 
    default String findDormancyAccount(String custId){
        System.out.println("**금융개정법안 00이후 고객의 휴면계좌 찾아주기 운동**");
        System.out.println("**금융결제원에서 제공하는 로직**");
        return "00은행 000-000-0000-00";
    }
}

package interface_exam2;

public class KBBank implements Bank{
	@Override
    public void withDraw(int price) {
        System.out.print("KB은행만의 인출 로직...");
        if(price < Bank.MAX_INTEGER){
            System.out.println(price+" 원을 인출한다.");  
        }else{
            System.out.println(price+" 원을 인출실패.");  
        }
    }
 
    @Override
    public void deposit(int price) {
        System.out.println("KB은행만의 입금 로직..."+price+" 원을 입금한다.");
     
    }
}

package interface_exam2;

public class SHBank implements Bank{
	@Override
    public void withDraw(int price) {
        System.out.println("SH은행만의 인출 로직...");
        if(price < Bank.MAX_INTEGER){
            System.out.println(price+" 원을 인출한다.");  
        }else{
            System.out.println(price+" 원을 인출실패.");
        }
    }
 
    @Override
    public void deposit(int price) {
        System.out.println("SH은행만의 입금 로직..."+price+" 원을 입금한다.");
        System.out.println("SH은행은 별도의 후행처리 작업을 따로 한다.");
     
    }
     
    //JAVA8에서 가능한 defualt 메소드(고객의 휴면계좌 찾아주는 메소드)
    // 디폴트메소드 : 인터페이스에서 기본적으로 제공해주지만, 맘에 안들면 각자 구현해서 써라. (선택적)
    @Override
    public String findDormancyAccount(String custId){
        System.out.println("**금융개정법안 00이후 고객의 휴면계좌 찾아주기 운동**");
        System.out.println("*SH은행만의 로직 적용*");
        return "00은행 000-000-0000-00";
    }
}

package interface_exam2;

public class Main {

	public static void main(String[] args)
	{
			Bank bank = new KBBank();
	        bank.withDraw(100);
	        bank.deposit(100);
	        bank.findDormancyAccount("763231");
	         
	        System.out.println("\n*************인스턴스 교체!!***************\n");
	         
	        bank = new SHBank();
	        bank.withDraw(100);
	        bank.deposit(100);
	        bank.findDormancyAccount("4311");
	        
	        /*
	         * public class KakaoBank{

				    public void kakaoWithDraw(int price) {
				        System.out.print("Kakao은행만의 인출 로직...");
				        System.out.println(price+" 원을 인출한다.");  
				    }
				 
				    public void kakaoDeposit(int price) {
				        System.out.println("Kakao은행만의 입금 로직..."+price+" 원을 입금한다.");
				    }
				     
				    public void kakaoFindDormancyAccount(){
				        System.out.println("kakao은행만의 휴면계좌 찾아주기 로직");
				    }
	 	       }
	         */
	         
	        // 마지막으로 아래 신규 인터넷 은행사 카카오뱅크 코드를 보자. 위 코드에서 볼 수 있듯이 
	        // 카카오뱅크는 인터페이스를 implements를 하지 않은 채 자신만의 메소드를 구현했다. 
	        // 어떤 문제점이 있을까? 당연...금융결제원에서 제공해주는 그 어떠한 서비스도 사용할 수 없으며
	        //  호환성이 없으며 연동이 불가할 것이다. 

		

	}

}

  default String findDormancyAccount(String custId){
        System.out.println("**금융개정법안 00이후 고객의 휴면계좌 찾아주기 운동**");
        System.out.println("**금융결제원에서 제공하는 로직**");
        return "00은행 000-000-0000-00";
    } 

여기서 default로 설정하고 interface에다 추상메소드를 만든 경우 필수구현이 아니라 선택사항이 됩니다.

여기서 interface를 쓰는 이유중 하나가 또 나오는데 안 쓰고 만들어도 무방한데 금융결제원에서 제공해주는

어떤 서비스도 사용할 수 없으면 호환성이 없고 연동이 불가능하게 됩니다.

이렇게 interface를 제공해주면 쉽게 프로그램을 개발할 수 있게 해주죠 

public int MAX_INTEGER = 10000000;

상수를 선언할 수도 있는데 이 경우에는 고정값으로 절대 변경할 수 없습니다.

package overriding;

public class Airplane {
	public void land() {
		System.out.println("착륙합니다");
	}
	public void fly() {
		System.out.println("일반비행합니다.");
	}
	public void takeOff() {
		System.out.println("이륙합니다.");
	}
}

package overriding;

public class SupersonicAirplane extends Airplane{
	public static final int NORMAL = 1;
	public static final int SUPERSONIC =2;
	
	public int flyMode = NORMAL;
	
	@Override
	public void fly() {
		if(flyMode == SUPERSONIC) {
			System.out.println("초음속비행합니다");
		}else {
			super.fly(); // 부모 메소드 불러옴 부모에서 정의된 필드도 가져올 수 있음[전역만]
		}
	}
}

package overriding;

public class SupersnoicAirPlaneExample {

	public static void main(String[] args) {
		SupersonicAirplane sa = new SupersonicAirplane();
		sa.takeOff();
		sa.fly(); // 자식객체를 sa로 만들었기 때문에 자식 메소드 override 실행
		sa.flyMode = SupersonicAirplane.SUPERSONIC;
		sa.fly();
		sa.flyMode = SupersonicAirplane.NORMAL;
		sa.fly();
		sa.land();
	}

}

부모 클래스에 이렇게 fly가 정의 되어있는데

public void fly() {
    System.out.println("일반비행합니다.");
}

자식에 경우 이 fly를 쓰고 싶은데 내용을 다르게 쓰고 싶습니다. 그러한 경우에는 오버라이드를 하시면됩니다.

@Override라고 적고 내용을 자식이 사용하고 싶은데로 쓰시면 됩니다. 

즉 재정의라고 불리는 Override는 정말 많은 곳에 쓰입니다.

@Override
public void fly() {
if(flyMode == SUPERSONIC) {
     System.out.println("초음속비행합니다");
}else {
     super.fly(); // 부모 메소드 불러옴 부모에서 정의된 필드도 가져올 수 있음[전역만]
   }
}

https://github.com/SungJLee/My_Java_World.git

package Inheritance_super;

public class People {
	public String name = "장첸";
	public String ssn;
	
	public People(){
		this.name ="없음";
		this.ssn = "000";
	}
	
	public People(String name, String ssn) {
	this.name = name;
	this.ssn = ssn;
	}
}

package Inheritance_super;

public class Student extends People{
	public int studentNo = 1;
	
	public Student(String real_name, String ssn, int studentNo) {
//		this.name = name; 불가능
//		this.ssn = ssn; 불가능
//		
		super(real_name, ssn);
		// People의 메소드 People(String name , String ssn)을 호출
		this.studentNo = studentNo;
	}

	public Student() {
		this("X","X",0);
	}
	
	public void test() {
		System.out.println("부모 name : " + super.name);
		System.out.println("자식 name : " + this.name);
		
		super.name = "김철수";
		System.out.println("자식 name " + this.name);
		System.out.println("부모 name " + super.name);
		// super.name = People의 name에 접근
	}
}

package Inheritance_super;

public class Teacher extends People{
	String name ="Teacher";
	
	void childMethod() {
		System.out.println("this.x(Teacher)" + this.name);
		System.out.println("super.x(People)" + super.name);
	}
}

package Inheritance_super;

public class StudentExample {

	public static void main(String[] args) {
		Student student = new Student("홍길동" , "123456-1234567",1);
		Student student2 = new Student();
		Teacher teacher = new Teacher();
		
		System.out.println("name : "+ student.name);
		System.out.println("ssn : " + student.ssn);		
		System.out.println("studentNo : " + student.studentNo);
		
		
		
		System.out.println();
		
		student.test(); 
		System.out.println();
		
		student2.test();
		System.out.println();
		
		teacher.childMethod();

	}

}

super()은 부모의 생성자를 의미합니다. super()만 적을시에 부모 기본적인 생성자를 의미하고

super(매개변수, 매개변수...) 이러한 형태의 생성자가 있을 시에 매개변수를 받을 수 있는 구조라면

public Student(String real_name, String ssn, int studentNo){....}

매개변수를 받는 생성자를 불러와서 적용시킵니다.

자식이 생성자를 만들 때 super()를 쓰면 부모의 Default내용이 들어가게 됩니다.

나머지 추가 속성이 자식한테 있으면 그 부분만 설정해주면됩니다.

super를 안 쓰고 this.studentNo = stduentNo만 쓸시 부모에 "장첸"이라고 적힌 게 Default로 들어가게 됩니다.

여기에선 매개변수를 안 받는 생성자가 있기 때문에 그 생성자가 Default값이 되어서 

name = "없음"이 들어가게 되는 것입니다.

this()은 자신 클래스의 또다른 생성자를 의미합니다.

super.name으로 부모의 name에 접근할 수 있습니다. 기본적인 생성자(매개변수 없는)가 없는 경우에는

super.name 에 없음이 아니라 장첸이 나옵니다.

https://github.com/SungJLee/My_Java_World.git

package overriding;

public class CellPhone {
		//필드
		String model;
		String color;
		
		// 메소드
		void powerOn() { System.out.println("전원을 켭니다.");}
		void bell() { System.out.println("벨이 울립니다.");}
		void sendVoice(String message) {System.out.println("자기 : " + message);}
		void receiveVoice(String message) { System.out.println("상대방 : " + message);}
		void hangUp() {System.out.println("전화를 끊습니다.");}
		void powerOff() { System.out.println("전원을 끕니다.");}
}

package overriding;

public class DmbCellPhone extends CellPhone{
	int channel;
	// 생성자
	DmbCellPhone(String model, String color , int channel){
		this.model = model;
		this.color = color;
		this.channel = channel;
	}
	
	//메소드
	
	void turnOnDmb() {
		System.out.println("채널 " + channel + " 번 DMB 방송 수신을 시작합니다.");
	}
	void changeChannelDmb(int channel) {
		this.channel = channel;
		System.out.println("채널 " + channel + "번으로 바꿉니다");
	}
	void turnOffDmb() {
		System.out.println("DMB 방송 수신을 멈춥니다.");
	}
}
​

package overriding;

public class DmbCellPhoneExam {

	public static void main(String[] args) {
		//DmbCellPhone 객체 생성
		DmbCellPhone dmbCellPhone = new DmbCellPhone("자바폰","검정",10);
		
		//CellPhone으로부터 상속 받은 필드
		System.out.println("모델 " + dmbCellPhone.model);
		System.out.println("색상 " + dmbCellPhone.color);
		
		//DmbCellPhone의 필드
		System.out.println("채널 " + dmbCellPhone.channel);
		System.out.println();

		//CellPhone으로부터 상속 받은 메소드 호출
		dmbCellPhone.powerOn();
		dmbCellPhone.bell();
		dmbCellPhone.sendVoice("여보세요");
		dmbCellPhone.receiveVoice("안녕하세요! 저는 홍길동인데요");
		dmbCellPhone.hangUp();
		System.out.println();
		
		//DmbCellPhone의 메소드 호출
		dmbCellPhone.turnOnDmb();
		dmbCellPhone.changeChannelDmb(12);
		dmbCellPhone.turnOffDmb();

	}

}

상속이라는게 부모가 자식한테 재산 등을 물려줄 때 일반적으로 사용하는 말이죠?

똑같습니다. 여기에서는 CellPhone이라는 부모한테 DmbCellPhone이 물려받는 것입니다.

CellPhone이 더 큰 범위이기 때문에 부모인거죠

이렇게 쓰면 장점이 CellPhone의 기능 몇개는 DmbCellPhone과 겹치는데 하나하나씩 입력하기 힘듭니다.

(전화기능 , 문자기능 등...)

코드를 간략하게 할 수 있습니다.

상속받는 방법은 public class (내가 만든 클래스명) extends (부모 클래스명)입니다.

여기서는 public class DmbCellPhone extends CellPhone 가 되는 거죠

그러면 DmbCellPhone은 CellPhone의 변수와 메소드를 전부 사용할 수 있게 됩니다.

https://github.com/SungJLee/My_Java_World.git

캡슐화

객체의 무결성을 보장하기 위함입니다. 은닉성이라고도 하죠 직접적으로 접근할 수 없게 하는 건데

public으로 변수를 선언하는 경우는 접근이 가능하지만 private으로 선언하는 경우 직접 접근할 수 없습니다.

여기서 직접접근이란 .을 이용해 접근하는 걸 의미합니다.

이렇게 마음대로 접근해서 값을 바꾸면 price에 -500만원 이런식으로 넣을수 있기 때문에 그걸 막기 위해

데이터를 보존 보호하는 것입니다.

package setter_getter;

public class Car {
	public int speed;
	private int price;
	
}

package setter_getter;

public class CarExample {

	public static void main(String[] args) {
		Car myCar = new Car();
		
		myCar.speed = 0;
		myCar.price = 100; // 에러
	}
}

이런식으로 접근이 불가능합니다. 그래서 따로 함수를 통해서 접근해서 값을 변경하거나 추가할 수 있게 하는데

값을 설정하는데 Setter고 값을 출력하는데 Getter라고 일반적으로 불립니다.

이러한 Setter과 Getter로 이루어져있는 클래스를 POJO클래스라고도 불리죠

그러면 Getter는 왜 만들어야할까 private이라서 접근할 수도 없고

다른식으로 하면 데이터를 조작할 수도 있기 때문에 만든 것입니다.

이제 Setter와 Getter를 만들어보자

변수는 private으로 선언해주자

setter와 getter가 뭐냐면 set 즉 설정하는 겁니다. 생성자와 유사해보이지만 단일 변수값을 지정할 때 쓰입니다.

getter는 그 변수 값을 리턴해주는 것이고요

이걸 왜 쓰냐면 가장 기본적인 구조입니다. 

하나하나씩 만들수도 있지만 이러한 걸 이클립스에서 간단히 지원해줍니다.

package setter_getter;

public class Car {
	private int speed;
	private int price;
//	
	public int getSpeed() {
		return speed;
	}
	public void setSpeed(int speed) {
		this.speed = speed;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
}

그러면 이런식으로 만들기만 하면 되는 것인가? 일단 기본적인 구조이다 하지만 여기에서 좀 조작을 해주는게

더 좋다 예를 들어서 setPrice는 0보다는 무조건 커야하기 때문에 이러한 걸 넣어주면 된다.

package setter_getter;

public class Car {
	// punlic int speed;
	private int speed;
	private int price;
	
	public int getSpeed() {
		return speed;
	}
	public void setSpeed(int speed) {
		this.speed = speed;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		if(price >= 0) {
			this.price = price;
		}else {
			throw new IllegalArgumentException("가격은 음수가 될 수 없습니다.");
		}
		
	}
}

package setter_getter;

public class CarExample {

	public static void main(String[] args) {
		Car myCar = new Car();
		
//		myCar.speed = 0;
//		myCar.price = 100;

//		System.out.println(price);
		myCar.setSpeed(-50);
		
		System.out.println("현재속도 : " + myCar.getSpeed());
		
		myCar.setSpeed(60);
		
		System.out.println("현재속도 : " + myCar.getSpeed());
		
		myCar.setPrice(-500);

	}


}