모르니까 검색할거야

1.

2.

3. Product -> clean build folder 클릭

4. 다시 빌드

가정) 홈 씨어터(극장)으로 예제를 작성하겠습니다.

로직

1. 전등을 어둡게 조절한다.

2.스크린을 내린다.

3.프로젝터를 켠다.

4.프로젝트로 DVD신호가 입력되도록 한다.

5.앰프를 켠다.

6.볼륨을 중간으로 설정한다.

7.DVD를 키고 재생한다..... 등

light.on();
screen.down();

.
.
.
등등

.

.

그런데,, 아직 끝난게 아닙니다.

영화가 끝나면 어떤식으로 꺼야할까요?

시스템을 업그레이드하면 또 어떤식으로 작동되어야할까요?

.

.

이런경우에 퍼스드를 사용하면 됩니다.

퍼사드는 인터페이스를 단순화 시킬 뿐 아니라 클라이언트와 구성요소들로 이루어진

서브시스템을 분리시키는 역할도 합니다.

퍼사드와 어댑터는 모두 여러 개의 클래스를 감쌀 수 있습니다.

하지만,

퍼사드는 인터페이스를 단순화시키기 위한 용도로 쓰이는 반면,

어댑터는 인터페이스를 다른 인터페이스로 변환하기 위한 용도로 쓰입니다.

.

.

예제구현

public class HomeTheaterFacade {
	Amplifier amp;
	Tuner tuner;
	StreamingPlayer player;
	CdPlayer cd;
	Projector projector;
	TheaterLights lights;
	Screen screen;
	PopcornPopper popper;
 
	public HomeTheaterFacade(Amplifier amp, 
				 Tuner tuner, 
				 StreamingPlayer player, 
				 Projector projector, 
				 Screen screen,
				 TheaterLights lights,
				 PopcornPopper popper) {
 
		this.amp = amp;
		this.tuner = tuner;
		this.player = player;
		this.projector = projector;
		this.screen = screen;
		this.lights = lights;
		this.popper = popper;
	}
 
	public void watchMovie(String movie) {
		System.out.println("영화 볼 준비");
		popper.on();
		popper.pop();
		lights.dim(10);
		screen.down();
		projector.on();
		projector.wideScreenMode();
		amp.on();
		amp.setStreamingPlayer(player);
		amp.setSurroundSound();
		amp.setVolume(5);
		player.on();
		player.play(movie);
	}

public class Amplifier {
	String description;
	Tuner tuner;
	StreamingPlayer player;
	
	public Amplifier(String description) {
		this.description = description;
	}
 
	public void on() {
		System.out.println(description + " on");
	}
 
	public void off() {
		System.out.println(description + " off");
	}
 
	public void setStereoSound() {
		System.out.println(description + " stereo mode on");
	}
 
	public void setSurroundSound() {
		System.out.println(description + " surround sound on (5 speakers, 1 subwoofer)");
	}
 
	public void setVolume(int level) {
		System.out.println(description + " setting volume to " + level);
	}

	public void setTuner(Tuner tuner) {
		System.out.println(description + " setting tuner to " + player);
		this.tuner = tuner;
	}
  
	public void setStreamingPlayer(StreamingPlayer player) {
		System.out.println(description + " setting Streaming player to " + player);
		this.player = player;
	}
 
	public String toString() {
		return description;
	}
}

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Amplifier amp = new Amplifier("Amplifier");
        Tuner tuner = new Tuner("AM/FM Tuner", amp);
        StreamingPlayer player = new StreamingPlayer("Streaming Player", amp);
        CdPlayer cd = new CdPlayer("CD Player", amp);
        Projector projector = new Projector("Projector", player);
        TheaterLights lights = new TheaterLights("Theater Ceiling Lights");
        Screen screen = new Screen("Theater Screen");
        PopcornPopper popper = new PopcornPopper("Popcorn Popper");

        HomeTheaterFacade homeTheater =
                new HomeTheaterFacade(amp, tuner, player,
                        projector, screen, lights, popper);

        homeTheater.watchMovie("Raiders of the Lost Ark");
        homeTheater.endMovie();
    }
}

.

.

.

퍼사드패턴 : 어떤 서브시스템의 일련의 인터페이스에 통합된 인터페이스를 제공합니다.
퍼사드에서 고수준 인터페이스를 정의하기 때문에 서브세스템을 더 쉽게 사용 할 수 있습니다.

.

.

디자인원칙 
- 최소 지식 원칙 : 정말 친한 친구하고만 얘기하라.

결합도를 낮추는 방법

다음 네 종류의 객체의 메소드만을 호출하면 됩니다.

1. 객체 자체

2. 메소드에 매개면수로 전달된 객체

3. 그 메소드에서 생성하거나 인트턴스를 만든 객체

4. 그 객체에 속하는 구성요소

//원칙을 따르지 않는경우

public float getTemp() {
	Thermometer thermometer = station.getThermometer();
    return thremometer.getTemperature();
}

//원칙을 따르는 경우
puvlic float getTemp() {
	return station.getTemperature();
}

- 객체를 감싸서 실제와 다른 인터페이스를 가진 것처럼 보이도록 할 계획입니다.

이유?

: 특정 인터페이스를 필요로하는 디자인을 다른 인터페이스를 구현하는 클래스에 적응시킬 수 있기 때문입니다.

예제 구현

//오리 인터페이스
public interface Duck {
    void quack();
    void fly();
}

//그냥오리 인터페이스 구현
public class JustDuck implements Duck{
    @Override
    public void quack() {
        Log.d("abcd", "꽥꽥!!");
    }

    @Override
    public void fly() {
        Log.d("abcd","훨훨~");
    }
}

//새 인터페이스
public interface Bird {
    void gobble();
    void fly();
}


//그냥새 구현
public class JustBird implements Bird{
    @Override
    public void gobble() {
        Log.d("abcd","짹짹!!");
    }

    @Override
    public void fly() {
        Log.d("abcd","날아랏!");
    }
}

// 어뎁터 구현
// 새는 birdAdapter로 감싸서 오리처럼 보이게 만듭니다.
public class BirdAdapter implements Duck{
	//객체를 감쌀때는 구성을 사용
    Bird bird;

    public BirdAdapter(Bird bird) {
        this.bird = bird;
    }

    @Override
    public void quack() {
        //오리의 울음소리 메소드에 새의 울음소리를 입력합니다.
        bird.gobble();
    }

    @Override
    public void fly() {
        bird.fly();
    }
}

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Bird bird = new JustBird();
        //duck을 adapter에 implements 하였기 때문에 가능
        Duck duck = new BirdAdapter(bird);


        // 메소드 출력
        duck.fly();
        duck.quack();
    }
}

D/abcd: 날아랏!
        짹짹!!

.

.

전체적인 어댑터패턴 구현 순서

1. 클라이언트에서 타켓(오리) 인터페이스를 사용하여 메소드를 호출함으로써 어댑터에 요청합니다.

2. 어댑터에서는 어댑티(새) 인터페이스를 사용하여 그 요청을 어댑티(새)에 대한  메소드 호출로 변환합니다.

3. 클라이언트에서는 호출 결과를 받긴하지만 중간에 어댑터가 껴 있는지는 전혀 알지 못합니다.

.

.

어댑터 패턴 : 한 클래스의 인터페이스를 클라이언트에서 사용하고자 하는 다른 인터페이스로 변환합니다.
어댑터를 이용하면, 인터페이스 호환성 문제 때문에 같이 쓸 수 없는 클래스들을 연결해서 쓸 수 있습니다.

.

.

코틀린

// 오리
interface Duck {
    fun quack()
    fun fly()
}

// 그냥 오리
class JustDuck : Duck {
    override fun quack() {
        Log.d("abcd","꽥꽥!")
    }

    override fun fly() {
        Log.d("abcd","훨훨~")
    }
}

//새
interface Bird {
    fun gobble()
    fun fly()
}


//그냥 새
class JustBird : Bird {
    override fun gobble() {
        Log.d("abcd","짹짹")
    }

    override fun fly() {
        Log.d("abcd","훨훨!")
    }
}

//어댑터
class Adapter constructor(bird: Bird) : Duck {

    var bird:Bird? = null

    init {
        this.bird = bird
    }

    override fun quack() {
        bird?.gobble()
    }

    override fun fly() {
       bird?.fly()
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)


        val bird = JustBird()
        var adapter:Duck = Adapter(bird)


        adapter.fly()
        adapter.quack()

    }
}


D/abcd: 훨훨!
짹짹

: 일련의 행동을 특정 리시버(받는자)와 연결시킴으로써 요구사항을 캡슐화 한 것.

배우게 될 내용.

- 메소드 호출을 캡슐화

- 캡슐화된 메소드 재사용

가정) 최신형 리모컨을 개발한다. 리모컨 안에는 일곱 가지 프로그래밍이 가능한 슬롯이 있습니다.

그 일곱 가지를 가지고 on / off 할 수 있는 스위치도 가지고 있습니다.

기능에 대해 얘기해보자면, 스마트홈 같은 집에 불켜기, 가스불 끄기, 욕조물 데우기 등의 기능이 있다고 치겠습니다.

이러한 메소드들을 캡슐화하고, 캡슐화된 메소드를 재사용 해보겠습니다.

예제 작성 1

:  리모컨 버튼이 하나만 있다고 생각하고 불을 키는 버튼을 가진 리모컨을 사용해 커맨드 패턴을 사용하겠습니다.

//커맨드 객체
public interface Command {
    //실행 메소드
    void execute();
}


//불을 키는 클래스
public class LightOnCommand implements Command {
    Light light;

    public  LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.on();
    }
}

//불
public class Light {

    // 켜짐
    public String on() {
        Log.d("abcd", "불 켜짐");
        return "불 켜짐";
    }

    // 꺼짐
    public String off() {
        return  "불 꺼짐";
    }
}


//불을 키는 클래스
public class LightOnCommand implements Command {
    Light light;

    public  LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.on();
    }
}

//리모컨
public class RemoteController {
    Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void buttonClicked() {
        command.execute();
    }
}

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //리모컨 객체 생성
        RemoteController remoteCon = new RemoteController();
        // 불빛 객체
        Light light = new Light();
        // 불 키는 명령을 내리는 command 객체에 넣어줌
        LightOnCommand lightOn = new LightOnCommand(light);
        // command 설정
        remoteCon.setCommand(lightOn);
        // 클릭
        remoteCon.buttonClicked();

    }
}

결관 ; D/abcd: 불 켜짐

.

.

커맨드 패턴 : 커맨드 패턴을 이용하면 요구사항을 객체로 캡술화 할 수 있으며, 매개변수를 써서 여러가지 다른 요구사항을 집어 넣을 수도 있습니다. 또한 요청 내역을 큐(queue)에 저장하거나 로그로 기록할 수 있으며, 작업취소 기능도 지원 가능합니다.

.

.

.

.

.

.

.

.

바뀐 부분.

//null 방지를 위해 넣어줌.
public class NoCommand implements Command {
    @Override
    public void execute() {
        Log.d("abcd", "null 방지");
    }
}

 noCommand 객체는 일종의 null객체입니다. 리턴할 객체는 없지만,

클라이언트 쪽에서 null을 처리하지 않아도 되도록 하고 싶을 때 null 객체를 활용하면 좋습니다.

(즉, 빈자리를 채우기 위한 용도일 뿐입니다.)

//커맨드 객체
public interface Command {
    //실행 메소드
    void execute();
    //취소 메솓,
    void undo();
}

//리모컨
public class RemoteController {
    Command[] onCommands;
    Command[] offCommands;
    Command undoCommand;

    public RemoteController() {
        // 7개의 기능을 가진 버튼 on/off을 실행할 array[]
        onCommands = new Command[7];
        offCommands = new Command[7];

        //null방지
        Command noCommand = new NoCommand();
        for (int i = 0; i < 7; i++) {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
        undoCommand = noCommand;
    }

    //command 설정
    public void setCommand(int slot, Command onCommand, Command offCommand) {
        this.onCommands[slot] = onCommand;
        this.offCommands[slot] = offCommand;
    }

    //on 버튼 클릭
    public void onButtonClicked(int slot) {
        this.onCommands[slot].execute();
        //실행 후, 실행 취소를 누르면 바로 취소시키기 위해 해당 버튼의 [slot]을 준비시킴
        undoCommand = onCommands[slot];
    }

    //off 버튼 클릭
    public void offButtonClicked(int slot) {
        this.offCommands[slot].execute();
        undoCommand = offCommands[slot];
    }
    //취소 버튼 클릭
    public void undoButtonClicked() {
        undoCommand.undo();
    }
}

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //리모컨 객체 생성
        RemoteController remoteCon = new RemoteController();
        // 불빛 객체
        Light light = new Light();

        // 불 키는 명령
        LightOnCommand lightOn = new LightOnCommand(light);
        // 불 끄는 명령
        LightOffCommand lightOff = new LightOffCommand(light);

        // command 설정
        remoteCon.setCommand(0,lightOn,lightOff);

        // 클릭
        remoteCon.onButtonClicked(0);
        remoteCon.offButtonClicked(0);
        remoteCon.undoButtonClicked();

    }
}

코틀린 코드

interface Command  {
    fun execute()
    fun undo()
}

//
class LightOnCommand constructor(light: Light) :Command {

    var light : Light? = null

    init {
        this.light = light
    }

    override fun execute() { light?.on() }

    override fun undo() { light?.off() }
}


//
class LightOffCommand constructor(light:Light) : Command {

    var light : Light? = null
    init {
        this.light = light
    }

    override fun execute() {
       light?.off()
    }

    override fun undo() {
        light?.on()
    }
}


///
class NoCommand : Command {
    override fun execute() {
        TODO("Not yet implemented")
    }

    override fun undo() {
        TODO("Not yet implemented")
    }
}

class Light {
    fun on() { Log.d("abcd", "불 켜기")}
    fun  off() {Log.d("abcd","불끄기")}
}

class RemoteController {
     var onCommand: Array<Command>? = null
     var offCommand: Array<Command>? = null
    var undoCommand:Command? = null

    init {
        val noCommand = NoCommand()
        //사이즈, 초기화
        onCommand =Array(7, {noCommand})
        offCommand = Array(7, {noCommand})

        undoCommand = noCommand
    }

    fun setCommand(slot:Int, onCommand: Command, offCommand: Command) {
        this.onCommand?.set(slot, onCommand)
        this.offCommand?.set(slot, offCommand)
    }

    fun onButtonClicked(slot:Int) {
       this.onCommand?.get(slot)!!.execute()
        undoCommand = onCommand!![slot]
    }

    fun offButtonClicked(slot:Int) {
        this.offCommand?.get(slot)!!.execute()
        undoCommand = offCommand!![slot]
    }

    fun undoButtonClicked() {
        undoCommand!!.undo()
    }

}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)


        val remoteCon = RemoteController()
        val light:Light = Light()

        var lightOn: LightOnCommand = LightOnCommand(light)
        var lightOff: LightOffCommand = LightOffCommand(light)

        remoteCon.setCommand(0,lightOn,lightOff)

        remoteCon.onButtonClicked(0)
        remoteCon.offButtonClicked(0)
        remoteCon.undoButtonClicked()

    }
}

두개의 뷰컨트롤러를 생성하여,

첫번째 뷰컨트롤러에는 버튼 1개와, 라벨 1개

두번째 뷰컨트롤러에는 버튼 1개를 만들어 주었다.

로직

1. 첫번째 뷰컨트롤러의 버튼을 클릭하면, 두번째로 화면이 넘어가고

2. 두번째 뷰컨에서 버튼을 클릭하면 데이터를 가져와서 라벨에 띄우고, 창을 종료한다.

상속 받아서, 확장할 protocol을 하나 만들어준다. (new swift파일을 하나 생성하였다.)

import Foundation


//class나 AnyObject를 상속받는다면, 오직 class에서만 사용 가능하다.
protocol deliveryDataProtocol: AnyObject {
    func deliverydata(_ data:String)
}

첫번째 뷰 컨트롤러

import UIKit

//채택
class ViewController: UIViewController, deliveryDataProtocol{
    
    //라벨가져오기
    @IBOutlet weak var afterText: UILabel!
    
    //프로토콜 확장.
    func deliverydata(_ data: String) {
        //두번째에서 데이터를 받아와서 라벨에 띄어줄 것이다.
        afterText.text = data
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
       
    }

    
    //화면 이동
    @IBAction func nextPageButton(_ sender: Any) {
        //두번째 뷰컨트롤러를 가져옴
        guard let vc = self.storyboard?.instantiateViewController(withIdentifier: "SecondViewController") as? SecondViewController else {return}
        
        //위임
        vc.delegate = self
        
        //화면 이동
        self.present(vc, animated: true, completion: nil)
      
    }
    
}

두번째 뷰 컨트롤러

import UIKit

class SecondViewController: UIViewController {
    
    //두번째 화면에서는 delegate의 property 생성
    //protocol에서 오직 이 프로토콜은 클래스에서만 사용이 가능하다라는것이 명시되어 있을 때 "weak"를 쓴다.
    weak var delegate:deliveryDataProtocol?
    

    override func viewDidLoad() {
        super.viewDidLoad()

    }
    
    //이전으로 돌아가면서 데이터 전달하는 버튼을 클릭
    @IBAction func goBack(_ sender: Any) {
        //데이터 전달
        delegate?.deliverydata("안녕하세요~")
        //화면 닫기
        self.dismiss(animated: true, completion: nil)
    }
    
}

받은 에러 : Unknown class SecondViewController in Interface Builder file.

해결 :

module 연결 되어 있는지 꼭 확인 바람

.

.

.

예제 1. MVVM + ROOM + DataBinding

예제 구현

.

.

.

.

.

.

예제 2.  MVVM + ROOM + DataBinding + RecyclerView + Repository + Room

.

.

.

.

.

.

MVVM 장·단점

장점?

1.뷰가 데이터를 실시간으로 관찰한다. (UI 갱신 용이)

2.생명주기로부터 안전(데이터를 홀드하고 있으므로)하여 메모리 릭을 방지 할 수 있다.

3.기능별로 모듈화되어 있어, 역할분리를 할 수 있다.

단점?

1. 작은 프로젝트에는 유용하지 않다.

2. 사용하는 기술에 대한 러닝커브가 존재한다.

-Model,View,Presenter의 약자

-1990년대 초기에 MS에서 공개한 패턴

-MVC와 MVP는 Model과 View간의 결합도를 낮추는데 초점

특징? (View와 Presenter은 1:1관계)

View ?

사용자의 실질적인 이벤트가 발생하고, 이를 처리 담당자인 Presenter로 전달

(완전한 View의 형태를 가지도록 설계, MVC : Controller에서 사용자의 이벤트가 발생)

Presenter ?

View에서 전달받은 이벤트를 처리 후 이를 View에 전달 (View와 Model을 이어주는 역할)

.

.

전체적인 흐름

.

.

.

예제 1. 간단한 패턴 구현

.

.

.

.

.

.

예제 2. MVP + RecyclerView

.

.

.

.

.

.

.

.

.

예제 3.MVP + RecyclerView + Repository + Room + LiveData

예제코드작성

MVP 장·단점

장점?

-View와 Model의 의존성이 없다.

-새로운 기능 추가 및 변경을 해야할 때 관련된 부분만 코드 수정하면 되기 때문에 확장성이 좋다.

단점?

-View와 Presenter사이의 의존성이 커진다.

-Interface의 양이 많아진다.

MVC패턴?

-Model,View,Controller의 약자

-비즈니스 처리 로직과 UI요소를 분리시켜 서로 영향없이 개발

-안드로이드에서는 Activity/Fragment -> View,Controller 역할을 함께한다.

특징? 

-Model : 데이터를 가진다.

-View : 사용자에게 보여 질 화면을 표현한다.

Controller? 

-사용자로부터 입력을 받고, 이를 모델에 의해 View를 정의한다. *(Model과View연결)

- View와 Model을 변화시키는 알고리즘이나 소스코드가 위치한 곳 

예) Model을 호출해서 데이터를 변경 명령을 내리거나, 뷰에서 버튼 색상을 변경을 명령 내리거나 등

-앱을 묶어주는 접착제

입력은 모두 Controller에서 발생한다.

MVC패턴 흐름

1. 사용자가 화면의 버튼을 클릭

2. Controller가 View의 값을 바꾼다던지 동작을 컨트롤

3. View에서 Controller에게 사용자 입력을 전달 

4.Controller에서 Model에게 값의 변경이 필요하다면 모델값을 변경

5.Model에서 View에게 값의 변경 된 것을 View에 반영한다.

MVC패턴의 규칙 5가지

1.Model은 Controller와 View에 의존하지 않아야한다.

(Model내부에 Controller와 View에 관련된 코드가 있으면 안된다.)

2.View는 Model에만 의존해야하고, Controller에는 의존하면 안된다.

(VIew내부에 Model의 코드만 있을 수 있고, Controller의 코드가 있으면 안된다.)

3.View가 Model로부터 (직접적인?) 데이터를 받을 때는, 사용자마다 다르게 보여주어야 하는 데이터에 대해서만 받아야한다.

4.Controller는 Model과 View에 의존해도 된다.(Controller 내부에는 Model과 View코드가 있을 수 있다.)

5.View가 Model로부터 데이터를 받을 때, 반드시 Controller에서 받아야한다.

예제

.

.

.

MVC 패턴 장·단점

장점?

-쉽게 접근 가능

-개발기간이 짧을 수 있다.

단점?

-코드의 양이 많아져서 코드 복잡도가 높아진다.

-View와 Model의 의존성이 높으며 컨트롤러에 대한 의존성도 높다.

-View와 Model의 결합도가 높다.

-유지보수가 어렵다.