비트캠프 기초특강 #종로학원 (19.11.18~11.22)

#Day01

Oracle 설치 - 구글창 - jdk 1.8 download - 검색 - 오라클 사이트 들어감 - https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

- Windows x64 설치 - 

 

#Java 셋팅하기.

Java 폴더로 매번 들어가서 컴파일을 할 수는 없으니, 환경변수라는 것을 등록하여 컴파일을 쉽게 할 수 있도록 한다.

제어판 - 시스템 - 고급시스템 - 고급 - 환경변수 - 변수 이름 : JAVA_HOME 

변수값 : C:\Program Files\Java\jdk1.8.0_231(자바 설치 경로)

JAVA_HOME 등록 후, 시스템 변수에서

Path 찾아서 편집

변수 값 수정 - 기존에 등록되어있는 변수 값 뒤에,

;%JAVA_HOME%\bin; 입력 후 확인 

(\이거는 엔터 위 원화표시를 말함. naver에서는 저렇게 나오는데 복사 붙혀넣기하면 원화로 잘 나옴.)

 

 

# cmd

cd ..  - 상위 파일로 올라간다.

cd p 입력 후 tab tab - Program Filse로 들어감.

 

#이클립스 설치

eclipse.org 사이트에서 x64 로 설치하기.

eclipse 파일 실행시킨 후 Eclipse IDE for Java Developers 설치하기

 

#이클립스

New - Java Project - 이름 설정(JavaBasic) - src - 마우스 오른쪽 - New - class

 

단축키

Ctrl+Shift+S : 전체 저장

Ctrl+F11 : 컴파일

F11 : 디버깅

 

#이클립스 글씨

Window - Preferences - font 검색 - Colors and Fonts - Basic - Text Font - Edit - 수정

 

#코드

public class HelloWorld {

public static void main(String[] args) {

System.out.println("Hello World!!!");

}

}

 

#명령어

// : 한 줄 주석 

/* ~ */: 여러 줄 주석

 

#자바 이름 짓는 규칙

 

#Ex01

//1. 주석(comment)

//주석이란 컴파일 될 때 무시가 되는 글자들이다.

//주로 프로그램에 대한 설명을 작성할 때 사용하게 된다.

//주석은 // 으로 한줄 주석을 만들거나

// /* */으로 여러줄 주석으로 만들어 줄 수 있다.

 

//2. "낙타등 표기법"(Camel back notation)

//낙타등 표기법이란?

//여러 단어로 이루어질 경우 단어의 첫 글자를 대문자로 만들어 주는 것

//예)firstNumber, myString

package day01;

//package : 비슷한 기능 혹은 목적을 가진 클래스들을 모아놓는 폴더

//소문자로 적어준다.

public class Ex01 {

//class는 대문자로 시작

public static void main(String[] args) {

//메소드란?

//클래스의 기능 부분을 뜻한다.

//소문자로 시작하는 동사이다.

//메소드는 "항상" 뒤에 괄호가 따라오므로 쉽게 알 수 있다.

 

//변수란?

//내용이 변하는 공간

//변수 선언하기

//데이터타입 변수명

//변수명은 소문자로 시작하는 명사

 

//상수란?

//내용이 한번 정해지면 못바꾸는 공간

//상수 선언하기

//final 데이터타입 상수명

//상수명은 모든 글자를 대문자로 적어주는 명사

final double PIE;

int myNumber;

}

}

 

+ 클래스는 필드와 메소드로 이루어진다.

메소드는 클래스의 기능을, 필드는 클래스의 내용을 저장한다.

 

 

#Ex02

package day01;

//데이터타입

//데이터타입은 크게 2가지로 나뉜다 : 기본형과 참조형

//기본형 : stack 메모리에 선언되고 값이 해당 주소에 들어간다.

//기본형에는 byte short int long float double char boolean 8가지만 있다.

//byte, short, int, long : 정수형 데이터타입(8비트, 16비트, 32비트, 64비트)

//float, double : 실수형

//char : 문자형

//boolean : 참/거짓

//참조형 : heap 메모리에 선언되고 해당 주소에는 그 변수로 들어가는 메모리 주소가 저장된다.

//참조형은 크게 class, interface, 배열 3가지 종류의 변수가 있다.

public class Ex02 {

public static void main(String[] args) {

//만약 데이터타입이 표현할 수 있는 최대 범위를 넘으면

//오히려 -로 가게 되는데

//이러한 버그를 overflow라고 한다.

//byte 127은 = 127

//byte(127+1) = -128

 

//반대로 표현할 수 있는 최소 범위를 넘으면

//+로 바뀌는데

//이러한 버그를 underflow라고 한다.

byte max = (byte)(127+1);

System.out.println(max);

}

}

 

#Ex03

package day01;

//산술연산자

//+ - * / %

 

public class Ex03 {

public static void main(String[] args) {

//변수를 만들어서 값을 넣어보자

//데이터타입 변수명 = 값;

int myNumber1 = 5;

int myNumber2 = 10;

System.out.println(myNumber1 + myNumber2);

System.out.println(myNumber1 - myNumber2);

System.out.println(myNumber1 * myNumber2);

System.out.println(myNumber1 / myNumber2);

System.out.println(myNumber1 % myNumber2);

//typecasting(형변환)

//데이터 타입을 바꿀 때에는 형변환을 해줘야 한다.

//형변환에는 2가지 방법이 있다.

//명시적 형변환 vs 암시적 형변환

long myNumber3 = myNumber2;

System.out.println(myNumber3);

int number2 = 128;

//명시적 형변환을 하는 방법:

//(바꿀 데이터타입)값

byte number4 = (byte)number2;

 

//더 큰 데이터 타입과 작은 데이터 타입을 산술연산하면?

//자동으로 더 큰 데이터 타입이 결과로 낭게 된다.

System.out.println(number4 + number2);

double myDouble = 1.0;

System.out.println(number4 * myDouble);

}

}

//myNumber1 / myNumber2의 답은 0.5가 정답이나,

//int가 정수형 데이터 타입이기 때문에 소수점 아래는 버려버려서 0이 나온다.

//이럴때는 실수형 데이터 타입인 double을 사용하면 0.5가 정상적으로 출력된다.

 

#Ex04

package day01;

//증감연산자

//현재 값을 1씩 증가하거나 감소하거나

//++     --

//다만 위치에 따라서 실행순서가 바뀌게 된다.

//증감연산자는 주로 제어문(control) 중 for 반복문에서 사용하게 된다.

public class Ex04 {

public static void main(String[] args) {

int a = 10;

System.out.println(a++); //System.out.println(a) -> a++ -> a는 11이 된다.

System.out.println(a); //11출력

System.out.println(++a); //++a -> System.out.println(a) -> a는 12가 된다.

System.out.println(a); //12출력

}

}

 

#Ex05

package day01;

//비교 연산자

//크냐, 크거나 같냐, 작냐, 작거나 같냐, 같냐, 다르냐

//>,   >=,      <,   <=,      ==,  !=

//비교는 항상 맞다 or 틀리다가 나오기 때문에

//결과값은 boolean이 된다.

public class Ex05 {

public static void main(String[] args) {

int a = 5;

int b = 6;

System.out.println(a > b);

System.out.println(a >= b);

System.out.println(a < b);

System.out.println(a <= b);

System.out.println(a == b);

System.out.println(a != b);

 

String str = "abc";

String str2 = new String("abc");

System.out.println(str);

System.out.println(str2);

System.out.println(str == str2);

}

}

 

#Ex06

package day01;

//논리연산자

//&& || !

public class Ex06 {

public static void main(String[] args) {

boolean isTrue = true;

boolean isFalse = false;

//&& = 앤드연산자

//둘다 트루일 때만 트루가 나온다.

System.out.println(isTrue && isFalse);

 

//|| = or 연산자

//둘 중 하나만 true여도 true가 나온다.

System.out.println(isTrue || isFalse);

 

//! = 반전 연산자

//true는 false로 false는 true로 바꿔준다.

System.out.println(! isTrue);

System.out.println(! isFalse);

 

System.out.println(isTrue && !isFalse);

//&&와 !를 같이 사용할 수도 있다.

 

int a = 10;

System.out.println(a > 0 && a < 100);

}

}

 

#Ex07

package day01;

//비트 연산자

//비트(2진법 숫자)에 대한 연산을 한다.

//&, |, ~, ^, <<, >>, >>>

public class Ex07 {

public static void main(String[] args) {

byte a = 5; //00000101

byte b = 20; //00010100

//& 연산 : 2자리가 모두 1일때만 1이 결과 값으로 나온다.

// 00000101

// 00010100

// --------

// 00000100 = 4

System.out.println(a & b);

 

//| 연산 : 둘 중 하나만 1이어도 1이 결과 값으로 나온다.

// 00000101

// 00010100

// --------

// 00010101 = 21

System.out.println(a | b);

 

//^ 연산 : 두 자리가 다를 때에만 1이 결과 값으로 나온다.

// 00000101

// 00010100

// --------

// 00010001 = 17

System.out.println(a ^ b);

 

//----------------2개의 숫자에 대한 연산------------------

 

//~ 연산 : 1은 0으로 0은 1로

//00010100

//11101011

//편하게 계산하자면 양수는 -를 붙히고 -1을 더해준다.

//네트워크 회사나 이미지 처리회사가 아니면 사실 비트연산자 자체를 잘 안쓴다.

System.out.println(~b);

 

//<< 연산: 오른쪽에 나온 자릿수 만큼 왼쪽으로 이동한다.

//a << 2; 비트를 왼쪽으로 2자리 이동한다.

// 00000101 << 2

// 0000010100 -> 자릿수가 8자리에서 10자리 -> 맨 왼쪽 2자리를 없애준다.

// 00010100 = 20

System.out.println(a << 2);

// 01011111 -> 0101111100

 

//>> 연산 : 오른쪽에 나온 자릿수만큼 오른쪽으로 이동한다.

//단! 맨 첫번째 비트를 그대로 가져간다.(맨 왼쪽 자릿수가 1이면 1로 채워준다)

//a >> 2; 비트를 오른쪽으로 2자리 이동한다.

//00000101 >> 2

//0000000101 -> 오른쪽 2자리를 없애준다.

//00000001 = 1

System.out.println(a >> 2);

 

b = -127; //10000001

//b >> 2;

//1110000001

//11100000 = -32

System.out.println(b >> 2);

 

// >>> -> 오른쪽 쉬프트연산을 하되 왼쪽 빈자리를 '0'으로만 채워라!

// 10000001 >>> 2

// 0010000001 

// 00100000 = 32

System.out.println(b >>> 2 );

}

}

 

#Ex08

package day01;

//스캐너 클래스 예제

//스캐너 클래스는 외부 클래스이기 때문에

//import 명령어를 통해서 가져와야 한다.

import java.util.Scanner;

public class Ex08 {

public static void main(String[] args) {

//클래스 변수 만들기

//클래스이름 변수 이름 = new 클래스이름();

Scanner scan = new Scanner(System.in);

 

//정수를 입력 받을때:스캐너 객체의 nextInt() 메소드로 입력받는다.

System.out.println("관리번호를 입력하세요: ");

int manageNumber = scan.nextInt();

System.out.println("관리번호 : "+manageNumber);

 

//String을 입력 받을 때: 스캐너 객체의 nextLine() 메소드로 입력받는다.

System.out.println("이름을 입력하세요 : ");

scan.nextLine();

String name = scan.nextLine();

System.out.println("이름: "+name);

scan.close();

}

}

 

+ 원래 저 빨간색 scan.nextLine();을 추가하지 않으면 이름을 입력할 수 없다.

이유는 위 관리번호 입력 받을때, int기 때문에 숫자만 가져가고 엔터는 가져가지 않는다.

따라서 빨간색줄이 없다면, 이름 입력 받을 때, 남아있는 엔터로 인해 종료가 된다.

그렇기 때문에 남아있는 엔터를 날려주기 위해서 빨간색 줄을 넣어준다.

 

#Ex09

package day01;

//사용자로부터 이름, 키(미터단위), 몸무게를 입력받아서

//이름 : ~~~ BMI : ~~~가 출력되는 프로그램을 만들어 봅시다.

//BMI 계산법 : 몸무게 / 키의 제곱 = 몸무게 / 키 / 키

import java.util.Scanner;

public class Ex09 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("이름을 입력하세요: ");

String name = scan.nextLine();

//지금은 nextLine부터 시랭하기 때문에

//버퍼메모리에 엔터키가 없고 따라서 nextLine을 단독 실행 시켜줄 필요가 없다.

System.out.println("키를 미터단위로 입력하세요: ");

double height = scan.nextDouble();

System.out.println("몸무게를 입력하세요: ");

double weight = scan.nextDouble();

 

double bmi = weight / height / height;

System.out.println("이름 : "+name+" BMI: "+bmi);

//스캐너는 메모리를 강제로 참조하기 때문에

//사용이 끝난 후에 닫아주지 않으면 항상 경고를 띄운다.

//닫아주는 방법은 close() 메소드를 실행하면 된다.

scan.close();

}

}

 

 

#Day02

 

#Ex01

package day02;

//if문 예제 01

//if문이란? 조건식이 true가 나오면 실행, false가 나오면 실행되지 않는 제어문이다.

//if - else if - else 로 구조가 이루어진다.

//if문 조건을 만족하면 아래의 else if + else는 무시가 되고

//if문 조건을 만족하지 않으면 else if를 체크

//else if도 만족하지 않을시엔 eles 가 실행된다.

//else if는 여러개가 나올 수 있다.

public class Ex01 {

public static void main(String[] args) {

int number = 5;

if(number >= 100) {

//if문의 조건식이 true가 나오면

//해당 code block이 실행된다.

//code block은 {} 으로 감싸진 부분을 code block이라고 한다.

System.out.println("number는 100보다 크거나 같습니다.");

}else if(number >= 10){

System.out.println("number는 100보다 작고 10보다 크거나 같습니다.");

}else if(number >= 0) {

System.out.println("number는 10보다 작고 0보다 크거나 같습니다.");

}else {

System.out.println("number는 음의 정수입니다.");

}

}

}

 

#Ex02

package day02;

//사용자로부터 이름과 국어점수를 입력받아서

//A, B, C, D, F,가 출력되는 프로그램을 만드세요.

import java.util.Scanner;

public class Ex02 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("사용자의 이름 : ");

String name = scan.nextLine(); 

System.out.println("사용자의 국어점수 : ");

int kor = scan.nextInt();

if(kor >= 90 && kor <= 100) {

System.out.println(name+"학생은 A");

} else if(kor >= 80 && kor <= 89) {

System.out.println(name+"학생은 B");

} else if(kor >= 70 && kor <= 79) {

System.out.println(name+"학생은 C");

} else if(kor >= 60 && kor <= 69) {

System.out.println(name+"학생은 D");

} else if(kor >= 0 && kor <= 59) {

System.out.println(name+"학생은 F");

} else {

System.out.println("점수를 잘못 입력하셨습니다.");

}

scan.close();

}

}

+ 나같이 트롤러들은 이상한 숫자넣고 그러기 때문에 미리 코드를 빡빡하게 짜야 한다.

 

#Ex03

package day02;

//switch

//switch는 조건식이 아니라

//변수를 잡아서 해당 변수가 나올 수 있는 값에 따라 조건문을 실행하게 된다.

public class Ex03 {

public static void main(String[] args) {

int number = 5;

switch(number) {

case 6:

System.out.println("6입니다.");

break;

case 5:

System.out.println("5입니다.");

break;

case 4:

System.out.println("4입니다.");

break;

default:

System.out.println("그외입니다.");

break;

}

}

}

 

#Ex04

package day02;

//switch 문에서 의도적으로 break를 생략하여

//특정 결과 값들의 실행코드를 컨트롤 하는 방법

public class Ex04 {

public static void main(String[] args) {

int month = 5;

switch(month) {

case 1:

case 3:

case 5:

case 7:

case 8:

case 10:

case 12:

System.out.println("31");

break;

case 4:

case 6:

case 9:

case 11:

System.out.println("30");

break;

case 2:

System.out.println("28");

break;

default:

System.out.println("잘못 입력하셨습니다.");

break;

}

}

}

 

#Ex05

package day02;

//점수를 입력받아서

//switch문을 이용해서

//A B C D F를 출력하시오

import java.util.Scanner;

public class Ex05 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("점수를 입력하시오");

int score = scan.nextInt();

if(score > 100 ) {

System.out.println("잘못 입력하셨습니다.");

} else {

switch(score/10) {

case 10:

case 9:

System.out.println("A");

break;

 

case 8:

System.out.println("B");

break;

 

case 7:

System.out.println("C");

break;

 

case 6:

System.out.println("D");

break;

 

case 5:

case 4:

case 3:

case 2:

case 1:

case 0:

System.out.println("F");

break;

 

default:

System.out.println("잘못 입력하셨습니다.");

break;

}

}

scan.close();

}

}

 

#Ex06

package day02;

//삼항연산자

//속도가 제일 빠르지만 코드 단독 실행이 불가

//대신 값을 초기화 할때 주로 사용된다.

 

import java.util.Scanner;

public class Ex06 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

int score = 59;

//삼항연산자를 쓸때는 

//조건식 ? 참일때 값 : 거짓일때 값

String result = score < 60 ? "낙제" : "합격";

//score < 60 ? System.out.println("낙제"); : System.out.println("합격");

 

//년을 입력받아서

//윤년인지 평년인지 출력하는 프로그램

//윤년의 조건 : 4로 나누어 떨어짐, 100으로 나누어 떨어지지 않음, 400으로 나누어 떨어짐

//

 

System.out.println("년을 입력하세요 : ");

int year = scan.nextInt();

//if문으로 만들 때

if(year % 4 == 0) {

//4로 나누어 떨어지니

//100을 체크

if(year % 100 == 0) {

//다시 400으로 나누어 떨어지는지 체크

if(year % 400 == 0) {

System.out.println("윤년");

}else {

System.out.println("평년");

}

}else { 

System.out.println("윤년");

}

}else { 

System.out.println("평년");

}

if(year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) {

System.out.println("윤년");

}else {

System.out.println("평년");

}

String yoon = year % 400 == 0 ? "윤년" : 

year % 4 == 0 && year % 100 != 0 ? "윤년" : "평년";

System.out.println(yoon);

scan.close();

}

}

 

 

#Ex07

package day02;

//for loop

//for loop 은 명확히 몇회동안 반복하라고 지시하게 된다.

//for(int i = 시작점; i < 끝날지점; i변화식) {

// 반복할 코드

//}

public class Ex07 {

public static void main(String[] args) {

//변수는 선언되면

//해당 코드 블록과 그 코드 블록의 하위 코드블록에서만 사용 가능하다.

//해당 코드 블록을 벗어나면 더이상 사용이 불가능하다.

//이것을 변수의 유효범위, 생명주기라고 표현한다.

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

if (i % 2 ==0) {

System.out.println(i+"는 짝수입니다.");

}else {

System.out.println(i+"는 홀수입니다.");

}

}

}

 

}

 

 

#Ex08

package day02;

//사용자로부터 입력을 받아서

//1부터 그 수까지의 시그마를 구하는

//프로그램을 만드세요.

import java.util.Scanner;

public class Ex08 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("숫자를 입력하시오.");

int number = scan.nextInt();

int sigma = 0;

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

sigma = sigma+i;

}

System.out.println("1부터"+number+"까지의 합은 "+sigma);

scan.close();

}

}

 

 

#Ex09

package day02;

//사용자로부터 숫자를 입력받아 그 숫자까지의 팩토리얼을 구하는

//프로그램을 작성하시오

//팩토리얼이란? 1부터 그 숫자까지의 곱

import java.util.Scanner;

public class Ex09 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("숫자를 입력하시오.");

int number = scan.nextInt();

int fact = 1;

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

fact = i * fact;

}

 

System.out.println("팩토리얼은 "+fact);

scan.close();

}

 

}

 

 

#Ex10

package day02;

//char

public class Ex10 {

public static void main(String[] args) {

//char는 ascii 테이블이라 불리는

//코드 테이블에서 숫자값에 대응하는 글자를 불러온다.

char myChar = 'a'; // char에 값을 넣을때에는 따옴표로 감싸준다.

//쌍따옴표는 String이라는 의미이다.

System.out.println((char)(myChar-32)); //a-32???

 

}

}

 

 

#Ex11

package day02;

//char ascii 값을 이용한 5x5 체스판 만들기

public class Ex11 {

public static void main(String[] args) {

//println과 print의 차이

//println은 ()안의 내용을 출력하고 자동으로 줄바꿈 한다.

//print는 ()안의 내용을 출력하고 그 옆으로 커서를 옮긴다.

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

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

System.out.print((char)('A'+i)+Integer.toString(j+1));

}

System.out.println();

}

}

}

 

#Ex12

package day02;

//1~100까지의 소수를 구하는 프로그램

//소수란? 1과 자기 자신을 제외한 앿가 없는 수

//숫자에서의 가장 큰 약수 = 자기자신

//요 2가지 조건을 이용해서 소수를 출력하는 프로그램을 만들어봅시다.

public class Ex12 {

public static void main(String[] args) {

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

int count = 0;

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

if(i % j == 0) {

count++;

}

}

if(count == 2) {

System.out.println(i+"는 소수입니다!");

}

}

}

}

 

#Ex13

package day02;

//while문

//while(조건식)

//조건식이 true 이면 실행, false이면 종료

public class Ex13 {

public static void main(String[] args) {

int myNum = 0;

while(myNum < 5) {

System.out.println("myNum은 5보다 작습니다. myNum은 "+myNum+"입니다.");

myNum++;

// }

// myNum = 0;

// while(myNum < 5) {

// System.out.println(myNum);

// }

// while(0 < 1) {

// System.out.println("아");

// }

// while(true) {

// System.out.println("무한루프");

}

}

}

 

#Ex14

package day02;

//무한루프를 이용한 메뉴 만들기

import java.util.Scanner;

public class Ex14 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

while(true) {

System.out.println("====비트 게임기====");

System.out.println("1. 새로시작 2. 세이브 로드하기 3. 종료하기");

int choice =scan.nextInt();

if(choice == 3) {

System.out.println("플레이해주셔서 감사합니다.");

break;

}

}

scan.close();i

}

}

 

 

#Day03

 

#Ex01

package day03;

 

import java.util.Scanner;

public class Ex01 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 : ");

int lineNumber = scan.nextInt();

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

String stars = "";

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

stars += "*";

}

System.out.println(stars);

}

scan.close();

}

 

}

 

#Ex02

package day03;

 

import java.util.Scanner;

public class Ex02 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 : ");

int lineNumber = scan.nextInt();

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

String stars = "";

for(int j = i ; j <= lineNumber ; j++) {

stars += "*";

}

System.out.println(stars);

}

scan.close();

}

}

 

#Ex03

package day03;

 

import java.util.Scanner;

public class Ex03 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 : ");

int lineNumber = scan.nextInt();

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

String stars = "";

for(int j = i; j <= lineNumber - 1; j++) {

stars += " ";

}

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

stars += "*";

}

System.out.println(stars);

}

scan.close();

}

}

 

#Ex04

package day03;

 

import java.util.Scanner;

public class Ex04 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 : ");

int lineNumber = scan.nextInt();

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

String stars = "";

for(int j = 1; j <= i-1; j++) {

stars += " ";

}

for(int j = i; j <= lineNumber; j++) {

stars += "*";

}

System.out.println(stars);

}

 

scan.close();

}

}

 

#Ex05

package day03;

 

import java.util.Scanner;

public class Ex05 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 : ");

int lineNumber = scan.nextInt();

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

String stars = "";

for(int j = i; j <= lineNumber - 1 ; j++) {

stars += " ";

}

for(int j = 1; j <= 2 * i -1 ; j++) {

stars += "*";

}

System.out.println(stars);

}

scan.close();

}

}

 

#Ex06

package day03;

 

import java.util.Scanner;

public class Ex06 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요: ");

int lineNumber = scan.nextInt();

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

String stars = "";

for(int j = 1; j <= i-1; j++) {

stars += " ";

}

for(int j = 1; j <= 2 * (lineNumber - i) +1 ; j++) {

stars += "*";

}

System.out.println(stars);

}

scan.close();

}

}

 

//선생님 풀이

//package day03;

//

//import java.util.Scanner;

//public class Ex062 {

// public static void main(String[] args) {

// Scanner scan = new Scanner(System.in);

// System.out.println("출력할 줄 수를 입력하세요 : ");

// int lineNumber = scan.nextInt();

// for(int i = lineNumber; i >= 1; i--) {

// String stars = "";

// for(int j = i; j <= lineNumber - 1 ; j++) {

// stars += " ";

// }

// for(int j = 1; j <= 2 * i -1 ; j++) {

// stars += "*";

// }

// System.out.println(stars);

// }

// scan.close();

// }

//}

 

#Ex07

package day03;

 

import java.util.Scanner;

public class Ex07 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 : ");

int lineNumber = scan.nextInt();

for(int i = 1; i <= 2 * lineNumber -1 ; i++) {

String stars = "";

if(i <= lineNumber) {

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

stars += "*";

}

}else {

for(int j = 1; j <= ((2 * lineNumber)- i) ; j++) {

stars += "*";

}

}

System.out.println(stars);

}

scan.close();

}

}

//선생님 풀이

//package day03;

//

//import java.util.Scanner;

//

//public class Ex077 {

// public static void main(String[] args) {

// Scanner scan = new Scanner(System.in);

// System.out.println("출력할 줄 수를 입력하세요 : ");

// int lineNumber = scan.nextInt();

// for(int i = 1; i <= lineNumber - 1; i++) {

// String stars ="";

// for(int j = 1; j <= i; j++) {

// stars += "*";

// }

// System.out.println(stars);

// }

// for(int i = 1; i <= lineNumber; i++) {

// String stars = "";

// for(int j = i; j <= lineNumber; j++) {

// stars += "*";

// }

// System.out.println(stars);

// }

// scan.close();

// }

//}

 

#Ex08

package day03;

 

import java.util.Scanner;

public class Ex08 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 : ");

int lineNumber = scan.nextInt();

for(int i = 1; i <= 2 * lineNumber - 1; i++) {

String stars = "";

if(i <= lineNumber) {

for(int j = i; j <= lineNumber - 1; j++) {

stars += " ";

}

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

stars += "*";

}

}else {

for(int j = 1; i - lineNumber >= j; j++ ) {

stars += " ";

}

for(int j = 1; j <= (2 * lineNumber) - i; j++ ) {

stars += "*";

}

}

System.out.println(stars);

}

scan.close();

}

}

 

//선생님 풀이

//package day03;

//

//import java.util.Scanner;

//public class Ex082 {

// public static void main(String[] args) {

// Scanner scan =  new Scanner(System.in);

// System.out.println("출력할 줄 수를 입력하세요 : ");

// int lineNumber = scan.nextInt();

// for(int i = 1; i <= 2 * lineNumber - 1; i++) {

// String stars = "";

// if(i <= lineNumber -1) {

// //윗부분

// for(int j = i; j <= lineNumber -1; j++) {

// stars += " ";

// }

// for(int j = 1; j <= i; j++) {

// stars += "*";

// }

// }else { 

// //아랫부분

// int lowerI = i - lineNumber + 1;

// for(int j = 1; j <= lowerI -1; j++) {

// stars += " ";

// }

// for(int j = lowerI; j <= lineNumber; j++) {

// stars += "*";

// }

// }

// System.out.println(stars);

// }

// scan.close();

// }

//}

 

#Ex09

package day03;

 

import java.util.Scanner;

public class Ex09 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 : ");

int lineNumber = scan.nextInt();

for(int i = 1; i <= 2 * lineNumber -1; i++) {

String stars = "";

if(i<= lineNumber) {

for(int j = 1; j <= lineNumber - i + 1; j++) {

stars += "*";

}

} else {

for(int j = 1; j <= i - lineNumber + 1; j++)

stars += "*" ;

}

System.out.println(stars);

}

scan.close();

}

}

//선생님 풀이

//package day03;

//

//import java.util.Scanner;

//public class Ex09 {

// public static void main(String[] args) {

// Scanner scan = new Scanner(System.in);

// System.out.println("출력할 줄 수를 입력하세요: ");

// int lineNumber = scan.nextInt();

// for(int i = 1; i <=lineNumber * 2 - 1; i++) {

// String stars = "";

// if(i <= lineNumber -1 ) {

// for(int j = i; j <= lineNumber; j++) {

// stars += "*";

// }

// }else {

// int lowerI = i - lineNumber + 1;

// for(int j = 1; j <= lowerI; j++) {

// stars += "*";

// }

//

// }

// System.out.println(stars);

// }

// scan.close();

// }

//}

 

#Ex10

package day03;

 

import java.util.Scanner;

public class Ex10 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 : ");

int lineNumber = scan.nextInt();

for(int i = 1; i <= 2 * lineNumber - 1; i++ ) {

String stars = "";

if(i <= lineNumber ) {

for(int j = 1; j <= i - 1; j++ ) {

stars += " ";

}

for(int j = 1; j <= lineNumber - i + 1; j++) {

stars += "*";

}

} else {

for(int j = 1; j <= 2 * lineNumber - i - 1; j++) {

stars += " ";

}

for(int j = 1; j <= i - lineNumber + 1; j++) {

stars += "*";

}

}

 

System.out.println(stars);

}

scan.close();

}

}

 

//선생님 풀이

//package day03;

//

//import java.util.Scanner;

//public class Ex10 {

// public static void main(String[] args) {

// Scanner scan = new Scanner(System.in);

// System.out.println("출력할 줄 수를 입력하세요 : ");

// int lineNumber = scan.nextInt();

// for(int i = 1; i <= 2 *lineNumber - 1; i ++) {

// String stars = "";

// if(i <= lineNumber -1) {

// for(int j = 1; j <= i -1; j++) {

// stars += " ";

// }

// for(int j = i; j <= lineNumber; j++) {

// stars += "*";

// }

// } else {

// int lowerI = i - lineNumber +1;

// for(int j = lowerI; j <= lineNumber -1; j++) {

// stars += " ";

// }

// for(int j =1; j <= lowerI; j++) {

// stars += "*";

// }

// }

// System.out.println(stars);

// }

// scan.close();

// }

//}

 

 

#Ex11

package day03;

 

import java.util.Scanner;

public class Ex11 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 :");

int lineNumber = scan.nextInt();

for(int i = 1; i <= 2 * lineNumber - 1; i++) {

String stars = "";

if(i <= lineNumber) {

for(int j = 1; j <= lineNumber - i + 1; j++) {

stars += " ";

}

for(int j = 1; j <= 2 * i - 1 ; j++) {

stars += "*";

}

} else {

for(int j = 1; j <= i-lineNumber + 1; j++) {

stars += " ";

}

for(int j = 1; j <= 2 * (2 * lineNumber - i) -1; j++) {

stars += "*";

}

}

System.out.println(stars);

}

scan.close();

}

}

 

//package day03;

//

//import java.util.Scanner;

//

//public class Ex11 {

// public static void main(String[] args) {

// Scanner scan = new Scanner(System.in);

// System.out.println("출력할 줄 수를 입력하세요: ");

// int lineNumber = scan.nextInt();

// for (int i = 1; i <= 2 * lineNumber - 1; i++) {

// String stars = "";

// if (i <= lineNumber - 1) {

// for (int j = i; j <= lineNumber - 1; j++) {

// stars += " ";

// }

// for (int j = 1; j <= 2 * i - 1; j++) {

// stars += "*";

// }

// } else {

// //lowerI는 1 2 3 4 5 .... lineNumber가 된다.

// int lowerI = i - lineNumber + 1;

// //위의 나온 lowerI를 역순으로 바꿔주기 위해

// //lineNumber - lowerI + 1을 해준다.

// //reversedI는 lineNumber lineNumber-1 .....1 이 된다.

// int reversedI = lineNumber - lowerI + 1;

//

// for (int j = reversedI; j <= lineNumber - 1; j++) {

// stars += " ";

// }

// for (int j = 1; j <= 2 * reversedI - 1; j++) {

// stars += "*";

// }

// System.out.println(stars);

// }

// scan.close();

// }

// }

//

//}

 

#Ex12

package day03;

 

import java.util.Scanner;

 

public class Ex12 {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

System.out.println("출력할 줄 수를 입력하세요 : ");

int lineNumber = scan.nextInt();

 

for (int i = 1; i <= 2 * lineNumber - 1; i++) {

String stars = "";

if (i == 1 || i == 2 * lineNumber - 1) {

for (int j = 1; j <= 2 * lineNumber - 1; j++) {

stars += "*";

}

} else if (i <= lineNumber) {

for (int j = 1; j <= lineNumber - i + 1; j++) {

stars += "*";

}

for (int j = 1; j <= 2 * (i - 1) - 1; j++) {

stars += " ";

}

for (int j = 1; j <= lineNumber - i + 1; j++) {

stars += "*";

}

} else {

for (int j = 1; j <= i - lineNumber + 1; j++) {

stars += "*";

}

for (int j = 1; j <= 2 * (2 * lineNumber - i - 1) - 1; j++) {

stars += " ";

}

for (int j = 1; j <= i - lineNumber + 1; j++) {

stars += "*";

}

}

System.out.println(stars);

}

scan.close();

}

}

 

//선생님 풀이

//package day03;

//

//import java.util.Scanner;

//public class Ex121 {

// public static void main(String[] args) {

// Scanner scan = new Scanner(System.in);

// System.out.println("출력할 줄 수를 입력하세요: ");

// int lineNumber = scan.nextInt();

// for(int i = 1; i <= 2*lineNumber - 1; i++) {

// String stars = "";

// if(i == 1 || i == 2 * lineNumber -1) {

// for(int j = 1; j <= 2*lineNumber -1; j++) {

// stars += "*";

// }

// } else if(i <= lineNumber -1 ) {

// for(int j = i; j <= lineNumber; j++) {

// stars += "*";

// }

// for(int j = 1; j <= 2 * (i - 1) - 1; j++ ) {

// stars += " ";

// }

// for(int j = i; j <= lineNumber; j++) {

// stars += "*";

// }

// }else { 

// int lowerI = i - lineNumber + 1;

// for(int j = 1; j <= lowerI; j++) {

// stars += "*";

// }

// for(int j = 1; j <= 2 * (lineNumber-lowerI)-1; j++) {

// stars += " ";

// }

// for(int j = 1; j <= lowerI; j++) {

// stars += "*";

// }

// }

// System.out.println(stars);

// }

// scan.close();

// }

//

//}

 

 

#Day04

 

#Student

package day04;

 

public class Student {

//field

//해당 객체의 정보가 들어가는 곳

//필요한 정보에 따라서 변수 선언하듯이 선언만 한다.

private int id;

//이제 모든 필드들이 private이 되었기 때문에

//외부에서 직접적으로 값을 넣거나 뺄 수 없게 된다.

//따라서 메소드를 만들어서 해당 클래스의 필드들의 값을 관리 할 수 있게 해야한다.

 

//값을 외부에서 받아서 객체 내부에 저장할 때에는 setter 메소드를 사용한다.

//setter는 public void set필드이름(필드데이터타입 필드이름)으로 선언한다.

public void setId(int id) {

//this란? 해당 메소드를 호출하는 객체 자신을 뜻한다.

this.id = id;

}

//getter는 현재 필드에 저장된 값을 호출한 곳으로 보내주는 메소드이다.

//getter는 public 필드데이터타입 get필드이름()으로 선언한다.

public int getId() {

return id;

}

private String name;

 

public void setName(String name) {

this.name = name;

}

public String getName() {

return name;

}

 

private int kor;

 

public void setKor(int kor) {

this.kor = kor;

}

public int getKor() {

return kor;

}

 

private int eng;

 

public void setEng(int eng) {

this.eng = eng;

}

public int getEng() {

return eng;

}

 

private int math;

public void setMath(int math) {

this.math = math;

}

 

public int getMath() {

return math;

}

 

 

//method는 이 클래스의 기능부분이다.

//method는

//접근제한자 리턴타입 메소드이름(파라미터 내용) 으로 선언한다.

//리턴타입은 해당 메소드가 끝나고 나서 호출 된 곳으로 보내줄 값의 데이터타입

//파라미터는 해당 메소드가 호출될 때 받아서 메소드 내부에서 사용할 재료

//파라미터의 이름은 호출된 곳에서 넘겨받을 변수 혹은 값의 이름과 같을 필요가 없다.

//다만 이 메소드 내부에서는 해당 이름으로 쓰게 된다.

public void showName(String name) {

System.out.println("이름은 "+name);

}

//접근 제한자란? (Access modifier)

//해당 field 나 method가 어디서 접근할 수 있는지 정한다.

//public, package(=default), protected, private 4단계가 있다.

//public: 어디서든지 접근 가능

//package: 패키지 내부에서만 접근 가능. 만약 별도의 접근 제한자를 써주지 않으면

// 자동으로 package 접근제한이 걸리게 된다.

//protected: 패키지 내부 + 상속받는 클래스까지만 접근 가능

//private: 외부의 접근을 모두 막는다.

 

//근데 이제는 정말 외부에서 쓸 메소드들만 public 나머지는 모두다 private

//여기서 말하는 클래스 내부에서만 쓰는 method들과 모든 field를 말함

 

//생성자란?

//해당 클래스의 객체가 만들어질때 호출되는 메소드이다.

//해당 객체가 만들어질 때 해야하는 행동들이나 혹은 초기화값들을 정해줄 수 있다.

//우리가 안만들어줘도 자바가 자동으로 만들어주는 생성자가 있는데

//해당 생성자는 기본형 데이터타입의 필드들은 0으로 초기화하고

//참조형 데이터타입의 필드들은 null로 초기화한다.

//생성자는 public 클래스이름()으로 선언한다.

 

//생성자에는 파라미터가 있는 생성자와 파라미터가 없는 생성자가 있는데

//파라미터가 있는 생성자를 만들어주면 기본 생성자와 파라미터가 없는 생성자는

//쓸 수 없게 된다.

//따라서 파라미터가 있는 생성자를 만들고 나서 파라미터가 없는 생성자가도 필요하면

//추가로 만들어줘야한다.

public Student(String name, int id, int kor, int eng, int math) {

System.out.println("파라미터가 있는 생성자 호출");

this.name = name;

this.id = id;

this.kor = kor;

this.eng = eng;

this.math = math;

 

}

public Student() {

name = "학생";

id = -1;

kor = -1;

eng = -1;

math = -1;

}

public String toString() {

return id+" "+name+" "+kor+" "+eng+" "+math;

}

 

//equals 메소드란?

//해당 객체와 파라미터로 들어오는 모든 것을 비교하는 메소드이다.

//만약 해당 객체와 데이터타입이 같고

//해당 객체의 특정 필드와 값이 같으면 똑같은 객체로 판단하여

//true를 리턴하고

//만약 같은 종류가 아니거나 필드의 값이 다르다면 false를 리턴해준다.

 

public boolean equals(Object o) {

if(o instanceof Student) {

Student s = (Student)o;

if(this.id == s.id && this.name.equals(s.name)) {

return true;

}

}

return false;

}

}

 

 

#StudentEx

 

package day04;

 

import java.util.Scanner;

public class StudentEx {

public static void main(String[] args) {

Student s = new Student("조재영", 0, 80, 90, 100);

String str = "abc";

s.showName(str);

s.showName("조재영");

s.setId(0);

 

Student s2 = new Student();

s2.showName(str);

s2.setId(2);

 

s.setId(1);

s.setName("조재영");

s.setKor(80);

s.setEng(90);

s.setMath(100);

System.out.println("이 핵상의 이름은 : "+s.getName());

System.out.println("이 학생의 이름은 : "+s2.getName());

 

//System.out.println 메소드는

//파라미터로 class 객체가 들어오면

//해당 객체의 toString()이라는 메소드를 실행시켜서

//그 결과값을 화면에 출력한다.

 

//우리가 따로 toString()메소드를 만들지 않아도

//자바에서 만들어준 toString()메소드를 실행시켜서

//출력해주는데

//자바에서 만들어주는 toString()메소드는

//패키지명.클래스이름@메모리주소값을 보여준다.

 

//따라서 우리가 객체의 필드값을 println으로 보여줄려면

//getter를 호출하거나 toString()메소드를 만들어서 보여줘야 한다.

 

System.out.println(s);

System.out.println(s2);

 

//equals 메소드 실행결과

System.out.println(s.equals(s2));

s2.setId(0);

s2.setName("조재영");

System.out.println(s.equals(s2));

}

}

 

 

#car

package day04;

//필드 : 번호판번호, 차량 종류, 색깔, 최고속도

//메소드 : toString, equals, getter/setter

 

public class Car {

private String plateNumber;

private String type;

private String color;

private int maxSpeed;

 

public String toString() {

return plateNumber + " " + type + " " + color + " " + maxSpeed;

}

public boolean equals(Object o) {

if(o instanceof Car) {

Car c = (Car)o;

if(this.plateNumber.equals(c.plateNumber)) {

return true;

}

}

return false;

}

public String getPlateNumber() {

return plateNumber;

}

public void setPlateNumber(String plateNumber) {

this.plateNumber = plateNumber;

}

public String getType() {

return type;

}

public void setType(String type) {

this.type = type;

}

public String getColor() {

return color;

}

public void setColor(String color) {

this.color = color;

}

public int getMaxSpeed() {

return maxSpeed;

}

public void setMaxSpeed(int maxSpeed) {

this.maxSpeed = maxSpeed;

}

}

 

 

#Ex01

package day04;

 

import java.util.Random;

 

//배열

//배열이란? 똑같은 데이터타입이 모여있는 구조

 

public class Ex01 {

private static final int SIZE = 6;

private static final int MAX = 45;

public static void main(String[] args) {

//배열은

//데이터타입[] 배열이름 = new 데이터타입[크기]

//으로 선언한다.

int[] lottoNumber = new int[SIZE];

//위의 코드에서 6은 magic number이다.

//이러한 '마법의 숫자'는 사용을 기피해야한다.

//만약 이렇게 크기를 정해줘야 한다면

//상수로 만들어서 써야한다!

//상수로 만드는 것은 private static final int SIZE = 6;

//이런식으로 상수로 때려박는다.

 

//배열의 각 요소에 접근할대에는 index번호를 써서 접근한다.

lottoNumber[0] = 5;

//위의 코드는 배열에 0번째에 5를 집어넣는다는 의미

System.out.println(lottoNumber[0]);

//배열의 0번째 요소에 저장된 값을 출력하라.

 

//아래 코드는 오류가 난다.

//lottoNumber[6] = 11;

//왜냐하면 컴퓨터는 숫자를 0부터 세기 때문에

//가장 마지막 인덱스 번호는 크기 -1이다.

//따라서 현재 lottoNumber의 크기는 6이기 때문에

//마지막 인덱스는 5이고, 6은 에러가 난다.

 

//본격적으로 로또번호 추첨기를 만들어보자

//랜덤클래스는 0~1 사이에 실수를 갖고 있고 그걸로 난수를 제작한다.

Random random = new Random();

 

//만들어진 랜덤클래스로 lottoNumber에 차례대로 난수를 집어넣어보자.

lottoNumber[0] = random.nextInt(45)+1;

//nextInt(숫자)를 하게 되면 0~숫자 -1까지 난수가 나오기 때문에

//+1을 해줘서 1~숫자까지의 난수가 나오게 만들어준다.

lottoNumber[1] = random.nextInt(45)+1;

lottoNumber[2] = random.nextInt(45)+1;

lottoNumber[3] = random.nextInt(45)+1;

lottoNumber[4] = random.nextInt(45)+1;

lottoNumber[5] = random.nextInt(45)+1;

 

//하지만 위의 코드는 매우 나쁜 코드이다.

//하드코딩의 대표적인 예시

for(int i = 0; i < lottoNumber.length; i++) {

lottoNumber[i] = random.nextInt(MAX)+1;

}

 

//하지만 위의 코드에서는 중복이 발생할 수 있다.

//2중 for문을 이용해서 중복된 숫자를 새로 배정하는 코드를 만들어보자

for(int i = 0; i <lottoNumber.length; i++) {

for(int j = 0; j < lottoNumber.length; j++) {

if(lottoNumber[i] == lottoNumber[j] && i != j ) {

lottoNumber[i] = random.nextInt(MAX)+1;

j = -1;

 

}

}

}

 

//2중 for문으로 중복제거 완료 후

//정렬을 하는 코드

//정렬을 할 때 현재 i번째와 i+1번째를 비교해서 i가 더 크면

//2개의 순서를 바꿔준다.

 

for(int i = 0; i < lottoNumber.length

-1; i++) {

if(lottoNumber[i] > lottoNumber[i+1]) {

int temp = lottoNumber[i];

lottoNumber[i] = lottoNumber[i+1];

lottoNumber[i+1] = temp;

i = -1;

}

 

}

 

for(int i = 0; i <lottoNumber.length; i++) {

System.out.println(lottoNumber[i]);

}

}

}

 

 

#Ex02

package day04;

 

 

public class Ex02 {

public static void main(String[] args) {

Car[] arrayCar = new Car[5];

//위의 코드는 배열에 대해서만 메모리 확보가 되었기 때문에

//각 요소는 다시 한번 new로 초기화해줘야

//사용가능하다.

for(int i = 0; i < arrayCar.length; i++) {

arrayCar[i] = new Car();

}

arrayCar[0].setPlateNumber("01가 0000");

//2번째, 배열에 비어있는데를 찾으려면 배열 전체를 다 돌아다녀야한다.

for(int i = 0; i <arrayCar.length; i++) {

if(arrayCar[i].getPlateNumber() == null) {

System.out.println(i+"번째가 비어있습니다.");

}

}

}

}

 

 

#Ex03

package day04;

// ArrayList 예제!

 

import java.util.ArrayList;

public class Ex03 {

public static void main(String[] args) {

//ArrayList란?

//배열과 비슷하지만 클래스로 되어있어서

//좀 더 사용하기가 쉽다.

//ArrayList<데이터타입> list = new ArrayList<>();로 선언해서 사용한다.

 

ArrayList<Integer> list = new ArrayList<>();

//< >안에는 클래스만 들어올 수 있다.

//그럼 기본형 데이터타입 8개의 경우는?

//자바에서 제공하는 포장클래스(wrapper class)를 사용하면 된다.

//int의 경우에는 Integer

 

//안에 몇개의 요소가 들어있는지 볼때에는 size()메소드를 실행한다.

System.out.println(list.size());

 

//제일 먼저 값을 집어 넣을 때에는 add() 메소드를 사용한다.

//파라미터는 우리가 < > 안에 집어넣은 데이터타입과 일치해야한다.

//단 wrapper class일 경우 기본형 데이터타입을 넣어도 된다.

 

list.add(5);

System.out.println(list.size());

 

//ArrayList 안에서 객체를 뺄때는 (배열의 배열[index]처럼)

//get(인덱스번호)메소드를 실행한다.

System.out.println(list.get(0));

 

//만약 ArrayList에서 제거하고 싶다면?

//2가지 방법이 가능하다.

//1번. 제거하는 요소의 인덱스 번호를 알고 있을때

//2번. 제거하는 객체를 직접 넣어줄때

//둘다 remove()의 파라미터를 줄 수 있다.

//객체를 넣어줄 때에는 list의 각 요소에 대해 equals() 메소드를 실행하고

//true가 나오는 첫번째 요소를 제거해준다.

Integer number = 5;

list.remove(number);

System.out.println(list.size());

 

//해당위치의 요소를 다른걸로 바꿀 때에는

//set(위치, 바꿀 객체)를 실행시켜서 바꿔줄 수 있다.

list.add(6);

System.out.println(list.get(0));

list.set(0, 26);

System.out.println(list.get(0));

 

//만약 해당 객체의 인덱스 번호가 궁금하면?

//indexOf(객체)로 첫번째로 등장하는 인덱스를 알 수 있다.

//단 해당 객체를 찾디 못한다면? -1이 나온다.

System.out.println(list.indexOf(26));

System.out.println(list.indexOf(55));

 

//해당 객체가 리스트에 있는지 없는지 궁금하다면?

//contain(객체) 메소드를 실행하면

//있으면 true, 없으면 false가 나온다.

System.out.println(list.contains(26));

System.out.println(list.contains(30));

}

}

 

 

#Ex04

package day04;

//ArrayList를 사용한 로또번호 제작기

//배열은 사이즈를 정해두지만, ArrayList는 add로 사이즈를 추가하기 때문에

//원래 예상보다 사이즈가 커져도 배열은 터지지만, ArrayList는 터지지 않는다.

import java.util.ArrayList;

import java.util.Collections;

import java.util.Random;

public class Ex04 {

private static final int MAX = 45;

public static void main(String[] args) {

Random rand = new Random();

ArrayList<Integer> lottoNumbers = new ArrayList<>();

while(lottoNumbers.size() < 6) {

int randomNumber = rand.nextInt(45)+1;

if(!lottoNumbers.contains(randomNumber)) {

lottoNumbers.add(randomNumber);

}

}

//단순 출력만 할때에는

//배열이나 arrayList를 좀 더 쉽게 for 문을 돌리는 방법

for(int i : lottoNumbers) {

//위에 ()의 의미는 해당 리스트에서 순서대로 하나씩 뽑아와서

//임시 변수인 i에 값을 복사한다는 뜻이 된다.

//즉 i에 값을 바꾸더라도 원본인 lottoNumbers 안에 값은 바뀌지 않는다.

//또한 이 방식을 할 때 주의할 점음

//remove 나 add같이 크기를 바꾸는 메소드는 실행하면 안된다는 것이다.

System.out.println(i);

}

Collections.sort(lottoNumbers);

for (int i : lottoNumbers) { 

System.out.println();

}

}

}

 

 

#Human

package day04;

 

public class Human {

public String name;

 

public void think() {

System.out.println("생각한다.");

}

public void think(Human h) {

System.out.println(h.name + "는 사람입니다.");

}

public void think(Human h1, Human h2) {

System.out.println(h1.name+"는 사람입니다.");

System.out.println(h2.name+"도 사람입니다.");

System.out.println();

}

//아래의 think 메소드는 오버로딩 될 수 없다.

//왜냐하면 파라미터 내용이 같기 때문이다.

//Human h로 휴먼 한명에 대해 선언했기 때문에

// public void think(Human h) {

// System.out.println(h.name+"은 사람이 아닙니다.");

// }

//

//overriding vs overloading

//오버라이딩이란?

//부모로부터 상속받는 메소드를 자식이

//새롭게 정의해서 자식에게 좀 더 맞게 바꿔주는 것

 

//오버로딩이란?

//같은 이름의 메소드가 같은 클래스에 정의되어있지만

//파라미터의 내용이 달라지면서 똑같은 이름의 메소드를 추가할 수 있는 것.

}

 

 

#Korean

package day04;

//상속이란?

//부모 클래스의 field와 메소드를 물려받아서

//자식 클래스는 그것을 또 선언해주거나 만들어줄 필요가 없어지므로

//부모 클래스의 코드 재 사용성이 매우 늘어나게 된다.

//자식 클래스도 해당 코드들을 다시 안써줘도 되기 때문에

//개발 시간이 짧아지게 된다.

 

//클래스 상속은 extends 라는 예약어로 실행된다.

//예약어란, 자바에서 미리 사용하기로 한 단어들로써

//해당 단어로는 변수의 이름을 지정할 수 없다.

//예약어는 36개가 있고 여러분들은 외울 필요가 없다.

//왜? 이클립스에서 자주색으로 표시되는 단어들이 바로 예약어이기 때문이다.

 

public class Korean extends Human{

public void speak() {

System.out.println(name+"는 한국말한다!");

}

//오버라이딩이란 부모 클래스로부터 상속받은 메소드를

//자식이 필요에 따라서 재정의하는 것이다.

//이렇게 재정이 되면 자식 클래스 객체가 해당 메소드를 호출 할 시에

//부모 클래스의 메소드가 아닌 자식 클래스에서 재정의한 메소드가 호출된다.

public void think() {

System.out.println("한국말로 생각한다.");

}

}

 

 

#KoreanEx

package day04;

 

public class KoreanEx {

public static void main(String[] args) {

Korean k = new Korean();

k.name = "조재영";

k.think();

k.speak();

 

 

Human h = new Human();

Japanese j = new Japanese();

j.think();

h.think(j);

 

 

}

}

 

#Japanese

package day04;

 

public class Japanese extends Human{

public void speak() {

System.out.println(name+"은 일본말을 합니다.");

}

}

 

 

#Day05

 

#ParkDTO

package day05;

//객체지향 프로그래밍에는

//5가지 원칙이 있다. (SOLID)

//그 중 첫번째 원칙이 바로 Single Responsibility Principle

//개별 책임 원칙이다.

//이 원칙은 생각보다 간단하다.

//클래스는 한개의 기능만 책임져야 한다는 것이다.

//대표적인 예가 POJO 클래스이다. POJO 클래스는 다른 기능은 없이

//오직 데이터를 담는 틀의 역할만 한다.

//즉 프로그램의 기능을 컨트롤 하는건 다른 클래스가 담당해야되고

//프로그램의 UI는 또 다른 클래스가 담당해야하는 것이다.

public class ParkDTO {

//DTO = Data Transfer Object

//이 안에는 field 와 getter/setter, equals, toString 정도만 들어간다!

private String number;

private int inTime;

public String getNumber() {

return number;

}

public void setNumber(String number) {

this.number = number;

}

public int getInTime() {

return inTime;

}

public void setInTime(int inTime) {

this.inTime = inTime;

}

//ArrayList의 contains, indexOf 등의 메소드들은

//template으로 들어온 class의 equals 메소드를 호출해서

//그 결과값을 메소드 내부에서 사용한다.

//우리 프로그램에선 차량 번호가 같으면 같은 차량이므로

//number를 기준으로 한 equals 메소드를 만들어준다.

public boolean equals(Object o) {

if(o instanceof ParkDTO) {

ParkDTO p = (ParkDTO)o;

if(this.number.equals(p.number)) {

return true;

}

}

return false;

}

}

 

 

#ParkController

 

package day05;

//controller 클래스는

//ArrayList를 이용해서

//ParkDTO를 관리하는 클래스가 된다.

//실제 DB와 연결되면 ArrayList를 필드로 가지고 있을

//필요가 없지만 우리는 DB가 없으므로

//field의 ArrayList를 유사 db로 쓸 것이다.

 

import java.util.ArrayList;

 

public class ParkController {

private final int MAX = 5;

private final int UNIT_MINUTE = 10;

private final int UNIT_PRICE = 1000;

private ArrayList<ParkDTO> list;

public ParkController() {

//이렇게 하면 생성자만 호출해도 list가 사용될 준비가 된다.

list = new ArrayList<ParkDTO>();

}

public boolean checkNumberExist(String number) {

//클래스 변수(=객체)는 필요할 때마다 만들어서 써주면 된다.

ParkDTO p = new ParkDTO();

p.setNumber(number);

return list.contains(p);

}

public boolean validateTime(int time) {

int hour = time / 100;

int min = time % 100;

if(hour > -1 && hour < 24 && min > -1 && min <60) {

return true;

}

return false;

}

public boolean findEmpty() {

return list.size() < MAX;

}

public void insert(ParkDTO p) {

list.add(p);

}

public boolean isEmpty() {

return list.isEmpty();

}

//2가지 방법이 가능하다.

//1. parkDTO 객체 보내주기

//2. inTime만 보내주기

public ParkDTO selectOne(ParkDTO p) {

return list.get(list.indexOf(p));

}

public int calcRate(ParkDTO p, int outTime) {

int hourDifference = outTime / 100 - p.getInTime() / 100;

int minuteDifference = outTime % 100 - p.getInTime() % 100;

int totalDifference = 60 * hourDifference + minuteDifference;

return totalDifference / UNIT_MINUTE * UNIT_PRICE;

}

public void remove(ParkDTO p) {

list.remove(p);

}

}

 

#ParkEx

 

package day05;

 

import java.util.Scanner;

public class ParkEx {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

ParkController controller = new ParkController();

while (true) {

System.out.println("===============");

System.out.println("비트 주차 관리 프로그램");

System.out.println("===============");

System.out.println("1.입차 2.출차 3.종료");

int choice = scan.nextInt();

if (choice == 3) {

System.out.println("사용해주셔서 감사합니다.");

break;

} else if (choice == 1) {

// 입차 시작.

// 제일 먼저 빈 자리가 있는지 체크한다.

if (controller.findEmpty()) {

// 빈자리가 존재하므로 차량 번호 입력을 받는다.

scan.nextLine();

System.out.println("입차할 차량 번호를 입력하세요: ");

ParkDTO p = new ParkDTO();

p.setNumber(scan.nextLine());

while (controller.checkNumberExist(p.getNumber())) {

// while문이 반복된다. = 중복된 차량 번호이다.

System.out.println("이미 입차된 번호입니다.");

System.out.println("입차할 차량 번호를 입력하세요 : ");

p.setNumber(scan.nextLine());

}

// while문을 넘겼다 = 중복된 차량번호가 아니다 -> 시간 입력 받기

System.out.println("입차 시간을 입력해주세요 : ");

int inTime = scan.nextInt();

// while문 안에 !countroller.validateTime(intime)만 넣어도 된다.

// True 값이 나오게 하여 무한루프에 갇히게 한다.

while (controller.validateTime(inTime) == false) {

System.out.println("형식이 잘못 되었습니다.");

System.out.println("입차 시간을 입력해주세요 : ");

inTime = scan.nextInt();

}

// 이번 while문의 끝 = 시간이 올바른 형식

// 이제 p에 담아서 controller.insert() 호출

p.setInTime(inTime);

controller.insert(p);

} else {

System.out.println("빈 자리가 없습니다.");

}

}else if(choice == 2) {

//먼저 주차된 차량이 있는지 확인한다.

if(controller.isEmpty()) {

//리스트가 비어있으므로

//경고 메시지만 출력

System.out.println("주차된 차량이 없습니다.");

 

}else { 

//리스트에 주차된 ParkDTO가 존재하므로

//출차 시작

scan.nextLine();

System.out.println("차량 번호를 입력해주세요: ");

ParkDTO p =new ParkDTO();

p.setNumber(scan.nextLine());

while(!controller.checkNumberExist(p.getNumber())) {

System.out.println("입차된 기록이 없습니다.");

System.out.println("차량 번호를 입력해주세요: ");

p.setNumber(scan.nextLine());

}

//차량번호가 존재 -> 하지만 inTinme은?

//리스트의 해당 차량번호를 가진 ParkDTO 객체가 가지고 있으니깐

//걔를 불러와야된다.

p = controller.selectOne(p);

 

//출차시간을 입력을 받는다.

//출차시간은 시간의 유효성 뿐만이 아니라

//입차시간보다 늦어야 한다는 특징도 있다.

System.out.println("출차 시간을 입력해주세요 : ");

int outTime = scan.nextInt();

while(!controller.validateTime(outTime) || p.getInTime() > outTime) {

System.out.println("잘못 입력하셨습니다.");

System.out.println("출차 시간을 입력해주세요: ");

outTime = scan.nextInt();

}

System.out.println("총 요금은 "+controller.calcRate(p, outTime)+"원 입니다.");

controller.remove(p);

}

}

}

scan.close();

}

}

 

 

#ParkEx

package day05;

 

import java.util.Scanner;

public class ParkEx {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

ParkViewer viewer = new ParkViewer();

while (true) {

viewer.showMenu();

int choice = scan.nextInt();

if(choice == 3) {

System.out.println("사용해주셔서 감사합니다.");

break;

}else if(choice == 1) {

viewer.insertPark(scan);

//insertPark에 커서 올려놓고 Alt+Shift+R 누르면 이름 바꾸기 가능하다.

}else if(choice == 2) {

viewer.deletePark(scan);

}

}

scan.close();

}

}

 

#ParkViewer(Refactoring)

package day05;

 

import java.util.Scanner;

 

//refactoring

//리펙토링이란? 프로그램의 실행 결과는 그대로이지만

//내부 소스는 더 효율적이거나 업그레이드 시키는 것.

public class ParkViewer {

private ParkController controller;

 

public ParkViewer() {

controller = new ParkController();

}

public void showMenu() {

System.out.println("===============");

System.out.println("비트 주차 관리 프로그램");

System.out.println("===============");

System.out.println("1.입차 2.출차 3.종료");

}

public void insertPark(Scanner scan) {

// 입차 시작.

// 제일 먼저 빈 자리가 있는지 체크한다.

if (controller.findEmpty()) {

// 빈자리가 존재하므로 차량 번호 입력을 받는다.

scan.nextLine();

System.out.println("입차할 차량 번호를 입력하세요: ");

ParkDTO p = new ParkDTO();

p.setNumber(scan.nextLine());

while (controller.checkNumberExist(p.getNumber())) {

// while문이 반복된다. = 중복된 차량 번호이다.

System.out.println("이미 입차된 번호입니다.");

System.out.println("입차할 차량 번호를 입력하세요 : ");

p.setNumber(scan.nextLine());

}

// while문을 넘겼다 = 중복된 차량번호가 아니다 -> 시간 입력 받기

System.out.println("입차 시간을 입력해주세요 : ");

int inTime = scan.nextInt();

// while문 안에 !countroller.validateTime(intime)만 넣어도 된다.

// True 값이 나오게 하여 무한루프에 갇히게 한다.

while (controller.validateTime(inTime) == false) {

System.out.println("형식이 잘못 되었습니다.");

System.out.println("입차 시간을 입력해주세요 : ");

inTime = scan.nextInt();

}

// 이번 while문의 끝 = 시간이 올바른 형식

// 이제 p에 담아서 controller.insert() 호출

p.setInTime(inTime);

controller.insert(p);

} else {

System.out.println("빈 자리가 없습니다.");

}

}

 

public void deletePark(Scanner scan) {

// 먼저 주차된 차량이 있는지 확인한다.

if (controller.isEmpty()) {

// 리스트가 비어있으므로

// 경고 메시지만 출력

System.out.println("주차된 차량이 없습니다.");

 

} else {

// 리스트에 주차된 ParkDTO가 존재하므로

// 출차 시작

scan.nextLine();

System.out.println("차량 번호를 입력해주세요: ");

ParkDTO p = new ParkDTO();

p.setNumber(scan.nextLine());

while (!controller.checkNumberExist(p.getNumber())) {

System.out.println("입차된 기록이 없습니다.");

System.out.println("차량 번호를 입력해주세요: ");

p.setNumber(scan.nextLine());

}

// 차량번호가 존재 -> 하지만 inTinme은?

// 리스트의 해당 차량번호를 가진 ParkDTO 객체가 가지고 있으니깐

// 걔를 불러와야된다.

p = controller.selectOne(p);

 

// 출차시간을 입력을 받는다.

// 출차시간은 시간의 유효성 뿐만이 아니라

// 입차시간보다 늦어야 한다는 특징도 있다.

System.out.println("출차 시간을 입력해주세요 : ");

int outTime = scan.nextInt();

while (!controller.validateTime(outTime) || p.getInTime() > outTime) {

System.out.println("잘못 입력하셨습니다.");

System.out.println("출차 시간을 입력해주세요: ");

outTime = scan.nextInt();

}

System.out.println("총 요금은 " + controller.calcRate(p, outTime) + "원 입니다.");

controller.remove(p);

}

}

}