반응형
반응형
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()

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

 

for (int i = 1 ; i <= 1000000; i++) {
    sum = sum + i;
}

이 for문이 실행하기 전에 한번 시간을 재고 ( long time1 = System.currentTimeMillis(); )
끝나고 나서 시간을 재서 ( long time2 =  System.currentTimeMillis(); )

 

 

length()

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

 

replace()

     문자를 바꿔줍니다.

String newStr = oldStr.replace("자바", "Java"); 여기에서 보면 자바라는 단어를 Java로 바꿉니다.

 

    

substring()

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

     

ssn2.substring(0,6); 은 0 ~ 5번째 인덱스까지 표현해줍니다.
ssn2.substring(3); 은 2번째 인덱스부터 끝까지 표현해줍니다.

 

 

equals()

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

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

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

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

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

 

str1.equals(str2) 는 str1 과 str2는 주소값이 같냐 이 말입니다.

 

 

toUpperCase()

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

 

toLowerCase()

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

 

trim()

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

 

String.valueOf(), 

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

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

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

 

concat()

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

 

String str8 = str6.concat(str7);은 str6의 문자열(togeth)과 str7의 문자열(er)를 합쳐줍니다.

 

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

 

SungJLee/My_Java_World

Contribute to SungJLee/My_Java_World development by creating an account on GitHub.

github.com

 

반응형
반응형
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

 

SungJLee/My_Java_World

Contribute to SungJLee/My_Java_World development by creating an account on GitHub.

github.com

 

 

반응형
반응형

 

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

 

 

SungJLee/My_Java_World

Contribute to SungJLee/My_Java_World development by creating an account on GitHub.

github.com

 

반응형
반응형
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

 

SungJLee/My_Java_World

Contribute to SungJLee/My_Java_World development by creating an account on GitHub.

github.com

 

반응형
반응형

캡슐화

 

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

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

	}


}

 

반응형
반응형
package constructor;

public class Car {
	String model; // this.model임
	int speed;
	
	//생성자
	Car(String model){
		this.model = model; // model은 매개변수
       // Car 클래스 형태를 가진 model과 클래스안에 model 과 구분짓기위해
	}
	
	void setSpeed(int speed) {
		this.speed = speed;
	}
	
	void run() {
		for (int i = 10 ; i <= 50 ; i = i + 10) {
			//this.setSpeed(i);
			setSpeed(i);
			System.out.println(this.model + "가 달립니다. (시속 : " 
			+ this.speed + "km/h)");
		}
	}
}
package constructor;

public class CarExample {

	public static void main(String[] args) {
		
		Car car = new Car("포르쉐"); 
        // 생성자가 있으면 반드시 그 양식에 맞게 매개변수 넣어야 함
		
		car.run();

	}

}

 

저번 시간에 이어서 이번엔 함수 만드는 방법에 대해서 알아봅시다

 

클래스에 변수도 들어갈 수 있지만 함수도 들어갈 수 있습니다.

 

함수는 원래 있던 걸 써도 되지만 자기가 만들어서 사용도 가능합니다.

 

void setSpeed(int speed) {
     this.speed = speed;
}

 

함수를 만들 때는 위나 아래쪽에 한쪽에 몰아서 써주세요 

 

void(반환타입) setSpeed(메소드명) int speed (매개변수)

반환타입에는 void, int , long..  다양하게 선언이 가능합니다.

반환타입이 무엇이냐면 이 메소드를 실행 시켰을 때 결과 값을 주는 겁니다. void는 아무것도 반환해주지 않고

 

예를들어서 정수를 더하는 함수를 제가 만들어보겠습니다.

 

int sum (int A , int B){

   int total = A + B;

   return total;

}

------------------------------------------------------------


System.out.print(sum(3,4));

int hab = sum(3,4);
System.out.println(hab);

 

이런식으로 A와 B를 받아서 더하고 그걸 반환하는 함수를 만들겠습니다.

 

return 하는 값과 함수선언시 반환타입은 동일해야합니다.

 

합친 값을 줘서 그걸 출력해야하기 때문에

 

1.

    System.out.print(sum(3,4));

    반환값을 그냥 출력해버리기

2.

    int hab = sum(3,4);
    System.out.println(hab);

    hab이라는 int형에 담아서(return값과 동일해야함) 출력해버리기

 

이러한 거 때문에 return값이 필요합니다. 모든 자료형을 쓸 수 있기 때문에 필요할 때 적재적소로 활용하면 됩니다.

 

메소드명은 자기가 짓고 싶은대로 지으면 되고

매개변수를 뭐로 받을지에 대한 인자값도 자기가 원하는 만큼 설정해주시면 됩니다.

 

 

다시 돌아와서

 

void run() {
     for (int i = 10 ; i <= 50 ; i = i + 10) {
     //this.setSpeed(i);
     setSpeed(i);
     System.out.println(this.model + "가 달립니다. (시속 : "+ this.speed + "km/h)");
     }
}

 

만들어둔 setSpeed 함수를 이용해서 속도를 설정해주고 그것을 출력하고 반복문으로 50까지 올라가도록 합니다.

그리고 메인 클래스에서 car.run()으로 실행해줍니다.

 

함수도 접근법은 동일합니다.

 

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

 

SungJLee/My_Java_World

Contribute to SungJLee/My_Java_World development by creating an account on GitHub.

github.com

 

반응형
반응형
package constructor;

public class Car {
	String model; // this.model임
	int speed;
	
	//생성자
	Car(String model){
		this.model = model; // model은 매개변수
       // Car 클래스 형태를 가진 model과 클래스안에 model 과 구분짓기위해
	}
	
	void setSpeed(int speed) {
		this.speed = speed;
	}
	
	void run() {
		for (int i = 10 ; i <= 50 ; i = i + 10) {
			//this.setSpeed(i);
			setSpeed(i);
			System.out.println(this.model + "가 달립니다. (시속 : " 
			+ this.speed + "km/h)");
		}
	}
}
package constructor;

public class CarExample {

	public static void main(String[] args) {
		
		Car car = new Car("포르쉐"); 
        // 생성자가 있으면 반드시 그 양식에 맞게 매개변수 넣어야 함
		
		car.run();

	}

}

 

저번에 클래스를 공부했는데 이번엔 클래스의 생성자를 공부해보겠습니다.

 

저번에 차를 선언할 때 Car car = new Car(); 이런식으로 선언했는데 이렇게 선언하면

 

값이 다를 때 마다 car.compnay ="Google"; 이런식으로 계속 설정해줘야해서 번거롭습니다.

 

그래서 생성과 동시에 안에 특징 즉 변수에 값까지 넣어주는 과정이 생성자라고 생각하시면 됩니다.

 

생성자의 형태는 이렇습니다.

 


Car(String model){
   this.model = model;
}

 

Car[클래스명] String model[인자값]

이렇게 String형을 매개변수로 받는 함수를 만드는거 와 비슷합니다.

여기서 this란 자기 자신 즉 만들어진 객체 자기 자신을 가르키는 말입니다.

자기 자신의 model이라는 변수에 매개변수로 받은 model을 쓰겠다.

 

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

 

SungJLee/My_Java_World

Contribute to SungJLee/My_Java_World development by creating an account on GitHub.

github.com

 

반응형