개발새발, 써놓기

punlic class Ex03{
	public static void main(String[] args){
    	Test3 t1 = new Test3();
        t1.setName("홍길동");
        t1.setAge(20);
        
        Test3 t2 = t1; // t1, t2 : 동일한 영역을 참조.
        System.out.println(t1 == t2);
        
        t1.print();
        t2.print();
        
        Test3 tt = new Test3();
        tt.setName("홍길동");
        tt.setAge(20);
        System.out.println(t1 == tt);
        
        // Object clone() : 새로운 객체를 생성하여 필드 값을 복사(객체 복제)
        Test3 t3 = (Test3) t1.clone();
        System.out.println(t1 == t3);
        t3.print();
    }
}

class Test3 implements Cloneable { // Cloneable 인터페이스 구현
	private String name;
    private int age;
    
    public String getName() {
    	return name;
    }
    public void setName(String name) {
    	this.name = name;
    }
    public int getAge() {
    	return age;
    }
    public void setAge(int age) {
    	this.age = age;
    }
    public void print() {
    	System.out.println(name+":"+age);
    }
    public Object clone() { // clone() 메솓, 재정의(override)
    	Object obj = null;
        
        try {
        	obj = super.clone();
        } catch (Exception e) {
        }
        return obj;
    }
    
}

t1, t2  는 동일한 영역을 참조하기 때문에 t1 == t2 는 true

tt는 new로 객체를 새롭게 생성했기 때문에 t1 == tt 는 false

public class Ex02 {
	public static void main(String[] args) {
    	// Test2의 상위 클래스 : Object
        Test2 t1 = new Test2();
        Test2 t2 = new Test2();
        Test2 t3 = t1;
        
        // toString() 메소드는 Object 메소드로 "클래스명@해쉬코드"를 반환한다.
        // 해쉬코드 : JVM이 해당 객체를 빠르게 검색할 수 있도록 만들어진 값.
        // 동일한 객체는 해쉬코드가 같지만, 해쉬코드가 같다고 동일한 객체는 아니다.
        // Object 클래스 : 모든 클래스의 최상위 클래스
        // 상위 클래스의 public, protected 접근제어자의 메소드나 필드는 모든 하위 클래스에서 사용 가능하다.
        System.out.println(t1.toString());
        System.out.println(t1);
        
        System.out.println( t1 == t2 );
        System.out.println(t1.equals(t2));
        
        System.out.println(t1.equals(t2));
        
        System.out.println(t1.equals(t3));
        
        System.out.println(t1.hashCode()); // 10 진수로 출력
        System.out.println("%h\n", t1.hashCode()); // 16진수로 출력        
    }
}

class Test2 {
}

동일한 객체는 해쉬코드가 같지만, 해쉬코드가 같다고 동일한 객체는 아니다.

// *은 그 안에 있는 모든 것을 import 하겠다는 의미!

import java.util.Scanner;
import static java.lang.Math.*;
// ctrl+shift+o : 자동 import
public class Ex01 {
	public satic void main(String[] args){
    	// java.util.Scanner sc = new java.util.Scanner(System.in); 
        // Scanner 는 현재 폴더 안에 없기 때문에 사용할 때 package 명을 넣어 불러온다.
        Scanner sc = new Scanner(System.in);
        // String name; // String은 import를 안해도 Java가 알아서 해준다.
        
        int r;
        double a;
        
        System.out.print("반지름 ? ");
        r = sc.nextInt();
        
        // a = r * r * Math.PI;
        a = r * r * PI; // Math package안에 있는 PI (클래스 변수) 
        System.out.println(a);
        
        sc.close;
    }
}

import java.util.Calendar;

public class Ex04{
	public static void main(String[] args) {
    	Calendar cal = Calendar.getInstance();
        System.out.printf("%tF %rA %tT\n", cal, cal, cal);
        
        MyCalendar mc = new MyCalendar();
        System.out.println(mc.getDate());
    }
}

class MyCalendar {
	private int year;
    private int month;
    private int date;
    
    public MyCalendar() {
    	Calendar cal = Calendar.getInstance();
        // 오늘 컴퓨터 시스템 시간 및 날짜로 Calendar 객체 생성
        
        year = cal.get(Calendar.YEAR);
        month = cal.get(Calendar.MONTH)+1;
        // cla.get(Calendar.MONTH) : 0~11
        date = cal.get(Calendar.DATE);
        
        // Calendar 객체에서 가져온 값들을 MyCalendar의 필드에 초기화 시켜줌.
    }
    
    public MyCalendar(int year, int month, int date) {
    	this.year = year;
        this.month = month;
        this.date = date;
    }
    
    public String getDate() {
    	String s = year + "年" + month + "月" + date + "日";
        return s;
    }
    
}

자바자체에서 Calendar를 손쉽게 가져와서 쓸 수 있게 해놓은 기능이 있어서 굳이 MyCalendar로 안해도 되지만, 어떻게 도는지 알기 위해서 !

// 재귀호출 : 메소드에서 자신의 메소드를 다시 호출. 처리하지 못한 데이터는 스택에 저장
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);
		
	}
}

class Test7 {
	// 접근제어 리턴타입 메소드명(매개변수타입 매개변수명)
	// 매개변수는 지역변수로 메소드안에서만 사용 가능
	public int sum(int n) { 
    // 매개변수 : (위에서 변수를 받기 때문에 자료형이 더 커야함
    // 1~부터 n까지의 합
		int s=0; // 지역변수. 메소드안에서만 사용가능
		for(int i=1; i<=n; i++) {
			s+=i;
		}
		return s; // 반환값을 가지고 호출한 곳으로 돌아감.
	}
	 // 짝수인지 판별하는 메소드
	public boolean isEven(int n) { // 리턴타입이 있을 경우 리턴을 써야함!	
		return n%2==0;
	}

	// 매개변수로 주어진 문자가 소문자이면 대문자로 변환하는 메소드
	public char upper(char c) {
		return c>='a' && c<='z' ? (char)(c-32) : c;
	}
	
	// 매개변수로 주어진 문자가 소문자이면 true, 그렇지 않으면 false
	public boolean isLower(char c) {
	return c>='a' && c<='z' ;
	}
	
	// 두개의 매개변수로 주어진 정수중 큰 수를 반환하는 메소드
	public int max(int x, int y) {
		return x>y? x : y;
	}
	
	// 매개변수로 주어진 구구단 출력. 단 주어진 매개변수가 1~9사이의 수가 아니면 아무것도 출력하지 않음.
	// void 리턴 타입 : 메소드를 실행하고 호출한 곳으로 값을 반환 할 필요가 없을 때 사용
	// void 리턴 타입인 경우에는 return; 처럼 마지막에 return문을 기술하지만 생략가능
	public void gugudan(int dan) {
		if(dan<1 || dan>9) {
			return; // return을 만나면 메소드는 실행을 멈추고 호출한 곳으로 복귀
		}
		for(int i=1; i<=9; i++) {
			System.out.printf("%d * %d = %2d\n", dan, i, dan*i);
		}
		return; // void에서는 생략 가능 
	}
	
	// 점수에 따른 평점 계산
	// 95~100ㅣ4.5, 90~94:4.0 ... 59~0 : 0.0
	public double grade(int score) {
		double s = 0.0;
		
		if(score>=95) s=4.5;
		else if(score>=90) s=4.0;
		else if(score>=85) s=3.5;
		else if(score>=80) s=3.0;
		else if(score>=75) s=2.5;
		else if(score>=70) s=2.0;
		else if(score>=65) s=1.5;
		else if(score>=60) s=1.0;
		else s = 0.0;
		
		return s;
	}
	
	
}

원래 하나의 클래스에는 하나의 기능만을 넣어야 한다. 단일책임의 원칙 ( 응집도를 높이기 위함)

이번 포스팅에서는 method의 예를 보기위해 여러개의 기능을 같이 넣었다. 

(실제 코딩시에는 이렇게 하면 안된다!!)

public class Ex07_method {
	public static void main(String[] args) {
		Test7 tt = new Test7();
		int result;
		
		result = tt.sum(10);
		System.out.println(result);
		
		result = tt.sum(100);
		System.out.println(result);
		
		boolean b;
		b = tt.isEven(13);
		System.out.println(b);
		
		char c;
		c = tt.upper('a');
		System.out.println(c);
		
		c = tt.upper('9');
		System.out.println(c);
		
		result = tt.max(5,  10);
		System.out.println(result);
		
		tt.gugudan(7);
		
		double g = tt.grade(85);
		System.out.println(g);
		
	}
}

class Test6 {
	int a=10;
    int b;
    // 인스턴스 변수
    
    public void print() {
    	System.out.println(a+ " : " +b);
    // 인스턴스 메소드
    }
}

public class Ex06_class {
	public static void main(String[] args) {
    
    	Test6 t1 = new Test6();
        Test6 t2 = new Test6();
        
        t2.b=20;
        
        t1.print();
        t2.print();
        
        t2 = t1;
        // t1의 주소를 t2에 넣는다. 
        // t2의 주소를 저장하고 있는 곳이 없으므로 garbage collector의 회수 대상이 되어
        // 메모리를 회수한다.
        
        t1.print();
        t2.print();
    
    }
}

class Test5 {
	int a=10;
    int b;
    // 인스턴스 변수
    
    public void print(){
    	System.out.println(a+ " : "+b);
    // 인스턴스 메소드
    }
}

public class Ex05_class {
	public static void main(String[] args) {
    // 참조 변수(메모리를 할당 받은)만큼 필드는 메모리를 할당 받는다.
    Test5 ob1 = new Test5();
    Test5 ob2 = new Test5();
    
    ob1.b=100;
    System.out.println(ob1.a+ " : " +ob1.b);
    System.out.println(ob2.a+ " : " +ob2.b);
    
    System.out.println(ob1 == ob2);
    // ob1과 ob2는 다른 주소값을 갖는다.
    
    Test5 t1 = new Test5();
    Test5 t2 = t1;
    // t2는 객체를 선언하고 t1의 메모리를 받는다.
    
    t2.b = 200;
    
    System.out.println(t1.a+ " : " +t1.b);
	System.out.println(t2.a+ " : " +t2.b);
    
    System.out.println(t1 == t2);
    // t1과 t2는 같은 주소이다.
    }
}