개발새발, 써놓기

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 Ex03 {
	public static void main(String[] args) {
    	// Test3 tt - new Test3(); 컴파일 오류. 생성자가 private 이므로 외부에서 생성불가
        
        Test3 ob1 = Test3.getInstance();
        Test3 ob2 = Test3.getInstance();
        
        System.out.println(ob1);
        System.out.println(ob2);
        System.out.println(ob1 == ob2); 
    }
}

class Test3 {
	private static Test3 tt = null;
    
    private int a = 10;
    // 생성자가 private이면 외부에서 객체 생성불가
    private Test3(){
    }
    
    public static Test3 getInstance(){
    	if(tt == null) {
        	tt = new Test3();
        }
        return tt;
    }
    
    public void sub() {
    	System.out.println(a+":"+a);
    }
}

소프트웨어 디자인 패턴에서 싱글턴 패턴(Singleton pattern)을 따르는 클래스는, 생성자가 여러 차례 호출되더라도 실제로 생성되는 객체는 하나이고 최초 생성 이후에 호출된 생성자는 최초의 생성자가 생성한 객체를 리턴한다. 이와 같은 디자인 유형을 싱글턴 패턴이라고 한다.

출처 : https://ko.wikipedia.org/wiki/%EC%8B%B1%EA%B8%80%ED%84%B4_%ED%8C%A8%ED%84%B4

public class Ex02 {
	public static void main(String[] args){
    	System.out.println(Test2.a);
        
        Test2.a = 20;
        System.out.println(Test2.a);
        
        System.out.println(Test2.PI);
        // Test2.PI = 3.5; 컴오류. 값을 변경할 수 없음.
    }
}

class Test2 {
	public static int a = 10;
    // 한번만 초기화 되며 값을 변경할 수 없음. 파이널 변수는 보통 대문자로 만든다.
    public final stitic double PI = 3.141592;
    public final static int x;
    static { // statix 블럭에서 final static 변수 초기화
    	x = 5;
    }
    
    final int b = 10;
    final int c;
    
    public Test2() {
    	// x= 10; final static 변수는 생성자에서 초기화 불가.
        
        c = 10; // final 인스턴스 변수는 생성자에서 단 한번 초기화 가능.
    }
    
    public void sub() {
    	// c = 5; 컴오류. instance final 변수의 값은 일반 메소드에서 변경 불가
    }
    
}

public class Ex01 {
	public static void main(String[] args) {
    	Test1 tt; // 이 시점은 클래스가 로딩되는 시점이 아님.
        
        // 클래스가 로딩되는 시점은 객체를 생성하거나 클래스 변수, 클래스 메소드를 사용하는 시점.
        System.out.println(Test1.y);
        
        tt = new Test1();
        tt.print();
        
        Test1 ob = new Test1();
        ob.print();
    }
}

클래스가 로딩 될 때 한 번 실행

1. 클래스 변수 메모리 할당 - 메소드 영역
2. 클래스 변수를 디폴트 값으로 초기화
3. 초기화 변수 수식 실행
4. static 초기화 블록 실행

객체를 생성할 때 마다 실행

1. new Test1(); - 객체를 위한 메모리 할당(인스턴스 변수의 메모리 할당) : a, b, c, d
2. 모든 인스턴스 변수는 디폴트 값으로 초기화 : a<- 0, b <- 0, c <-0, d <- 0
3. 초기화 수식으로 초기화(존재하는 경우) : b <- 1
4. 초기화 블록 실행(존재하는 경우) : d <- 5
5. 생성자 몸체 실행

• 생성자 몸체에서 첫번째 문장의 super([인수]); 또는 this([인수]) 실행
• 생성자 몸체 실행
• c <- 10 생성자...

class Test1 {

	private int a;
    private int b=1;
    private int c;
    private int d;
    
    public static int x=10;
    public static int y;
    
    static {
    	// static변수의 초기화, 한 번만 실행 : 클래스가 로딩 될 때
        y = 20;
        System.out.println("static 초기화 블럭");
    }
    
    {	//인스턴스 초기화 블럭(객체가 생성될 때 마다 실행)
    	d = 5;
        System.out.println("초기화 블럭"); // 거의 쓰지 않는다.
    }
    
    public Test1() {
    	c = 10;
        System.out.println("생성자 ...");
    }
    
    public void print() {
    	System.out.println(a+":"+b+":"+c+":"+d);
    }
    
}

public vlass Ex09_this {
	public static void main(String[] args){
    Test9 t = new Test9();
    
    t.set(50);
    t.print();
    
    Test9.sub(10);
    System.out.println("Test9.b:"+Test9.b);
    }
}

class Test9 {
	private int a;
    public static int b=10;
    
    public void set(int a) {
    	this.a = a;
    }
    
    public void print() {
    	System.out.println("a: "+a);
    }
    
    public static void sub(int b) {
    	// b = b+ 10;
        // this.b = b + 10;
        // 컴 오류. static메소드 (클래스메소드)에서는 this사용이 불가하다. 
        // 클래스 메소드는 객체 생성과 상관이 없기 때문임.
        // this는 호출한 객체를 의미한다.
        Test9.b = b + 10;
    }
}

인스턴스 필드, 인스턴스 메소드는 "객체.필드" "객체.메소드" 로 접근

클래스 필드, 클래스 메소드는 "클래스명.필드" "클래스명.메소드"로 접근

public class Ex08_this {
	public static void main(String[] args) {
    	Test8 t = new Test8("김자바");
        t.print();
    }
}

class Test8 {
	private String name;
    private int age;
    
    public Test8(){
    	System.out.println("인자가 없는 생성자");
    }
    public Test8(String name) {
    	this(name, 0); // 다른 생성자를 호출. 생성자 선두에 단 한번만 가능
        System.out.println("인자가 하나인 생성자");
    }
    public Test8(String name, int age) {
    	this.name = name;
        this.age = age;
        System.out.println("인자가 두 개인 생성자");
    }
    public void print(){
    	System.out.println(name+":"+age);
    }
}

public class Ex07_this {
	public static void main(String[] args) {
    	Test7 ob = new Test7();
        // ob.age = 20; 컴 오류. private은 외부에서 접근 불가
        // 직접접근이 불가능 하기 때문에 name과 age를 줄 다른 방법을 찾아야 한다.
        ob.setName("홍길동");
        ob.setAge(20);
        
        System.out.println(ob.getName()+"님은 "+ob.getAge()+obresult());
        // 요즘 선호하는 코딩방식은 생성자로 값을 넘기는 방식
        // setter의 값을 변경할 수 있기 때문.
    }
}

class Test7 {
	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 String result() {
    	return age>=19? "성인":"미성년자";
    }
    
}

public class Ex06_this {
	public static void main(String[] args) {
    	Test6 t = new Test6();
        t.set(5);
        t.print();
        
        Test6 t2 = new Test6();
        t2.set(3);
        t2.print();    
    }
}

class Test6 {

	private int a;
    private int b;
    
    public void set(int b) {
    	// this : 호출한 객체
    	this.a = 10;
        this.b = b + 100;
        // this.b : 호출한 객체의 필드, b : 매개변수
    }
    
    public void print() {
    	System.out.println("a: "+this.a+", b: "+this.b);
    }
}