예나아빠_개발

git 지옥에서 온 git

터미널 또는 gitbash 툴을 사용하여 명령어를 이용해 소스를 관리

@start a working area(작업공간 시작하기.)

프로젝트 폴더 생성 후 폴더 안에서 

git init 하면 저장소가 생성이 되고 .git/ 폴더가 생성된다. 

.git 폴더는 버전 정보를 가지고 있다.

@git 이 관리할 파일 등록

생성된 파일 test.txt 가 있으면

터미널에서 git add test.txt 하면 등록이 된다

  add  

대상 파일을 git에게 추적하도록 명령하고 commit되기 전 stage에 등록한다. 

폴더의 상태를 확인할때는  git status 치면 된다.

@git 버전 만들기

git 버전을 만든 사람에 대한 정보를 설정한다.(한번만 설정하면 된다.)

git config --global user.name nickname

git config --global user.email email

git commit 하면

add 한 파일들에 대하여 파일의 상세설명을 등록하면

add한 파일들이 새로운 버전을 생성하게 된다.

text.txt 를 수정하였을 경우

등록때와 마찬가지로 파일을 수정하여 버전을 만들기 전에도 add 명령어를 사용한다.

git add text.txt 를 하여 수정된 파일을 다시 등록한다.

git commit 하면 새로운 버전을 등록 시 상세설명을 등록하여\

버전을 업데이트 해준다.

@git commit 전에 add를 해야하는 이유.

(git은 commit 전에 add를 꼭해야 합니다. 그 이유는 선택적으로 파일을 버전에 포함시키기 위해서 입니다.

여기서는 이에 대한 설명을 합니다.)

선택적 commit를 하기위해 add로 commit 할 파일만 등록한다.

stage area 커밋 대기 지역 

@ 변경사항 확인

git log -p  

:로그에서 출력되는 버전간의 차이점을 출력하고 싶을때

git diff '버전id' '버전id2'

:버전간의 차이점을 비교할때

git diff

:add 하기전과 add 한 후의 파일내용을 비교할때.

@ 버전 되돌리기

아래 명령은 버전 id로 돌아가는 명령입니다. 

git reset --hard "버전 id" 

버전 id의 커밋을 취소한 내용을 새로운 버전으로 만드는 명령

git revert "버전 id"

@git branch(작업 분기 하기)

매인 되는 작업과 테스트 되는 작업을 분리하여 매인 작업에 문제가 없도록 하기 위한 일

브랜치의 목록을 볼 때

git branch

브랜치를 생성할 때 

git branch "새로운 브랜치 이름"

브랜치를 삭제할 때

git branch -d

병합하지 않은 브랜치를 강제 삭제할 때 

git branch -D

브랜치를 전환(체크아웃)할 때

git checkout "전환하려는 브랜치 이름"

브랜치를 생성하고 전환까지 할 때 

git checkout -b "생성하고 전환할 브랜치 이름"

@브런치 

매인 브런치가 골조로 서브 브런치를 생성하여 매인 브런치는 영향이 없도록 브런치를 만들어 

서브 브런치에서 작업을 함.

서브 브런치에서 작업을 하고 push를 하면 원격 저장소 서브 브런치에 업로드가 됨.

새로운 브런치 생성.

git checkout -b newBranch

브런치 이동 

git checkout branch

브런치 삭제

git branch -d branch

@저장소 받아오기

로컬 저장소 복제 

git clone /로컬/저장소/경로

원격 저장소 복제

git clone 사용자명@호스트:/원격/저장소/경로 

@원격저장소

소스코드 백업

다른 사람들과의 협업

인터넷 연결하여 외부 저장소를 활용.

원격저장소로 소스를 복사하기

git remote add origin <원격서버 주소>

원격저장소로 변경 내용 업로드

git push origin 브런치

브런치 원격저장소로 전송.

git push origin branch

저장소 갱신(로컬 저장소를 원격 저장소에 맞춰 갱신)

git pull

브런치 병합

git merge branch

git 은 버전관리 시스템 이다.

git은 내 로컬 저장소 또는 원격 저장소에 저장할 수 있고 협업이 가능하다.

맨처음 파일 생성하면 add(버전관리) 할지 선택하고

소스를 완성하면 commit하여 버전관리를 함. 

소스의 설명 또는 버전 메시지를 넣을 수 있음.

(여기까지가 내 저장소에서 소스관리 하는 것..)

브런치.(원격 혹은 내 저장소에서 매인 소스를 건드리지 않고 소스를 관리하도록 함.)

매인 브런치가 골조로 서브 브런치를 생성하여 매인 브런치는 영향이 없도록 브런치를 만들어 

서브 브런치에서 작업을 함.

서브 브런치에서 작업을 하고 push를 하면 원격 저장소 서브 브런치에 업로드가 됨.

레트로핏 사용방법.

사용하는 방법은 대충 알겄는디 ??? 

정작 글로 쓸려고하니 뭔가 막히는 구문이 있다.

안드로이드에서 사용되는 여러 다양한 통신 기법 중 많이 사용되고 있는 레트로핏 통신방법

먼저 프로젝트를 생성한 다음 앱 그래들에 모듈을 포함시켜 준다.

GRADLE

//레트로핏 

implementation 'com.squareup.retrofit2:retrofit:2.4.0'

// 레트로핏 gson converter

implementation 'com.squareup.retrofit2:converter-gson:2.4.0'

// gson

implementation 'com.google.code.gson:gson:2.8.2'

//okhttp 로그 인터셉터

implementation 'com.squareup.okhttp3:logging-interceptor:3.10.0'

퍼미션에서 인터넷 권한을 준다.

//여기에 접속해서 필요한 데이터를 가져온다.

https://api.github.com/users/bearkinf

gson으로 데이터받을 클래스 생성.

/**유저 정보 관련 데이터 클래스*/

public class GithubUser {

    private String login;

    private String id;

    private String url;

    private String name;

    public String getLogin() {

        return login;

    }

    public void setLogin(String login) {

        this.login = login;

    }

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getUrl() {

        return url;

    }

    public void setUrl(String url) {

        this.url = url;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

/**저장소 관련 데이터 클래스.*/

public class GithubRepos {

    private String name;

    private String full_name;

    private String html_url;

    public String getName() { return name;  }

    public void setName(String name) {

        this.name = name;

    }

    public String getFull_name() {

        return full_name;

    }

    public void setFull_name(String full_name) {

        this.full_name = full_name;

    }

    public String getHtml_url() {

        return html_url;

    }

    public void setHtml_url(String html_url) {

        this.html_url = html_url;

    }

}

접속하기 위한 인터페이스를 만들고

public interface GithubConnectService {

    @GET("/users/{user}")

    Call<List<GithubUser>> getUser(@Path("user") String user);

    @GET("/users/{user}/repos")

    Call<List<GithubRepos>> getUserRepos(@Path("user") String user);

}

인터페이스르 사용하여 접속할 클래스 메서드를 만든다.

public class GithubConnectionApi {

    /**connection interface 리턴받음*/

    public static GithubConnectService setConnect() {

        OkHttpClient okHttpClient = new OkHttpClient.Builder()

                //통신시 request 및 response 상태 표시

                .addInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))

                .build();

        return new Retrofit.Builder()

                .baseUrl("https://api.github.com/")

                // gson 데이터 파싱 메서드

                .addConverterFactory(GsonConverterFactory.create())

                // 통신 클라이언트 지정

                .client(okHttpClient)

                .build()

                // 통신 인터페이스 등록

                .create(GithubConnectService.class);

    }

}

MainActivity에서 통신 할 방법을 구현 한다.

public class MainActivity extends AppCompatActivity {

    Button button;

    TextView textview;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        textview = findViewById(R.id.textview);

        button = findViewById(R.id.button);

        button.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                Log.d("bear", "버튼 클릭");

                Call<GithubUser> githubUserCall = GithubConnectionApi.setConnect().getUser("bearkinf");

                githubUserCall.enqueue(new Callback<GithubUser>() {

                    @Override

                    public void onResponse(Call<GithubUser> call, Response<GithubUser> response) {

                        Log.w("bear", "response : " + response.body());

                        GithubUser user = response.body();

                        Log.w("bear", "getId : " + user.getId());

                        Log.w("bear", "getLogin : " + user.getLogin());

                        Log.w("bear", "getName : " + user.getName());

                        Log.w("bear", "getUrl : " + user.getUrl());

                    }

                    @Override

                    public void onFailure(Call<GithubUser> call, Throwable t) {

                        t.printStackTrace();

                    }

                });

            }

        });

    }

}

안드로이드 4.4.4버전에서 ssl 관련 통신 에러 발생함.

apply 사용

apply()는

apply()함수를 호출하는 객체를 이어지는 블록의 리시버{블록 안에 메서드 및 속성에 바로 접근할 수 있도록 할 객체}

로 전달하고, 객체 자체를 반환

    val people01 = People().apply {

        //this: People        

        // People 객체를 넘겨주고 속성을 초기화 한 후 people01 변수에 값을 넣어준다.

        name = "ppppp"

        age = 20

    }

//run 사용법.    

    people01.run {

        println("${people01.afterAge(age!!)}")

    }

apply 를 사용하지 않는 동일한 코드는 다음과 같다.

    val people02 = People()

    people02.name = "ppp02"

    people02.age = 21

//data class 

//class

data class People(var name: String? = null,

                  var age: Int? = null) {

    var doubleAge: Int? = null

}

let 사용

let()는

let() 함수를 호출하는 객체를 인자로 받아서 넘기고 블록의 결과값을 리턴해준다.

  val people01 = People().apply {

        //this: People        

        name = "ppppp"

        age = 20

// age = 20     

    }

    //억지스럽지만 이렇게도 된다.

    people01.doubleAge = people01.age?.let { it + it }

let 함수

fun main(args: Array<String>) {

    // 코틀린 let 함수

    // public inline fun <T, R> T.let(block: (T) -> R): R

    // T 를 인자로 받아서 블록안에 넘기고 (뭔가 작업을 하고)블록의 결과값 R을 리턴해줍니다.

    // 어떤 변수 또는 리턴값이 있는 메서드에서 let함수를 호출 하면

    // 호출한 변수값이나 메서드값을 {(블록)}의 인자로 넘기고

    // {} 안에 결과값을 반환한다.(retrun)

    // RxJava에서 map 함수와 비슷한 기능이랄까???

    var number100 = 100

    number100.let { it ->

        //필요에 위해 가공을 한다면 

        val returnCount = it + it

        //이렇게 값을 반환할 수 있다.

        return@let returnCount

    }

    // let 함수의 리턴받을 변수가 없기에 number100 은 아무 변화가 없다.

    println("number100 = $number100")

    //let 함수를 호출하면 

    number100 = number100.let { it ->

        //필요에 위해 가공을 한다면 

        val returnCount = it + it

        //이렇게 값을 반환할 수 있다.

        return@let returnCount

    }

    // number100 에 let 함수에서 받은 반환걊을 받아 값이 변하였다.

    println("number100 = $number100")

    //위 값에선 변화가 없지만.

    // 새로운 변수를 지정하고 let 함수를 리턴 받으면. 

    // 앞에서 number100은 200이 되었다.

    val number200 = number100.let { it ->

        val returnCount = it + it

        return@let returnCount

    }

    println("number200 = $number200")

    // 예제.

    fun doubleCount(count: Int): Int {

        return count * count

    }

    val data = doubleCount(2).let {

        // doubleCount 값 2*2를 인자로 받아서 

        // 4

        return@let it + it

        // 4+4 하고

        // val returnData = it + it

        // 그값을 리턴한다.

        // returnData

    }

    println("$data")

}

추상 클래스를 이용한 액티비티 구현 2-1.

2-2에서 퍼미션 권한 이용.

안드로이드 스튜디오 프로잭트 생성.

생성된 기본 액티비티.

MainActivity.java

//////////////////////////////////////////////////////////////////////////////////////////

public class MainActivity extends AppCompatActivity {

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

    }

}

//////////////////////////////////////////////////////////////////////////////////////////

추상 클래스 BaseActivity 생성.

BaseActivity.java

//////////////////////////////////////////////////////////////////////////////////////////

abstract class BaseActivity extends AppCompatActivity {

    /**상속받은 곳에서 xml 레이아웃을 받아옴.*/

    abstract int setLayout();

    @Override

    protected void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(setLayout());

    }

}

//////////////////////////////////////////////////////////////////////////////////////////

생성된 BaseActivity를 MainActivity에서 상속받음.

MainActivity.java

//////////////////////////////////////////////////////////////////////////////////////////

public class MainActivity extends BaseActivity {

    @Override

    int setLayout() {

        // BaseActivit에서 만들어 놓은 추상 메서그 구현.

        // setContentView(R.layout.activity_main);

        // 추상메서드로 구현.

        return R.layout.activity_main;

    }

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

    }

}

//////////////////////////////////////////////////////////////////////////////////////////

이렇게 작업 한 이유는 액티비티를 상속 받은 처리 중 퍼미션 사용시 필요한 클래스 들을 정의 하여 사용하기 위함.

구현이 필요 없을 시엔 기존에 사용하던 대로 사용 가능.

MVP 패턴.

MODEL : 데이터 처리.

VIEW : 뷰 

PRESENT : MODEL과 VIEW 사이의 매개체

MVP 패턴의 동작

VIEW 에서 사용자 이벤트 수신

VIEW 에서 PRESENTER 이벤트 호출

PRESENTER 에서 MODEL 데이터 요청

MODEL 에서 PRESENTER 로 데이터 전달

PRESENTER 에서 전달받은 데이털 처리 후 VIEW 업데이트 요청

VIEW 에서 화면 업데이트

구현 방법

interface Contact

inner interface View

inner interface Present 

View 에서 처리할 이벤트 선언

Present 에서 처리할 이벤트 선언

View를 상속받는 Activiry 구현

Present를 상속받는 Presenter 구현

Presenter 에서 Model로 데이터 요청.(통신을 통한 서버 데이터 요청)

Model 에서 Presenter 가 요청한 데이터를 전달 후 Presenter에서 데이터 가공 후 View에 업데이트 요청

View 로 가공된 데이터를 가지고 화면 업데이트. 

MainActivityContract

MainActivity  MainActivityContract.View 상속

MainActivityPresenter MainActivityContract.Present 상속

MainActivityDataAction Present에서 데이터 요청

코틀린으로 코드 구현.

/**

 * 액티비티 상속 클래스

 */

abstract class BaseActivity : AppCompatActivity() {

    /**레이아웃 뷰 추상화 등록*/

    protected abstract val layoutId: Int

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContentView(layoutId)

    }

}

/**

 * mvp 계약자 정의

 */

interface MainActivityContract {

    /**

     * 단순 화면 처리

     * 액티비이에서 뷰 구현

     */

    interface View {

        /** 뷰에 프레젠터 등록.*/

        val presenter: Present

        fun buttonClickChangeUI(count: Int)

    }

    /**

     * 프레젠터 뷰와 모델의 데이터 처리

     * 프레젠터 클래스를 생성하여 인터페이스 구현.

     */

    interface Present {

        /**

         * 프레젠터에 뷰 등록

         *

         */

        var view: View?

        /** 전달받을 뷰를 등록함.*/

        fun attachView(view: View)

        /** 뷰 해제*/

        fun detachView()

        fun buttonClickCountUp(count: Int)

    }

}

/**

 * MainActivity

 * 

 */

class MainActivity : BaseActivity(), MainActivityContract.View {

    /**BaseActivity에서 상속받은 변수. */

    override val layoutId = R.layout.activity_main

    /**뷰에 지정한 프레젠터 등록.*/

    override val presenter: MainActivityContract.Present = MainActivityPresenter()

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        presenter.attachView(this)

        buttonEvent()

    }

    fun buttonEvent() {

        button_Click.setOnClickListener(View.OnClickListener {

            Log.w("bear", "buttonclick")

            presenter.buttonClickCountUp(count)

        }

        )

    }

    var count = 0

    override fun buttonClickChangeUI(count: Int) {

        this.count = count

        textview.text = "${this.count}"

    }

}

/**

 * 데이터를 처리하는 프레젠터

 * 처리된 결과를 등록한 뷰에 전달.

 */

class MainActivityPresenter : MainActivityContract.Present {

    /**뷰 초기화*/

    override var view: MainActivityContract.View? = null

    /**뷰 지정.onCreate 에 등록*/

    override fun attachView(view: MainActivityContract.View) {

        this.view = view

    }

    /**뷰 해제*/

    override fun detachView() {

        this.view = null

    }

    override fun buttonClickCountUp(count: Int) {

        view?.buttonClickChangeUI(count + 1)

    }

}

이런식으로 사용이 가능하다.

자바 분기문

break 문

반복문이 종료되기전 break문을 만나면 반복문을 종료 시킨다

for (int i = 0; i < 10; i++) {

//0부터 9까지 출력을한다.

    System.out.println(i);

    //i가 5라면.

    if (i == 5) {

    // 반복문은 종료되고 

        break;

    }

    //0부터 5까지만 출력한다.

}

중첩된 반복문을 사용할 경우에는 마지막에 사용된 반복문을 종료 시킨다.

// 0부터 9까지 반복을 한다.

for (int i = 0; i < 10; i++) {

    //0부터 9까지 반복을 한다.

    for (int j = 0; j < 10; j++) {

    // i 변수를 출력한다.

        System.out.print(i);

        // i 와 j 가 같다면 

        if(i==j){

        // j 변수로 시작되는 두번째 반복문은 종료된다.

            break;

        }

    }

    // 줄바꿈

    System.out.println("");

}

반복문에 라벨을 지정하고

break 뒤에 라벨을 붙여주면 좀더 명확하게 종료시점을 확인할 수 있다.

first:

for (int i = 0; i < 10; i++) {

    second:

    for (int j = 0; j < 10; j++) {

        System.out.print(i);

        if (i == j) {

        // second 라벨을 가진 반복문을 종료한다.

            break second;

       }

    }

    System.out.println("");

}

continue 문

반복문이 continue를 만나면 다음 반복으로 넘어간다.

for (int i = 0; i < 10; i++) {

// i를 2로 나누어 0이 된다면.

    if (i % 2 == 0) {

    // 아래 구문을 실행하지 않고 다음 반복으로 넘어간다. 

    // 2,4,6,8 은 건너띔

       continue;

    }

    System.out.println(i);

}

해당 조건식을 만나는 경우 다음 반복으로 건너뛴다.

맥에서 사용하는 단축키 정리

잘라내기 : cmd + c 대상파일  후 폴더 이동후 cmd + alt + v 파일 이동 됨.

복사 : cmd + c 대상 파일  후 폴더 이동 후  cmd + v 파일 복사.

      대상 파일을 alt 누른 후 드래그 하면 파일 복사.

파일 미리보기 : 해당 파일 선택 후 space 누르면 간단 미리보기 됨.

열린 창 이동 : cmd + tab

줄 맨처음 이동 : cmd + 왼쪽 화살표 (home)

줄 마지막 이동 : cmd + 오른쪽 화살표 (end)

페이지 맨위 이동 :  cmd + 위 화살표 (page up)

페이지 마지막 이동 : cmd + 아래 화살표 (page down)

뒤로가기 : cmd + [ (파인더[이전폴더이동], 크롬, 사파리, 파이어폭스)

앞으로가기 :  cmd + ] (파인더[다음폴더이동], 크롬, 사파리, 파이어폭스)

파일삭제 : 대상파일 선택 후  cmd + backspace(delete) 키 누르면 파일 삭제

파인더 폴더 이동 : 대상 폴더 선택 후 cmd + 아래 화살표 누르면 하위 폴더로 이동.

               cmd + 위 화살표 누르면 상위 폴더로 이동함.

               파일 일경우 실행함.

command(또는 cmd) ⌘

shift ⇧

option(또는 alt) ⌥

control(또는 ctrl) ⌃

caps lock ⇪

fn

자바 반복문

for 반복문

for(초기화; 조건식; 증감식){

반복할 코드.

}

for(int i = 0 ; i < 10 ; i++){

int total = temp + i;

System.out.println("합계는 " + total +" 입니다.");

}

합계는 (0부터 9까지 더한 수) 입니다.

초기화로 변수 i 값을 초기화 하고 증감식에 i 값을 증가시켜 조건식까지 값을 증가시켜 반복한다.

조건식에 변수 i값이 true 면 반복, false면 for문은 종료된다.

int 구구단수 = 2;

System.out.println(구구단수 + " 구구단");

for(int i = 1 ; i< 10 ; i++){

System.out.println(구구단수 +" x " + i  + " = " +(구구단수*i) );

}

간단한 구구단 출력 이다. 

i 값은 1부터 시작하여 10보다 작은 9까지 반복하고 종료되는데 

구구단수에 입력된 값과 i값을 곱하여 1부터 9까지의 값을 곱한것을 출력한 후 구구단을 종료한다.

조건식에서 i < 10 대신 i <= 10 으로 변경하면 i는 10까지 반복이 가능하다.

while 반복문

while(조건식){

반복할 코드

}

조건식에 true 일 경우 반복한다. 조건식에 false가 되면 반복은 종료된다.

int count = 0;

while(count < 10){

System.out.println("count는 " + count + " 입니다.");

// 만약 count를 증가시키는 코드가 없다면.

// count는 0이므로 무한 반복을 한다.

count++

}

반복의 상황을 직접 제어 해야 한다.

boolean end = true;

int i = 0 ;

while(end){

i++;

System.out.println(i +"는 증가했습니다.")

if(i == 100){

end = false;

System.out.println("반복문이 종료 되었습니다.")

}

}

조건식에 boolean 변수를 사용할수도 있다.

do{

최초 1회 실행되고 다음 조건식을 체크한다.

반복할 코드.

}while(조건식)

do{} 를 최초 실행한 다음 조건식을 확인하여 코드를 반복한다.

int i = 1;

do{

System.out.println()

// 변수를 조건식에 맞게 제어를 하지 않으면 무한 반복한다.

// i가 10이상일 경우  1회만 실행되고 종료되지만 10이하 일경우

// 조건에 맞게 제어를 해야 반복문을 끝낼수 있다.

i++;

}while(i < 10)

boolean end = true;

int i = 0;

do {

    System.out.println(i);

    if (i == 10) {

        end = false;

    }

    i++;

} while (end);

boolean 변수를 사용하여 종료될 시점을 정한다음 boolean 변수의 값을 변경하여 반복문을 종료한다.

반복문을 사용하기 적당한 예제는 숫자 맞추기 게임 이다.

입력되는 코드를 입력하여 do{} 위에 만들어진 난수와 비교하여 숫자 맞추기를 시도하고 몇번을 맞추었는지

체크 할수도 있다.

향상된 for문 (for each 문)

java 1.5 부터 지원 되며

배열 또는 컬렉션 사용.

for(대입받을 변수 정의 : 배열 또는 컬랙션){

코드

}

String[] arr = ["x", "y", "z", "1", "2", "3"]

for (String str : arr) {

System.out.println(" " + str);

}

배열 또는 컬렉션의 사이즈 만큼 반복하며 대입받을 변수는 반복될때마다 초기화 되고 해당 배열 또는 컬렉션 인텍스를 가진다.

자바 제어문

제어문

if(조건식 == true 또는 false){ 코드 실행.}

: ()어떠한 조건식이 true 또는 false 일때  {  } 안에 코드를 수행한다.

예제

int count = 10;

// 만약 count 라는 변수가 10이 맞다면.

if(count == 10){

// 화면에 맞다는 문구를 출력한다.

System.out.println(count + "는 10이 맞습니다.");

}else{

// 화면에 맞지 않다는 문구를 출력한다.

System.out.println(count + "는 10이 아닙니다..");

}

if 문안에 또 if문을 사용할 수 있다. 중첩된 if문을 사용하여 조건을 더 확인할 수 있다.

int count = 10;

if(count >= 10){

//10보다 크거나 같다.

if(count ==10){

System.out.println(count +"는 10 입니다.");

}else{

System.out.println(count +"는 10보다 큰 수입니다.");

}

}else{

System.out.println(count +"는 10보다 작습니다.");

}

if문에 else if() 로 또다른 조건을 걸수가 있다. 

int count =10;

//인트 타입의 변수 count를 숫자 10과 비교하여 true이면  

if(count == 10){

// 화면에 문구를 출력합니다.

System.out.println(count +"는 10입니다.");

}

// 위 조건문에서 false로 내려오는경우 다시한번 조건문을 비교합니다.

// count가 10보다 큰 11이라면 위 if문에서 false가되고 

// 아래 else if 문에서 true이다.

else if( count > 10){

// count 가 10보다 크므로 해당 문구를 출력합니다.

System.out.println(count +"는 10보다 큰 수 입니다.");

}

// 마지막 else 문은 count 모든 조건에 맞지 않을때 이다.

// count가 10 이하의 수 라면 위 2개의 조건을 거치고 난 다음

// 마지막 else 문으로 해당 소스를 실행한다.

else{

// count 변수가 10보다 작은수 이면 화면에 문구를 출력합니다.

System.out.println(count +"는 10보다 작은 수 입니다.");

}

count가 10보다 작을때 마지막 else 문을 삭제하면 화면에 아무것도 출력하지 않는다.

if (count == 10) {

            System.out.println(count + "는 10입니다.");

        } else if (count > 10) {

            System.out.println(count + "는 10보다 큰 수 입니다.");

        }

//else {

// 실행되지 않는다. 이유는 모든 조건이 맞지 않을때 마지막 else문을 실행 하기 때문이다.

// 따라서 if 문 맨 아래 else가 있다면 그것이 실행되지만 

// else가 없다면 모든 조건이 맞지 않을때 어떠한 것도 실행되지 않는다.

    //}

switch() { case ..  }

switch(변수) {

case 변수:  

break;

default :

break;

}

입력 받은 변수를 확인하여 case 로 지정되어 있다면 지정된 case 문을 실행하고 없다면 default 문을 실행한다. 

case없고 default도 없다면 아무것도 실행되지 않는다.

switch 변수 값에는 정수형 또는 char 값 그리고 java 7에서는 String 타입의 변수도 넣을 수 있다.

다만 변수의 참조 타입이 모두 같아야 한다.

int month = 1;

switch(month){

case 1:

System.out.println("1월 입니다.")

break;

case 2:

System.out.println("2월 입니다.")

break;

case 3:

System.out.println("3월 입니다.")

break;

default:

System.out.println("1~12월 까지 인데 잘못 입력하셨습니다.")

break;

}

위 스위치 문은 if문으로 대체가 가능하다.

if(month==1){

System.out.println("1월 입니다.")

}else if(month==2){

System.out.println("2월 입니다.")

}else if(month==3){

System.out.println("3월 입니다.")

}else {

System.out.println("1~12월 까지 인데 잘못 입력하셨습니다.")

}

RxJava

함수형 프로그래밍, 비동기 작업, 서버연동, 옵저버 패턴, 마블 다이어그램.

학습 곡선이 높다고 표현한다. 어떤식으로 작업을 해야 쉽게 이해가 될 수 있을까?

기본 

Observable : 데이터 생성을 위한 시작 클래스. 정적 팩토리함수로 인스턴스를 생성. 

just       : 데이터를 발행하는 정적팩토리 함수. 

     데이터를 발행하려는 메서드.하나의 인자 또는 최대 10개 까지의 같은 타입의 인자를 받음.

             subscribe()를 호출해야 실제 데이터 발행이 진행됨.

subscribe  : 데이터를 구독하는 함수. Observable에 데이터를 발행하라고 요구 (이함수가 없으면 RxJava 가 실해되지 않는다.)

Observable의 팩토리 함수 

create(), just(), from(), 

fromArray(), fromIterable(), fromCallable(), fromFuture(),

interval(), range(), timer(), defer()

Single : 오직 1개의 데이터만 발행하도록 한정됨.

  보통 결과가 유일한 서버api를 호출할때 사용.

  배열 및 리스트로 값을 받아도 1번의 값만 동작.

Flowable : 뜨거운 Observable 에서 데이터를 처리할때 배압을 고려할때 사용.

           배압은 Observable에서 테이타를 발행하는 속도와 구독자의 처리하는 속도의 차이가 발생할때 사용.

   Observable과 같은 방법으로 사용 하여도 된다.

기본 예제

   //자바 8 메서드 레퍼런스활용

   Observable.just("start Rxjava", "Rxjava end").subscribe(System.out::println);

   //람다식 적용.

   Observable.just("start Rxjava", "Rxjava end").subscribe(

           s -> {

               System.out.println("실행결과 : " + s);

       }

   );

   // 람다식 적용안함.

   Observable.just("start Rxjava", "Rxjava end").subscribe(new Consumer<String>() {

       @Override

       public void accept(String s) throws Exception {

           System.out.println("실행결과 : " + s);

       }

   });

   Single.just("fsdjaklfjasdklf").subscribe(System.out::println);

   Flowable.just("start Rxjava", "Rxjava end").subscribe(System.out::println);

연산자 활용

interval() : 일정시간 간격으로 데이터 흐름을 생성.

     주어진 시간을 간격으로 0부터 1씩 증가하는 Long 객체를 발행.