note for programming

생성자가 여러 차례 호출되더라로 실제로 생성되는 객체는 하나이고 최초 생성이후에 호출된 생성자는 최초의 생성자가 생성한 객체를 리턴한다.

1) Story

1. YGEnt는 하나뿐이므로 YGEnt가 여러번 new로 생성시킬 수 없다

2. getInstance()가 처음 호출될때 YGEnt의 객체를 new로 생성하고

    멤버변수와 getInstance()를 static으로 설정하여 class에 부속시킨다.

    생성자는 private으로 해 외부에서 new로 생성할 수 없게한다.

2) UML Class Diagram

3) Code

1.YGEnt를 new로 여러번 객체생성한다.

public class Main {

    public static void main(String[] args) {
        
        Entertainment entertainment1=new YGEnt();
        Entertainment entertainment2=new YGEnt();

        entertainment1.debut("위너");
        List<Singer> list = entertainment1.debut("빅뱅");
        
        System.out.println(entertainment1);
        System.out.println(entertainment2);
        System.out.println(list);
    }
}

entertainment1과 entertainment2의 hashcode 출력결과이다.

         factory.YGEnt@5c647e05
         factory.YGEnt@33909752

2. YGEnt를 getInstance()로 객체 생성하여 호출한다.

public class YGEnt extends AbstractEnt {

    private static YGEnt yGEnt;
    
    private YGEnt(){}
    
    @Override
    public int recruit() {
        int cnt=(int)(Math.random()*10+1);
        return cnt;
    }

    @Override
    public Singer train(String name, int memberCnt) {
        Singer singer;
        
        int cnt=(int)(Math.random()*2);
        if(cnt==0){
            singer=new BoyGroup(name,memberCnt);
        }else{
            singer=new GirlGroup(name, memberCnt);
        }
        
        return singer;
    }
    
    public static YGEnt getInstance(){
        if (yGEnt==null) {yGEnt=new YGEnt();}
        return yGEnt;
    }
}

public class Main2 {

    public static void main(String[] args) {
        
        Entertainment entertainment1=YGEnt.getInstance();
        Entertainment entertainment2=YGEnt.getInstance();
        
        System.out.println(entertainment1);
        System.out.println(entertainment2);
        
        List<Singer> list=entertainment1.debut("2NE1");
        System.out.println(list);
        
    }
}

entertainment1과 entertainment2의 hashcode 출력결과이다.

          singletone.YGEnt@70dea4e
          singletone.YGEnt@70dea4e

#Singletone Pattern은 캐시에 사용된다.

캐시는 캐시의 접근시간에 비해 원래 데이터를 접근하는 시간이 오래 걸리는 경우나 값을 다시 계산하는 시간을 절약하고 싶은 경우에 사용한다. 캐시에 데이터를 미리 복사해 놓으면 계산이나 접근 시간없이 더 빠른 속도로 데이터에 접근할 수 있다.

#CPU캐시

대용량의 메인 메모리 접근을 빠르게 하기 위해 CPU 칩 내부나 바로 옆에 탑재하는 작은 메모리이다. 1980년대 이후 대부분의 CPU는 하나, 많게는 5-6개까지의 서로 다른 기능을 가진 CPU 캐시를 장착하고 있다. 메모리 접근 속도가 늘어나는 것에 비해 CPU의 처리 속도가 훨씬 빠르게 늘어나고 있기 때문에, 용량은 작지만 속도가 빠른 CPU 캐시는 현대 마이크로프로세서의 성능에 직접적인 영향을 미친다.

#버퍼

버퍼(buffer,완충기억기)는 데이터를 한 곳에서 다른 한 곳으로 전송하는 동안 일시적으로 그 데이터를 보관하는 메모리의 영역이다. 버퍼링(buffering)이란 버퍼를 활용하는 방식 또는 버퍼를 채우는 동작을 말한다. 다른 말로 '큐(Queue)'라고도 표현한다.

버퍼는 컴퓨터 안의 프로세스 사이에서 데이터를 이동시킬 때 사용된다. 보통 데이터는 키보드와 같은 입력 장치로부터 받거나 프린터와 같은 출력 장치로 내보낼 때 버퍼 안에 저장된다. 이는 전자 통신의 버퍼와 비유할 수 있다. 버퍼는 하드웨어나 소프트웨어에 추가될 수 있지만 버퍼는 상당수가 소프트웨어에 추가된다. 버퍼는 보통 속도가 계속 바뀔 수 있으므로 데이터 수신, 처리 속도에 차이가 있다. (예: 프린터 스풀러)

버퍼는 네트워크 상에서 자료를 주고 받을 때나 스피커에 소리를 재생할 때, 또는 디스크 드라이브와 같은 하드웨어의 입출력을 결합하는 데에 자주 이용된다. 버퍼는 또한 순서대로 데이터를 출력하는 FIFO 방식에서 보통 사용된다.

#버퍼 캐시(buffer cache)는 최근 사용된 디스크 블록을 메모리에 캐시하는 것을 말한다.

디스크 입출력 시간이 메모리 접근 시간보다 크고, 디스크 블록의 접근 패턴에 지역성이 있기 때문에 디스크 블록의 정보를 메모리 공간에 저장해두면 읽기/쓰기 등의 작업시 응답시간을 줄일 수 있다.

가상 메모리는 MMU와 같은 하드웨어의 지원을 받는 반면, 버퍼 캐시는 그렇지 않다. 읽기와 쓰기 동작의 수행 결과가 실제 디스크의 내용과 비동기적이다.

Factory Method Pattern

Define an interface for creating a single object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

factory는 객체를 찍어낸다. 객체 생성과 객체 관리를 해주기 때문에 factory를 사용하는 부분에서 new로 객체를 생성할 필요가 없다.

modifier를 강제할 수 있다.

1) Story

1. YGEnt가 아이돌 그룹을 만든다: debut().
   아이돌 그룹은 profile()로 프로필을 확인할 수 있는 메서드를 가진다.
   YGEnt는 아이돌 그룹의 목록을 뽑아내는 list()메서드를 가진다.
2. Entertainment(interface)-AbstractEnt(abstract)-YGEnt순으로 class를 구현한다.
   boygroup과 girlgroup은 Singer interface를 구현한다.
3. debut()안에 다른 메서드들(recruit(),train())을 포함시켜 메서드의 외부노출이 불가능하다.

2) UML class diagram

3) Code

story1)

public class BoyGroup {
	int memberCnt;
	String name;
	
	BoyGroup(int memberCnt,String name) {
		this.memberCnt=memberCnt;
		this.name=name;
	}
	
	public int getMemberCnt() {
		return memberCnt;
	}
	public void setMemberCnt(int memberCnt) {
		this.memberCnt = memberCnt;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	public String toString() {
		return "{\"memberCnt\":" + memberCnt + ", \"Name\":\"" + name + "\"}";
	}
	
	public void profile(){
		System.out.println("memberCnt="+memberCnt+", name="+name);
	}
}

public class YGEnt {

	List list=new ArrayList();
	
	public BoyGroup debut(String name, int memberCnt){
		BoyGroup boyGroup=new BoyGroup(memberCnt,name);
		list.add(boyGroup);
		return boyGroup;
	}
	
	public List list(){
		return list;
	}
}

public class Main1 {

	public static void main(String[] args) {
		
		YGEnt yGEnt =new YGEnt();
		
		//BoyGroup boyGroupA = new BoyGroup(5,"빅뱅");
		BoyGroup boyGroupA = yGEnt.debut("빅뱅",5);
		BoyGroup boyGroupB = yGEnt.debut("위너",5);
		
		boyGroupA.profile();
		boyGroupB.profile();
		
		System.out.println(boyGroupA);
		System.out.println(boyGroupB);
		
		List list = yGEnt.list();
		System.out.println(list);
		
	}
}

story2)

public interface Entertainment {
	
	List debut(String name);
	int recruit();
	Singer train(String name, int memberCnt);
	List enlist(Singer singer);

}

public abstract class AbstractEnt implements Entertainment{

	List list=new ArrayList();
	
	@Override
	public List debut(String name) {
		
		int memberCnt=recruit();
		Singer singer=train(name,memberCnt);
		list.add(singer);
		
		return list;
	}
	
	public abstract int recruit();
	public abstract Singer train(String name, int memberCnt);

	@Override
	public List enlist(Singer singer) {
		return list;
	}

}

public class YGEnt extends AbstractEnt {

	@Override
	public int recruit() {
		int rand=(int)(Math.random()*10+1);
		return rand;
	}

	@Override
	public Singer train(String name, int memberCnt) {
		
		Singer singer=null;
		
		int rand=(int)(Math.random()*2);
		
		if(rand==0){
			singer=new BoyGroup(memberCnt, name);
		}else{
			singer=new GirlGroup(memberCnt, name);
		}
		
		return singer;
	}
}

public interface Singer {
	public void profile();
}

public class BoyGroup implements Singer {
	int memberCnt;
	String name;
	final String gender="boy";
	
	BoyGroup(int memberCnt,String name) {
		this.memberCnt=memberCnt;
		this.name=name;
	}
	
	public int getMemberCnt() {
		return memberCnt;
	}
	public void setMemberCnt(int memberCnt) {
		this.memberCnt = memberCnt;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	public String toString() {
		return "{\"memberCnt\":" + memberCnt + ", \"Name\":\"" + name +"\", \"gender\":\""+gender+ "\"}";
	}
	
	public void profile(){
		System.out.println("memberCnt="+memberCnt+", name="+name);
	}
}

public class GirlGroup implements Singer{
	int memberCnt;
	String name;
	final String gender="girl";
	
	GirlGroup(int memberCnt,String name) {
		this.memberCnt=memberCnt;
		this.name=name;
	}
	
	public int getMemberCnt() {
		return memberCnt;
	}
	public void setMemberCnt(int memberCnt) {
		this.memberCnt = memberCnt;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	public String toString() {
		return "{\"memberCnt\":" + memberCnt + ", \"Name\":\"" + name +"\", \"gender\":\""+gender+ "\"}";
	}
	
	public void profile(){
		System.out.println("memberCnt="+memberCnt+", name="+name);
	}
}

public class Main2 {

	public static void main(String[] args) {
		
		YGEnt yGEnt =new YGEnt();
		
		yGEnt.debut("빅뱅");
		yGEnt.debut("2NE1");
		yGEnt.debut("위너");
		yGEnt.debut("이하이");
		Listlist=yGEnt.debut("아이콘");
		
		System.out.println(list);
		
	}
}

디자인 패턴은 소프트웨어 객체지향설계에서 발견된 특정한 패턴을 말한다.

생성패턴(Creational Patterns), 구조패턴(Structural Patterns), 행동패턴(Behavioral Patterns)로 크게 분류된다.

1. 생성패턴(Creational Patterns)

 1) Factory Method : Define an interface for creating a single object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

 2) Abstract Factory : Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

 3) Singletone : Ensure a class has only one instance, and provide a global point of access to it.