개발새발, 써놓기

// 재귀호출
public class Ex08_recursion {
	public static void main(String[] args) {
		Test8 tt = new Test8();
		int s;
		
		s = tt.sum(10);
		System.out.println(s);

		s = tt.pow2(10);
		System.out.println(s);
		
		System.out.println(tt.pow(2, 5)); // 32.0
		System.out.println(tt.pow(2, -2)); //0.25
		
		// 최대공약수
		System.out.println(tt.gcd(12, 8)); // 4
		
	}
}

class Test8 {
	public int sum(int n) {
		return n>1 ? n+sum(n-1) : n;
	}
/*
		int s=0;
		for(int i=1; i<=n; i++){
			s+=i;
		}
		return s;
 */
		
	// 2의 x승 결과
	public int pow2(int n) {
		return n>=1 ? 2 * pow2(n-1) : 1;			
	}
	
	// x의 y승 결과
	public double pow(int x, int y) {
		if(y>=0) {
			return y>=1 ? x * pow(x, y-1) : 1;
		} else {
			return (1.0 / x) * pow(x, y+1);			
		}
	}
	
	// 최대공약수
	public int gcd(int a, int b) {
		return b==0 ? a : gcd(b, a%b);
	}
}

재귀호출 : 메소드에서 자신의 메소드를 다시 호출, 처리하지 못한 데이터는 스택!(저장공간)에 저장

// 재귀호출 : 메소드에서 자신의 메소드를 다시 호출. 처리하지 못한 데이터는 스택에 저장
public class Ex07_recursion {
	public static void main(String[] args) {
		Test7 ob = new Test7();
		ob.print(5);
		 // stack이 넘치면 StackOverflowError 발생
	}
}

class Test7 {
	public void print(int n) {
		if(n>1) {
			print(n-1); // 메소드에서 자신의 메소드를 호출
		}
		System.out.println(n);
		
	}
}

public class Ex06 {

	public static void main(String[] args) {
		Test6 ob1; // 레퍼런스 변수
		// ob1.print(); 컴오류. 메모리할당이 안되었으므로
		
		ob1 = new Test6(); // 메모리 할당이 되고 a=10, b=20으로 초기화 
		// 필드 a=10, b=20을 갖고 있는 주소값을 가지고 있다.
		Test6 ob2 = new Test6(); // 필드 a,b는 메모리 할당이 되고 a=10, b=20으로 초기화

		System.out.println(ob1 == ob2); // 주소가 같냐? false
		ob1.a+=100;
		System.out.println(ob1.a + ":"+ ob2.a); // 110 : 10
		
		Test6 ob3 = ob2; // ob와 ob3은 같은 주소를 나타낸다. 같은 객체
		System.out.println(ob2 == ob3); // 주소가 같냐? true
		ob3.a +=200;
		System.out.println(ob2.a+":"+ob3.a); // 210 : 210
		
		// 클래스명@해쉬코드 : 자바가 객체를 찾을 때 쓰는 코드 
		// 같은 객체는 해쉬코드가 같지만, 해쉬코드가 같다고 같은 객체는 아니다.★
		System.out.println(ob1); // ex0714.Test6@15db9742
		System.out.println(ob2); // ex0714.Test6@6d06d69c
		System.out.println(ob3); // ex0714.Test6@6d06d69c

	}

}

class Test6 {
	int a=10;
	int b=20;
	
	public void print() {
		System.out.println(a+":"+b);
	}
}

public class Ex05_method {
	public static void main(String[] args) {
		Test5 tt = new Test5();
		Test5 tt2 = new Test5();
		
		tt.x = 10; tt2.x = 10;
		tt.sub();
		System.out.println(tt.x+":"+tt2.x); // 15 : 10
		
		tt.x = 10; tt2.x = 10;
		tt.sub2(tt2);
		System.out.println(tt.x+":"+tt2.x); // 10 : 15

	}
}

class Test5 {
	int x;
	public void sub() {
		x+=5; // x는 메소드를 호출한 객체의 것 
	}
	public void sub2(Test5 t) { // call by reference
		t.x+=5;
	}
}

// 파라미터 전달 방법
public class Ex04_method {
	public static void main(String[] args) {
		Test4 tt = new Test4();

		int n = 5;
		
		// call by value
		tt.sub1(n);
		System.out.println(n); // 5

		// call by reference
		tt.sub2(tt); // tt객체의 주소값을 보냄
		System.out.println(tt.x); // 15
		
		int []ss = {10,20,30};
		tt.sub3(ss);
		System.out.println(ss[1]);
		// 실인수와 가인수의 자료형은 같아야함.
		
	}
}

class Test4 {
	int x=10;
	
	// call by value(기본) : 실매개 변수와 형식 매개변수가 기억공간 따로 확보
	public void sub1(int a) {
		a = a+10;
	}
	
	// call by reference : 레퍼런스변수(객체)
	public void sub2(Test4 t) { // tt의 주소값을 t가 받음. 자료형이 Test4임.
		// 보내는 것이 Test4의 레퍼런스변수 이므로 Test4의 레퍼런스변수로 받아야함
		// 다시만드는 것이 아님. 메모리할당이 아님.
		 t.x +=5;
	}	
	
	// call by reference : 레퍼런스변수(배열)
	public void sub3(int[] nn) {
		nn[1] += 100;
	
	}
		
}

public class Ex03_method {
	public static void main(String[] args) {
		Rect r = new Rect();
		
		int a, b;
		
		r.width = 10;
		r.height = 5;
		a = r.area();
		b = r.length();
		
		System.out.println("넓이:"+a+", 둘레:"+b);
		
	}
}

/*
  - 직사각형의 넓이와 둘레계산
    - 데이터(상태) : 가로, 세로
    - 메소드 : 넓이계산, 둘레계산
*/
class Rect {
	int width;
	int height;
	// 필드 선언 시, 자료형이 같아도 따로따로 선언한다.
	
	// 넓이 
	public int area() {
		return width * height;
	}
	
	// 둘레
	public int length() {
		return (width + height) * 2;
	}
	
}

public class Ex02_method {
	public static void main(String[] args) {
		Test2 ob = new Test2();
		
		String s;
		s=ob.isLeap(2021)? "윤년?" : "평년";
		System.out.println(s);
		
		int []a = {2,4,6,8,10};
		int n = ob.sum(a);
		System.out.println(n);
		
		int []num = ob.random(10);
		if(num != null) {
			for(int i=0; i<num.length; i++) {
				System.out.print(num[i]+"  ");
			}
			System.out.println();
		}
	}
}

class Test2 {
	public boolean isLeap(int y) {
		return y%4==0 || y%100 !=0 || y%400 == 0;
	}
	
	// 배열로 주어진 매개변수의 합 계산하기
	public int sum(int [] num) {
		int s=0;
		for(int n : num) {
			s+=n;
		}
		return s;
	}
	// 1~100 사이의 난수를 n개 발생하여 배열로 반환
	public int[] random(int n) {
		if(n<1) {
			return null;
		}
		
		int []a = new int[n];
		for(int i=0; i<a.length ; i++) {
			a[i] = (int)(Math.random() * 100) + 1;
		}
		
		return a; // 배열 주소 한 개를 보냄. // 그 배열의 주소 안에 값 n개가 있음
	}
}

public class Ex01_field {
	public static void main(String[] args) { 
		Test1 t1 = new Test1(); // 객체 생성. Test1 클래스의 a와 b필드가 메모리 할당받음.
		Test1 t2 = new Test1();
		
		t1.a=50;
		System.out.println(t1.a+ " : " + t2.a); // 50:0
		
		int s = t1.sub(10); // 지역변수와 매개변수는 호출 될 때 메모리 할당을 받음.
		System.out.println(s); 
		
		s = t1.sub(100);
		System.out.println(s);
		
		
/*
		// 클래스 변수를 객체를 통해서 접근 가능 하지만 권장하지 않음. (경고)
		t1.c = 50;
		System.out.println(t1.c+ " : " + t2.c); // 50:50 메모리 할당이 한 번만 되어서
*/
		
		System.out.println(Test1.c); // 클래스 변수는 클래스명으로 접근 
		
		
	}
}

class Test1 {
	// 필드 : 인스턴스 변수 + 클래스 변수
	
	// 인스턴스 변수
	// 인스턴스 변수는 객체가 생성될 때 메모리가 생성. 메모리를 할당 받을 때 기본값으로 초기화
	// 인스턴스 변수는 객체마다 메모리할당. heap 메모리 영역에 메모리할당 (자바가 메모리관리하는 부분임, 개발자가 관리 불가)
	// 인스턴스 변수는 객체가 null이 되거나 오랫동안 사용되지 않으면 Garbage collector가 메모리회수.
	// 객체에 종속되므로 객체를 통해서 접근 "객체명.인스턴스 변수" 로 접근
	int a; // 생성될때 0으로 초기화
	int b=10; // 생성될때 10으로 초기화
	
	// 클래스 변수
	// 클래스가 로딩될 때 메모리 할당. 
	// 객체 생성과 상관없이 하나만 메모리할당되고 모든 객체가 공유.
	// "클래스명.클래스 변수"로 접근
	// 프로그램이 종료되는 시점에 메모리에서 제거된다.
	static int c=100;
	
	// 매개변수, 지역변수 : 스택메모리 영역에 메모리 할당. 초기화하지 않으면 쓰레기값
	// 매개변수와 지역변수는 메소드를 호출할 때 메모리가 할당된고 메소드를 빠져나가면 메모리에서 제거됨.
	// 인스턴스 메소드 : 객체가 생성되어야 호출되는 메소드로 객체를 통해서 호출
	public int sub(int n) { // n:매개변수
		int s=0; // 지역변수
		for(int i=1; i<=n;i++) {
			s+=i;
		}
		return s;
	}
	
	// void는 메소드를 실행 후 결과를 호출한 곳으로 넘길 필요가 없는 경우 사용
	public void sub2() {
		// 인스턴스 변수는 클래스내의 모든 인스턴스 메소드에서 호출가능하다.
		System.out.println(a+" : "+b);
		
		int x = sub(5); // 다른 인스턴스 메소드도 호출 가능.
		System.out.println(x);
		
		// 클래스 메소드나 클래스 변수 호출 가능.
		System.out.println(c);
		demo2();
	}
	
	// 클래스 메소드 : 객체 생성과 상관없이 클래스 이름으로 호출하는 메소드
	public static void demo() {
		// 클래스메소드는 인스터스 변수나 인스턴스 메소드를 직접 호출 불가
		// System.out.println(a); // 컴파일 오류
		// tt.sub2(); // 컴파일 오류
		
		// 클래스 변수나 클래스 메소드는 호출 가능
		System.out.println(c);
		
		// 클래스 메소드에서 객체를 생성하여 인스턴스 변수나 인스턴스메소드 호출
		Test1 tt= new Test1();
		System.out.println(tt.a+" : "+tt.b);
		tt.sub2();
	}
	
	public static void demo2() {
		System.out.println("demo2 ...");
	}
	
}