choice blog

public class Lotto {
	public static void main(String[] args) {
		boolean swit[] = new boolean[45];
		int lotto[] = new int [6];
		int w, r;

		w = 0;
		while(w < 6) {
			r = (int)(Math.random()*45); // 0 ~ 44
			if(swit[r] == false) {
				swit[r] = true;
				lotto[w] = r+1;	     // 1 ~ 45
				w++; 
			}
		}
		for(int i =0; i < lotto.length; i++) {
			System.out.print(lotto[i]+ " ");
		}
	}
}

로또 번호 생성기

import java.util.Scanner;

public class Baseball {
	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		
		// 선언부
		int r_num[] = new int[3];
		int u_num[] = new int[3];
		boolean clear;
		
		boolean swit[] = new boolean[10]; // 0 ~ length-1
		//				 allocation(동적할당)
		
		// 초기화
		clear = false;
		for(int i=0; i<swit.length; i++) {
			swit[i] = false;
		}
		int w, r;
		
		w = 0;
		while(w < 3) {
			r = (int)(Math.random()*9);// 0~8
			if(swit[r] == false) {
				swit[r] = true;
				r_num[w] = r + 1;  // 1~9
				w++;
			}
		}
		for(int i=0; i<r_num.length; i++) {
			System.out.print(r_num[i]+ " ");
		}
		System.out.println();
		
		////////////////////////////////  loop
		w = 0;
		
		while(w<10) {
		// user 입력
		while(true) {
			for(int i=0; i<u_num.length; i++) {
				System.out.print((i + 1)+"번째 수 >> ");
				u_num[i] = scn.nextInt();
				}
				if(u_num[0] != u_num[1]
						&& u_num[1] != u_num[2]
								&& u_num[0] != u_num[2]) {
					break;
				}
				System.out.println("같은 숫자를 입력하셨습니다. 다시 입력해 주세요.");
			}
			
			// 비교			-> 탈출
			// 스트라이크, 볼
			int strike, ball;
			strike = 0;
			ball = 0;
			
			// ball
			for(int i=0; i< r_num.length; i++) {	// 0 1 2
				for (int j=0; j<u_num.length; j++) {// 0 1 2
					if(u_num[i] == r_num[j] && i != j) {
						ball++;
					}
				}
			}
			
			// strike
			for(int i=0; i< r_num.length; i++) {
				if(u_num[i] == r_num[i]) {
					strike++;
				}
			}
		// 맞췄을 경우
			if(strike > 2) {
				clear = true;
				break;
			}
		// 메세지 출력
			System.out.println(strike + "스트라이크"+ ball +"볼입니다.");
			w++;
		}
		////////////////////////////////
		// 결과출력
		if(clear) {
			System.out.println("Game Clear!!!");
		}else {
			System.out.println("Game Over~");
		}
	}
}

Baseball Game

조건 

> 기회는 10번
> 3개의 숫자는 같은 수이면 안 된다.
> 자리수와 숫자가 같은 경우 : strike
> 숫자만 같은 경우 : ball

import java.util.Scanner;

public class UpDown {
	public static void main(String[] args) {
		// 1 ~100까지 숫자 찾기 게임! 기회는 단 10회!
		Scanner scn = new Scanner(System.in);
		int temp = 0;
		int count = 0;
		boolean clear = false;
		
		int comNum = (int)(Math.random()*100)+1;	// comNum 1~100까지 랜덤 수 뽑기
		
		while(count<10) {
			System.out.print("user : ");
			int userNum = scn.nextInt();		// userNum 입력

			if(comNum > userNum ) {			// comNum이 userNum보다 클 경우
				temp = 1;			// temp에 1 저장
			}else if (comNum < userNum) {		// comNum이 userNum보다 작을 경우
				temp = 2;			// temp에 2 저장
			} else {				// comNum이 userNum보다 같을 경우
            			clear = true;			// clear에 true를 저장
				break;				// if블럭 빠져 나가기
			}
			
			switch(temp) {							
			case 1 :
				System.out.println("UP!");
				break;
			case 2 :
				System.out.println("DOWN!");
				break;
			}
			count++;
		}
		if(clear == true) {
			System.out.println("Congratulations! Game Clear!!!");
		} else {
			System.out.println("GameOver~~~");
		}
	}
}

Scanner로 숫자를 입력받아서 UP & DOWN 게임

import java.util.Scanner;

public class NumStr {
	public static void main(String[] args) {
		// 입력된 문자열이 숫자인지 문자가 섞여있는지 판단하는 코드를 작성
		char temp = 0;
		boolean flag = true;
		// 문자열 입력
		Scanner scn = new Scanner(System.in);
		System.out.print("입력 > ");
		String str = scn.next();
		
		for(int i=0; i<str.length(); i++) {
			temp = str.charAt(i);			// 입력한 str을 문자로 쪼개서 temp로 받기
				if (temp < '0' || temp > '9' ) {// temp의 값이 '0'작거나 '9'보다 클 경우
					flag = false;
					break;
				}	
		}
		if(flag == true) {	
			System.out.println("숫자로 되어있습니다.");
		}else {
			System.out.println("문자열입니다.");
		}
	}
}

    

위 예제는 입력한 문자열이 숫자로만 되어 있는지 문자열인지 판별해 주는 코드 입니다.

예약어란?

프로그래밍 언어의 구문에 사용되는 단어

클래스나 변수, 메서드의 이름(식별자)으로 사용할 수 없다.

Java 예약어(나만의 방식...)

byte, short, char, int, long, float, double, (boolean -true, false) : 기본형 데이터 타입 

String : 참조형 데이터 타입, 문자열

if, else if, else, switch, case, for, while, do, break, return, continue : 제어문 

pubilc, protected, defalut, private : 접근제한자 

throw, throws, try, catch, finally : 예외처리

void : 리턴할 것이 없다 

static : class 소속 지정

class : class명 앞에

import : 불러오다 

package : 패키지

abstract : 추상메소드 & 추상 클래스 사용

super : 부모 소환

this : 자기 자신

implements : Runnable 불러올 때

null : String 초기값

final : 상수 

extends : 상속 

new : 인스턴스 생성

synchronized : 동기화

(1) JVM

    1) JDK = jdk + jre
    2) 환경변수 : 고급시스템 설정 → 환경변수
　　　<1> JAVA_HOME

　　　 　　　새로만들기 → 변수이름 : JAVA_HOME

                                     　　변수 값 : java 경로　ex) C:\Program Files\Java\jdk1.8.0_281 　　
　　　<2> Path

　　　 　　　편집 → 새로만들기 → %JAVA_HOME%\bin
　　　<3> classpath

　　　 　　　새로만들기 →  변수이름 : classpath 

                                     　　 변수 값 : .

    3) API

　　　다운 후 → does → api → index.html

   
(2) 실행 메커니즘

    1) 작성(java) -> 컴파일(javac.exe)  -> 실행(java.exe)

    2) .java(for Man) -> .class(for Com)

(3) 클래스의 구조

    1) 패키지 선언     

　　　 　　　ex) pakcage 디렉토리명 ;
    2) 임포트 구문     

　　　 　　　ex) import java.io.*;
    3) 클래스 선언 {   

　　　 　　　ex) class 클래스명{
　　　(4) 멤버변수   

　　　 　　　ex) int i; (멤버변수는 초기화가 됨.)
　　　(5) 생성자    

　　　 　　　ex) 클래스명( ) { } (defalut 생성자는 파라미터 생성자가 없을때 자동으로 생성된다.)
　　　(6) 메소드      

　　　 　　　ex) void m( ) {구문..}
       }

(4) 객체 지향 용어

    1) 클래스 : 객체를 정의하는 붕어빵 틀, 설계도
    2) 객체    : 인스턴스
    3) 생성자(Constructor) : 인스턴스 변수(필드 값 등)를 초기화 시키는 역할
    4) 메소드(Method) : 어떠한 특정 작업을 수행하기 위한 명령문의 집합
    5) 속성 : 데이터타입의 정의(?)
   

 (5) 변수(Variable)

    1) 유효범위
      <1> 멤버(전역)
　　　 1> 클래스
　　　 2> 객체
      <2> 지역
　　　 1> 선언초기화
　　　 2> 파라미터
    2) static
       <1> 클래스
       <2> 객체
    3) final
       <1> 변수
       <2> 상수
    4) 메모리
       <1> 기본형 8개
       <2> 참조형 (레퍼런스)

(6) 제어

     '실행의 흐름' 

      JVM -> main( ) -> ...main( ) -> JVM

(7) 제어문

     1) 조건문
        - if
        - switch

     2) 반복문
        - for(초기값;조건식;증감식)
        - while ( )
        - do{ }while( )

(8) 제어 : 예약어

     1) break : 해당 바디를 나간다  (반복문, switch)
     2) continue : 건너뛰어서 증감식으로 간다 (반복문)
     3) return : 자기를 호출했던 곳으로 되돌린다

(9) 배열(Array)

     데이터의 '저장소' 객체

     1) 선언
        ex) int is[ ];
     2) 생성
        ex) new int[갯수];
     3) 초기화
        ex) 방에 저장되는 첫 번째 값

(10) 컬렉션(collection) 계열 ( ==  자료구조 == 가변배열 )

      참조형 데이터를 저장하는 '저장소' 객체 

     1) 종류
       <1> Collection
              |      |
            List    Set
       <2> Map
     2) 특징
       <1> List
          - 순서 보존
          - 중복 허용
       <2> Set
          - 순서 보존 X
          - 중복 허용 X
       <3> Map
          - key와 value 쌍
          - key중복 X, value 중복 O
          - 순서 보존 X

(11) OOP(OOP, Object-Oriented Programming) 특성

     1) 상속성 - 강제형 변환(제자리로 돌아갈 때- 자식이 쌔니까)
     2) 다형성 - 오버라이딩(메소드 재정의, 생성자 X)으로 한 객체가 여러 가지 일을 할 수 있다. 
     3) 은닉성 - 멤버 변수값(속성 값, 데이터)을 감추는 것
     4) 캡슐화 - 내용을 몰라도 형태만 알면 가져다 쓸 수 있는 것

(12) (메소드) 오버라이딩

     부모 메소드를 자식에서 바꾸는 것

     1) 부모의 접근제한자 보다 자식의 접근 제한자가 같거나 넓어야 한다.
     2) 메소드 만
     3) 반환 타입도 같아야 한다.
     4) 파라미터도 종류 순서 모두 같아야 한다.

(13) 제한자

     1) 접근
        public > protected > default > private
     2) 소유
        static
     3) 수정
        final
     4) 추상
        abstract

        ex)  interface Runnable
              {
            　　public  abstract void run();
         　　}

(14) 예외 (Exception)

      정상적으로 동작하지 못하게 하는 '돌발상황'

      1) 목적
         '돌발상황' -> '정상적으로 작동'
      2) 계층도
         <1> CompileException( CheckedException)
         <2> RuntimeException
      3) 방법
         <1> 적극
              try {
              } catch(Exception e) { }
         <2> 소극
              throws Exception
      4) try 절에 2개 이상의 예외 발생
         <1> 상속 O
              자식 예외부터 catch절
         <2> 상속 X
              catch절 순서 X
      5) 2개 이상의 예외를 떠넘길 때
         throws AException, BException,...
      6) finally절
         <1> 항상 수행
         <2> try절 나오면...
              catch 절이나 finally 절이나...
              둘 다 나오거나 해야 함
         <3> return 만나도 finally는 수행하고 return 함
         <4> 얘는 못 이김

                   System.exit(정수);

(15) 쓰레드(Thread)

프로세스를 구성하는 '제어의 흐름'

      1) Process / Thread 
         - Process : 실행의 단위 (실행되는 있는 프로그램)
         - Thread  : Process를 구성하는 작업 단위
      2) 생성
         - java.lang.Thread 상속법

         - java.lang.Runnable 상속법

      3) 시작
         th.start();

      4) 비유 : '피고용인'
      5) LifeCycle
         - 5가지
         - '메소드', '스케쥴러', '시간'
      6) Priority
         - 우선순위 th.setPriority(10);
         - 1 ~ 10
         - MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY
      7) 동기화
         - 멀티쓰레드에서 무결성을 보장하기 위해서
         - 비유: '화장실의 문고리'
         - schronized
         - 방법
           schronized void m( ) { }
   
           void m( ){
           　로직 1
         　　schronized (this) {
          　　　로직 2
          　　}
           }

Thread란?

　Process를 구성하는 '작업 단위'

MultiThread란?

　하나의 Process 내에서 여러 Thread가 동시에 작업을 수행하는 것

1) Thread class를 상속

예시

public class MultiThread extends Thread{
	MultiThread() {
		start();
	}
	void main1() {
		while(true) {
			try {
			Thread.sleep(1000);
			}catch(InterruptedException ie){}
			System.out.println("main");
			}
		}
	public void run() {
		while(true) {
			try {
			Thread.sleep(1000);
			}catch(InterruptedException ie){}
			System.out.println("Thread");
			}
		}
	public static void main(String[] args) {
		MultiThread mt = new MultiThread();
		mt.main1();
	}
}

2) Runnable인터페이스를 구현

예시

public class MultiThread2 implements Runnable{
	MultiThread2(){
		new Thread(this).start();
	}
	public void run() {
		while(true) {
			try {
				Thread.sleep(1000);
			}catch(InterruptedException ie) {}
			System.out.println("Thread");
		}
	}
	void main1() {
		while(true) {
			try {
				Thread.sleep(1000);
			}catch(InterruptedException ie) {}
			System.out.println("main");
		}
	}
	public static void main(String[] args) {
		MultiThread2 mt = new MultiThread2();
		mt.main1();
	}
}

참고

 *. start(); : 실행 시작

실행화면

main
Thread
Thread
main
Thread
main
main
Thread

두 소스를 실행화면 비슷하다.
실행 순서는 개발자가 알 수가 없다.

은닉화(Information Hiding)란 ?

정의

 외부 객체로부터 '속성 값(데이터, 멤버 변수값)'을 감추는 특성

조건

 접근제어자 private로 감춘다. (private - class내에서만 접근가능)

private를 사용하는 이유 ?

 외부로부터 데이터를 보호(캡슐화)하기 위해서
 인스턴스 변수는 private로 하여 외부에서 접근하지 못하도록 하고, 메서드는 public으로 하여 직접 접근은 막고 메서드를 통한 간접 접근 허용

 외부에는 불필요한, 내부적으로만 사용되는 , 부분을 감추기 위해서

접근 방법

 setter : 수정한다. 

 getter : 읽는다.

캡슐화(Encapsulation)란 ?

정의 

 객체가 은닉화 된 상태에서 메소드나 생성자의 일의 내용을 알 필요 없이, 그 형태(메서드 이름/파라미터/리턴 타입)만 알면 호출해서 사용할 수 있는 특성

예시

public class Hiding {
	private String add = "123456-2345678";
	private int balance = 2000;
	
	void setAdd(String add) {
		this.add = add;
	}
	String getAdd() {
		return add;
	}
	void setBalance(int balance) {
		this.balance = balance;
	}
	int getBalance() {
		return balance;
	}
	public static void main(String[] args) {
		Hiding h = new Hiding();

		h.setAdd("123456-1234123");
		System.out.println(h.getAdd());
		h.setBalance(40000);
		System.out.println(h.getBalance());
	}
}

실행화면

123456-1234123
40000

다형성(Polymorphism )이란 ?

정의

 '같은 타입'의 객체의 '같은 메소드'가 다른 일을 하는 특성

 객체를 부품 화하여 유지 보수를 용이하다.

조건

 상속, Overriding, 형 변환

예시

public class Pp {
	void see(){
		System.out.println("무엇을 본다");
	}
}
class CHee1 extends Pp {
	void see(){
		System.out.println("유튜브를 본다");
	}
}
class CHee2 extends Pp {
	void see(){
		System.out.println("TV를 본다");
	}
}
class CHee3 extends Pp {
	void see(){
		System.out.println("영화를 본다");
	}
}

public class Pp1 {
	public static void main(String[] args) {
		Pp a = new Pp();
		Pp b = new CHee1();
		Pp c = new CHee2();
		Pp d = new CHee3();
		a.see();
		b.see();
		c.see();
		d.see();
	}
}

실행화면

무엇을 본다
유튜브를 본다
TV를 본다
영화를 본다