221005

eclipse MethodEx04

package day04;

import java.util.Arrays;

public class MethodEx04 {
	public static void main(String[] args) {
	
		int[] arr = {1, 2, 3, 4, 5};
		
		String[] arr2= {"월", "화", "수"};
		
		method01(arr);//변수명 or 생성구문
		method02(arr, arr2);
		int[] arr3 = method03();
		String[] arr4 = "str".split("");
		
	}

	//정수배열을 매개변수로 하는 메서드
	
	static void method01(int[] a) {
		
		//a를 이용해서 배열값의 사용 가능
		System.out.println(Arrays.toString(a));
		
	}
//정수배열과, 문자열 배열을 매개변수로 받는 메서드	
	static int method02(int[] arr, String[] arr2) {
		
		for(int a : arr) {
			System.out.println(a);
		}
		return 0;
	}
//배열을 반환하는 메서드	
	static int[] method03() {
		
		int[] arr = new int[5];
		arr[0]=0;
		arr[1]=1;
		arr[2]=2;
		arr[3]=3;
		arr[4]=4;
		
		return arr;
		//return null;
	}
}

[1, 2, 3, 4, 5]
1
2
3
4
5

int 나 String뿐만 아니라, 배열도 매개변수로 받을 수 있다. 

eclipse Quiz23

import java.util.Arrays;

public class Quiz23 {
	public static void main(String[] args) {
		char[] arr = {'a','b','c'};
		String result = method6(arr);
		System.out.println(result);
		int[] arr2 = {1,2,3};
		System.out.println(method7(arr2));
		System.out.println(Arrays.toString(method8("홍길동","이순신")));
		
	}
	
	
	static String method6(char[] arr) {
		String s = "";
		for(int i=0;i<arr.length;i++) {
			s+=arr[i];
		}
		return s;
	}
	static int method7(int[] arr) {
		int sum = 0;
		for(int i : arr) {
			sum+=i;
		}
		return sum;
	}
	static String[] method8(String a, String b) {
		String[] str = new String[2];
		str[0]=a;
		str[1]=b;
		
		return str;
	}
	
}

abc
6
[홍길동, 이순신]

 매개변수가 배열이라고 해서 다르지 않다. 입력변수와 반환유형만 잘 확인하면 된다.

eclipse MethodEx05

package day04;

public class MethodEx05 {
	public static void main(String[] args) {
		
		//메서드의 (동기적) 실행-동기적:순서대로
		test01();
		//메서드의 (재귀적) 실행-자기 자신을 실행-반복. 쓸일이 많진 않다. 참고만.
		recursive(0);
		int result = fac(5);
		System.out.println(result);
	}
	
	static void test01() {
		System.out.println("1번 메서드 실행");
		test02();
		System.out.println("1번 메서드 종료");
	}
	static void test02() {
		System.out.println("2번 메서드 실행");
		System.out.println("2번 메서드 종료");
	}
	
	static void recursive(int a) {
		//재귀적 함수는 탈출의 구문을 반드시 명시한다.
		if(a==10) return;
		System.out.println(a+"번 호출");//10일때 멈춰서 sysout을 거치지 않는다.
		a++;
		recursive(a);
	}
	static int fac(int a) {
		if(a==1) return 1;//fac(1) =1
		return a*fac(a-1);
	}

}

1번 메서드 실행
2번 메서드 실행
2번 메서드 종료
1번 메서드 종료
0번 호출
1번 호출
2번 호출
3번 호출
4번 호출
5번 호출
6번 호출
7번 호출
8번 호출
9번 호출
120

동기적 실행-순서대로 실행한다는 뜻

재귀적 실행-자기 자신을 실행. 단, 오류가 발생하기 때문에 탈출구문을 반드시 명시해줘야 한다.

 

recursive메서드가 9번 호출까지만 출력하는 이유는 a가 10일때 return을 출력문 위에 적어서 더 이상 출력하지 않기 때문이다.

 

fac메서드는 fac(1)일때 1*fac(0)이 되는데 fac(0)은 0을 곱하기 때문에 return으로 1을 반환하고 종료시켜야 한다.

재귀적 메서드는 잘 사용하지 않아 참고만 하되, 어떻게 반복되는지를 직접 써보거나 이해하는 것이 좋다.

 

class의 활용

객체-컴퓨터 안에 무언가가 만들어졌을 때, 그것을 객체라고 부른다
instance -컴퓨터 안에 만들어진 것
최종적인 결과물이 객체. object

class-변수와 메서드 정의
필요하면 class를 생성해서 main에서 사용

펜을 만드는 틀(class)를 만들어 놓고, 
main에서 넣는 색깔에 따라 다른 펜이 나옴

new(생성하다)키워드를 이용해 class 사용. 만들어진 결과물을 객체라고 함.
붕어빵틀-class 만들어진 붕어빵-객체 

멤버변수-필드라고도 함. 속성.
{
바로 밑에 만들어짐. class안에서 제약없이 사용할 수 있음

메서드-기능

멤버변수
멤버변수는 클래스 바로 아래에 있음. 초기값을 지정하지 않아도 사용가능. 
객체를 생성할 때 각 데이터 타입의 기본 값으로 자동 초기화된다.
정수형 0, 실수형 0.0, 논리형 false, 객체 null
클래스 외부, 밖에서 사용가능

지역변수
메서드 안에서 선언되고, 그 안에서만 사용된다.
사용하기 전에 반드시 초기화해야 한다.
외부에서 사용 불가.
매개변수 역시 지역변수다. 메서드 안에서만 사용가능한 종류.

Calculator cal = new Calculator();
Calculator()는 뭘까? ->생성자.

생성자
new 키워드 다음에 오는 것
클래스 이름과 대/소문자까지 똑같이 만들고, 반환 타입을 적지 않는다(메서드가 아니다!).
객체를 생성할 때 필요한 멤버변수를 초기화하는 역할을 한다.

생성자는 클래스 안에 반드시 하나 있어야 한다.안적어도 자동으로 하나 만들어 준다.
new Calculator()->생성자를 만든다!

Calculator(){
}
로 똑같이 만들 수도 있다. 특징은 반환이 없다는 것. void도 아니고 그냥 없다.

생성자는 다른 유형으로 여러 개 만들 수 있다.
-()가 달려 있으니 외부에서 매개값을 받을 수도 있다.
-매개변수를 통해 다른 유형으로 만드는 것.
-생성자를 여러개 만드는 것을 생성자 오버로딩이라고 한다.
-매개변수의 이름이 같아도 순서가 바뀌면 다른 생성자로 인식함. 자바는 타입을 중시하기 때문

eclipse ObjectBasic01

package day05;

public class ObjectBasic01 {

	public static void main(String[] args) {
		//기존에 사용하던 계산기
		System.out.println("===1번 계산기===");
		System.out.println(add(5));
		System.out.println(add(10));
		System.out.println(add(100));

		System.out.println("===2번 계산기===");
		System.out.println(add2(100));
		System.out.println(add2(200));
		
		
	}

	//result에 매개값을 저장하는 1번 계산기
	static int result;//현재 범위는 class 전체
	static int add(int n) {
		result +=n;
		return result;
	}
	
	static int result2;
	static int add2(int n) {
		result2 +=n;
		return result2;
	}
}

===1번 계산기===
5
15
115
===2번 계산기===
100
300

멤버변수는 class 아래에 존재. 또한 선언만 한다. add메서드에 넣은 값들이 누적되는 것은 메서드를 사용할 때마다 추가해주기 때문. 

eclipse ObjectBasic02, Calculator

package day05;

public class ObjectBasic02 {
	public static void main(String[] args) {
		
		System.out.println("===1번 계산기===");
		Calculator cal = new Calculator();
		
		System.out.println(cal.add(1));
		System.out.println(cal.add(2));
		System.out.println(cal.add(3));
		
		
		System.out.println("===2번 계산기===");
		Calculator cal2 = new Calculator();
		
		System.out.println(cal2.add(100));
		System.out.println(cal2.add(200));
		
	}

}

package day05;

public class Calculator {
	int result;//현재 범위는 class 전체
	int add(int n) {
		result +=n;
		return result;

	}
}

===1번 계산기===
1
3
6
===2번 계산기===
100
300

계산기라는 class를 새로 만들고, 다른 class의 main에서 사용한다. 

두번 사용한다는 것은 두 개의 객체를 만든다는 것. 

클래스를 생성할 때 객체이름을 다르게 주면 된다. 위에선 cal과 cal2를 사용했다.

eclipse Pen, PenMain

package day05;

//대량 생산을 목적으로 하는 클래스는 메인이 없습니다.
public class Pen {

	//클래스에서 속성을 나타내는 것을 멤버변수(field) 라고 부릅니다.
	String color;
	int price;
	String company;
	//필드에서는 변수의 선언만 가능. 값을 바꾸는건 main에서. int price=0;을 하고 아래에 price=10;등을 넣어도 의미가 없다.
	
	//클래스에서 기능을 나타내는 것을 메서드로 부릅니다
	void write() {
		System.out.println(color +"글씨를 씁니다");
	}
	
	void info() {
		System.out.println("===펜의 정보===");
		System.out.println("색상:"+color);
		System.out.println("가격:"+price);
		System.out.println("제조사:"+company);
	}
	
	
}

 

package day05;

public class PenMain {
	public static void main(String[] args) {
		//펜의 기능을 사용할 때는 객체로 생성하고, 참조연산자 .을 사용합니다.
		Pen pen = new Pen();
		
		pen.color="검정";
		pen.price=1000;
		pen.company="모나미";
		pen.write();
		pen.info();
		System.out.println();
		Pen red = new Pen(); //new를 사용할 때마다 새로운 객체가 만들어지는 것.
		red.color="빨강";
		red.price=2000;
		red.company="모나미";
		red.write();
		red.info();
		
		Calculator cal = new Calculator();
		cal.add(1000);
		System.out.println(cal.add(2000));
		
	}

}

검정글씨를 씁니다
===펜의 정보===
색상:검정
가격:1000
제조사:모나미

빨강글씨를 씁니다
===펜의 정보===
색상:빨강
가격:2000
제조사:모나미
3000

class를 이루는 것은 멤버변수와 메서드, 그리고 후술할 생성자가 있다.

eclipse Variable, VariableMain

package day05;

public class Variable {
	
	//멤버변수: 초기화를 하지 않으면 기본값으로 자동 초기화
	String a;
	
	void printNum(int c) {
		int b=10;//지역변수는 초기값이 지정되어야 사용가능
		System.out.println("멤버:" +a);
		System.out.println("지역:" +b);
		System.out.println("매개:" +c);
	}
}

 

package day05;

public class VariableMain {
	public static void main(String[] args) {
		Variable var = new Variable(); //생성
		
		var.printNum(1000);
		
		var.a="바꿈!";
		var.printNum(1000);
	}
}

멤버:null
지역:10
매개:1000
멤버:바꿈!
지역:10
매개:1000

멤버변수는 생성자를 만들지 않으면 jvm가 알아서 초기화해 준다.

이때 int는 0, double은 0.0, boolean은 false, String은 null로 초기화된다.

멤버변수는 외부에서 사용할 수 있다. 이에 main에서 멤버변수(필드)를 바꿀 수 있다.

단 이때 생성된 객체를 통해 바꾸어준다. 위의 var.a형식이 그 예. 그냥 a=식으로 바꿀 순 없다.

eclipse Person, PersonMain

package quiz02;

public class Person {
	int age;
	String name;
	
	String info() {
		return "이름:"+name+" 나이:"+age;
	}
}

 

package quiz02;

public class Main {
	
	public static void main(String[] args) {
		
		/*
		 * Person 클래스를 파일로 정의
		 * 
		 * 멤버변수는 int age, String name
		 * 메서드 info(): String -멤버변수를 문자열로 더해서 반환
		 * 
		 * 메인에서는 Person 객체를 2개 생성해서 각각 확인
		 */
		
		Person p = new Person();
		p.age= 30;
		p.name="잭";
		System.out.println(p.info());
		
		Person p2 = new Person();
		p2.age=42;
		p2.name="헥터";
		System.out.println(p2.info());
		
	}
}

이름:잭 나이:30
이름:헥터 나이:42

+)숫자와 문자가 만나면 문자가 크므로 자동으로 문자로 바뀐다.

공부할 때 이게 되나 안되나 고민하기보단 해보고 안되면 이유를 읽고 원인을 파악하거나, 해보고 되면 이게 되네? 식으로 접근하는 쪽이 빠르다.

eclipse Phone, PhoneMain

package day05;

public class Phone {

	String model;
	int price;
	String color;
	
	//생성자
	//1. 클래스가 객체로 처음 생성될 때 불려나가는 친구
	//2. 이름은 클래스명과 동일
	//3. 생성자를 만들지 않으면 자동으로 생성해 줍니다.
	Phone(){
		System.out.println("생성자 호출됨");
		model = "애니콜";
		price = 1000;
		color="빨강";
	}
	//생성자는 여러개 일 수 있습니다. 단 모형이 달라야합니다.
	Phone(String pModel){
		model=pModel;
		price = 2000;
		color = "블루";
	}
	
	Phone(String pModel, int pPrice){
		model = pModel;
		price = pPrice;
		color = "블랙";
	}
	
	Phone(int pPrice, String pModel){ //이름이 같아도 순서가 바뀌면 다른 생성자로 인식함. 자바는 타입을 중시하기 때문
		model = pModel;
		price = pPrice;
		color = "화이트";
	}
	
	Phone(String pModel, int pPrice, String pColor){
		model = pModel;
		price = pPrice;
		color = pColor;
	}
	//이렇게 생성자를 여러 만드는 것을 생성자 오버로딩이라고 한다.
	
	void info() {
		System.out.println("===폰의 정보===");
		System.out.println("모델:"+model);
		System.out.println("가격:"+price);
		System.out.println("색상:"+color);
	}
}

 

package day05;

public class PhoneMain {
	public static void main(String[] args) {
		//객체 1
		Phone red =new Phone();
		red.info();
		
		//객체2
		Phone blue = new Phone("가로본능");
		blue.info();
		
		//객체3
		Phone black = new Phone("세로본능",3000);
		black.info();
		
		//객체4
		Phone White = new Phone(4000,"큐리텔");
		White.info();
		
		//모든 멤버변수를 매개변수로 받는 생성자를 만들고
		//초록, 10000, 아이폰
		
		Phone green = new Phone("아이폰",10000,"초록");
		green.info();
	}
}

생성자 호출됨
===폰의 정보===
모델:애니콜
가격:1000
색상:빨강
===폰의 정보===
모델:가로본능
가격:2000
색상:블루
===폰의 정보===
모델:세로본능
가격:3000
색상:블랙
===폰의 정보===
모델:큐리텔
가격:4000
색상:화이트
===폰의 정보===
모델:아이폰
가격:10000
색상:초록

생성자는 만들지 않을 경우 알아서 만들어지지만, 임의로 만들 수 있다.

생성자는 클래스가 객체로 처음 생성될 때 불려나가는 친구. 이름은 클래스명과 동일

이때 생긴 모습이 메서드와 굉장히 유사한데, 생성자는 반환 변수가 없다! 그것으로 구분하는 것.

 

생성자는 여러개일수도 있다. 단 유형이 달라야 하는데, 이는 매개변수를 통해 다른 유형으로 구분된다.

이때, 매개변수가 이미 만들었던 생성자에서 사용한 이름과 같더라도 순서만 다르면 다른 생성자로 인식된다. 

->자바는 타입을 중시하기 때문에.  생성자 3과 4가 다른 이유는 이 때문이다.

 

이렇게 생성자를 여러 번 만드는 것을 생성자 오버로딩이라고 한다.