2022.08.01 [MON]
- Day 4-
수업 주요 목차
- Java의 Data Type : Primitive Data Type(기본형 데이터 타입)과 Reference Data Type(참조형 데이터 타입)
- 제어문 :
- 조건문 (if ~ else if ~ else / switch case)
- 반복문 (for / while / do while)
🤖Review
Object Oriented Concept (객체 지향 개념)
: 객체를 시스템의 기본 단위로 하여 객체간의 관계를 중심으로 분석 설계 구현하는 프로그래밍 개념
Object (객체) : 시스템의 기본단위로 속성과 기능으로 구성되어 있음
Class (클래스) : '객체틀'
Object Oriented 주요 개념(Key Concept)
- 응집도(Cohesion) : 모듈 내부 기능적 역할 집중도(높을수록 좋음)
- 결합도(Coupling) : 모듈 간 상호 의존도(낮을수록 좋음)
- Encapsulation(캡슐화) : 모듈을 public interface(소통부), private implementation(구현부)로 나누어 설계, 개발
ㄴ setter / getter를 통해 접근가능
- Inheritance(상속)
- Polymorphism(다형성) // 배우기 전
소프트웨어 개발 방법론
- waterfall model (폭포수 모델)
분석 / 설계 / 구현 / 테스트 / 운영 ->차례차례 순서대로 시작, 마무리, 시작, 마무리
- agile : 클라이언트의 요구에 기민하게 반응; 신속, 반복, 점증
kanban : to do / doing / done
페어링 프로그래밍 : 짝
Unified Model Language(UML) : 객체지향 소프트웨어 분석 / 설계를 위한 초기언어
- Class diagram : 설계
- UseCase diagram : 분석
Java의 Data Type : Primitive Data Type(기본형 데이터 타입)과 Reference Data Type(참조형 데이터 타입)
1) Primitive Data Type(기본형 데이터 타입)
| 1byte | 2byte | 3byte | 4byte | |
| 정수형 | byte | short | int | long |
| 실수형 | float | double | ||
| 문자형 | char | |||
| 논리형 | boolean |
👾 특징 :
- 정수형의 기본형은 int 이다. (만약 프로그램 상에서 정수 데이터를 7이라고 명시하면 정수형의 기본인 int 형으로 인식한다.)
- 실수형의 기본형은 double 이다. (3.14로 명시하면 double로 인식된다.)
- 문자형은 한문자만 가능하고 ' ' 로 데이터를 감싼다. 문자열은 참조형은 String으로 처리한다.
- 논리형은 true or false로만 할당 가능하다.
2) Reference Data Type(참조형 데이터 타입) => 객체를 참조하는 변수의 데이터 타입을 말한다.
- 기본형 데이터 타입(Primitive Data Type)이 아닌 데이터 타입이 참조형 데이터 타입이다.
- 참조형 데이터 타입은 클래스명으로 구성된다. (이후 인터페이스 타입 또한 참조형 타입이다. -> 나중에 공부예정)
ex) Person p=new Person();
Person : 참조형 데이터 타입이자 클래스명 (Reference Data Type)
p : 객체를 참조하는 변수 (reference variable)
= : assign 할당 또는 대입
new : 자바 객체 생성시 사용하는 키워드
Person() : constructor 생성자
연산자(Operator) -> eclipse 예제참고
- 조건문
1) if ~ else if ~ else 구문
if(조건식){
} else if(조건식){
} else{
}
2) switch case 조건문
switch(변수){
case 데이터1:
break;
case 데이터2:
break;
default:
}
- 반복문(loop)
1) for
2) while
3) do ~ while
🔎 Eclipse 실습 내용
1. Data Type
package step1;
// java 기본형 데이터 타입을 테스트하는 예제
public class TestPrimitiveDataType {
public static void main(String[] args) {
//정수형
byte b1=1; //byte 형은 1byte(8bit)
System.out.println("byte b1=1; -> "+b1);
//javase api를 이용해 byte 형의 최소값과 최대값을 확인해본다.
System.out.println("Byte.MIN_VALUE; -> "+Byte.MIN_VALUE);
System.out.println("Byte.MAX_VALUE; -> "+Byte.MAX_VALUE);
byte b2=127;
System.out.println("byte b2=127; -> "+b2);
//b2=128; -> byte 형의 최대값을 넘어서므로 compile error가 난다.(short, int, long으로 처리해야 한다.)
System.out.println("************");
short s1=128; //2byte이므로 가능
System.out.println("short s1=128; -> "+s1);
System.out.println("************");
int i=1; //4byte, 정수형의 기본형
System.out.println("int i=1; -> "+i);
System.out.println("Integers.MIN_VALUE=1; -> "+Integer.MIN_VALUE); //int형의 최소값
System.out.println("Integers.MAX_VALUE=1; -> "+Integer.MAX_VALUE); //int형의 최대값
//int i2=2147483648;
//System.out.println(i2); -> int 형의 최대값을 넘어서므로 long으로 처리해야 한다.
System.out.println("************");
long lo=2147483648L; // long형 데이터 마지막에는 소문자 l 또는 대문자 L로 표기해주어야 한다.
System.out.println("long lo=2147483648L; -> "+lo);
System.out.println("Long.MIN_VALUE=1; -> "+Long.MIN_VALUE); //int형의 최소값
System.out.println("Long.MAX_VALUE=1; -> "+Long.MAX_VALUE); //int형의 최대값
System.out.println("************");
//실수형
float f=3.14F; //float 실수형의 데이터 마지막에는 소문자 f 또는 대문자 F로 표기해주어야 한다.
System.out.println("float f=3.14F; -> "+f);
System.out.println("************");
double d=3.14; // 실수형의 기본형 double
System.out.println("double d=3.14; -> "+d);
//문자형
System.out.println("************");
char c='a';
System.out.println("char c='a'; -> "+c);
//논리형
System.out.println("************");
boolean bol=true;
bol=false;
System.out.println("boolean bol=true; bol=false; -> "+bol);
// type casting : 형변환의 예
System.out.println("************");
byte num1=5;
byte num2=10;
//byte num3=num1+num2; -> 연산 결과는 정수형의 기본형인 int로 인식되므로 error -> byte형으로 할당하기 위해서는 type casting 형변환을 하면 됨
byte num3=(byte)(num1+num2);
System.out.println("byte num3=(byte)(num1+num2) -> "+num3);
}
}↓
byte b1=1; -> 1
Byte.MIN_VALUE; -> -128
Byte.MAX_VALUE; -> 127
byte b2=127; -> 127
************
short s1=128; -> 128
************
int i=1; -> 1
Integers.MIN_VALUE=1; -> -2147483648
Integers.MAX_VALUE=1; -> 2147483647
************
long lo=2147483648L; -> 2147483648
Long.MIN_VALUE=1; -> -9223372036854775808
Long.MAX_VALUE=1; -> 9223372036854775807
************
float f=3.14F; -> 3.14
************
double d=3.14; -> 3.14
************
char c='a'; -> a
************
boolean bol=true; bol=false; -> false
************
byte num3=(byte)(num1+num2) -> 15
2. Reference Data Type
package step2;
public class TestReferenceDataType {
public static void main(String[] args) {
int i=22; // int는 Primitive Data Type
Person p=new Person("아이유",i);
/*
* Person은 Reference Data Type(참조형)
* p : 지역변수이자 객체를 참조하는 참조변수
* p는 new Person()으로 생성한 객체의 주소값을 참조한다.
*/
System.out.println(p.getName()+" "+p.getAge());
}
}
package step2;
public class Person {
private String name; //name 인스턴스 변수의 데이터 형은 참조형이다.
//문자열 저장시 참조형인 String을 명시한다.
private int age; //name 인스턴스 변수의 데이터 형은 기본형이다.
//정수형 데이터를 저장시 int명시한다.
public Person(String name, int age) {
this.name = name; // -> 띄어쓰기 상관 없음
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}↓
아이유 22
3. Operator 1
package step3;
public class TestOperator {
public static void main(String[] args) {
int i=3;
int j=7;
System.out.println(i+j);
System.out.println(i-j);
System.out.println(i*j);
System.out.println(j/i);
System.out.println(j%i); //나머지 1
System.out.println(i==j); //== 같은지 비교
System.out.println(i=j); //= 할당
int k=7;
System.out.println(i==k); // 할당 후 비교하면 true가 나옴
System.out.println(i!=k); // i와 k가 같지 않으면 true
boolean flag=false;
System.out.println(flag);
System.out.println(!flag);
System.out.println("***********************");
//증감연산자
int a=1;
System.out.println(a++); //실행 후 증가
System.out.println(a);
System.out.println(++a); // 증가 후 실행
System.out.println(a--); //실행 후 증감
System.out.println(a);
System.out.println(--a); //증감 후 실행
System.out.println("***********************");
//대입연산자
int money=10000; // money에 5000원을 누적하고 싶음
money=money+5000; //방법 1
System.out.println(money);
// 2000을 또 누적
money+=2000; //방법 2
System.out.println(money);
System.out.println("***********************");
// 삼항연산자
//조건식 ? 식1 : 식2 -> 조건식이 참이면 식1이 수행되고 거짓이면 식2가 수행된다.
int point=10000;
int result=(point>=10000) ? point+200 : point+100;
System.out.println(result);
int point2=1000;
int result2=(point2>=10000) ? point2+200 : point2+100;
System.out.println(result2);
}
}↓
10
-4
21
2
1
false
7
true
false
false
true
***********************
1
2
3
3
2
1
***********************
15000
17000
***********************
10200
1100
4. Operator 2
package step3;
/*
&&연산과 ||연산 (&& 연산은 모두가 참일 때 참, || 연산은 모두가 거짓일 때 거짓)
1. and(&&) 연산 : 모든 조건식이 참일 때만 true
true && true => true
true && false => false
false && true -> false
false && false => false
2. or(||) 연산 : 조건식 중에 참이 하나 이상 나오면 true
true || true => true
true || false => true
false || true => true
false || false => false
*/
public class TestOperator2 {
public static void main(String[] args) {
OperatorExam exam=new OperatorExam();
// & 와 &&의 연산자의 차이점 확인
System.out.println("main:"+(exam.test1()&exam.test2())); //test1() method 실행결과 false, test2() method 실행결과 true / false & true -> false
System.out.println("main:"+(exam.test1()&&exam.test2())); // test1() method 실행결과 false, && 모두가 참일 때만 참이기 때문에 test2() method 실행결과에 상관없이 false
//마찬가지로 || 연산일 경우 true가 나오면 이후 조건식 실행없이 바로 true 결과를 도출한다.
//&&, || 연산자 두개씩 쓰는 이유 : 필요없는 연산은 안해서 실행속도가 빨라짐
}
}package step3;
public class OperatorExam {
public boolean test1() {
System.out.println("test 1() 실행");
return false;
}
public boolean test2() {
System.out.println("test 2() 실행");
return true;
}
}↓
test 1() 실행
test 2() 실행
main:false
test 1() 실행
main:false
5. If 1
package step4;
public class TestIf1 {
public static void main(String[] args) {
int age=17;
if(age<19) { //실행문이 한라인일 경우 중괄호 생략 가
System.out.println(age+"세 어린이");
} else {
System.out.println(age+"세 성인");
}
}
}↓
17세 어린이
6. If 2
package step4;
import java.util.Scanner;
public class TestIf2 {
public static void main(String[] args) {
/*
* 1~13세 까지 어린이
* 14~19세 까지 청소년
* 20세 ~ 성인
*/
Scanner sc=new Scanner(System.in);
System.out.print("나이를 입력하세요: ");
int age=sc.nextInt(); //사용자가 콘솔에 입력한 나이 정보를 받아온다.
if(age>19){ //19세 초과하면
System.out.println(age+"세 성인");
} else if(age>13) { //13세 초과 19세까지 까
System.out.println(age+"세 청소년");
} else { // 13세 이하 나머
System.out.println(age+"세 어린이");
}
sc.close();
}
}↓
나이를 입력하세요: 13 //입력
13세 어린이
7. If 3
package step4;
import java.util.Scanner;
public class TestIf3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("태어난 월을 입력하세요: ");
int month=sc.nextInt(); //사용자가 콘솔에 입력한 데이터를 받아온다.
MyDate date = new MyDate(month);
// date.getMonth() return 값이 0이 아니면 !=
if(date.getMonth()!=0) {
System.out.println(date.getMonth()+"월에 태어남");
}
sc.close();
}
}package step4;
public class MyDate {
//인스턴스 변수 정수형을 선언만 하면 기본 초기화는 0이 됨
private int month;
public MyDate(int month) {
//월 정보는 1이상 12이하일 때만 할당하게 한다.
if(month>=1 && month<=12){
this.month=month;
} else {
System.out.println(month+"는 올바른 값이 아닙니다.(1이상 12이하의 값만 가능)");
}
}
public int getMonth() {
return month;
}
}↓
태어난 월을 입력하세요: 12 //입력
12월에 태어남
// ----------
태어난 월을 입력하세요: 13 //입력
13는 올바른 값이 아닙니다.(1이상 12이하의 값만 가능)
8. If 4
package step4;
public class TestIf4 {
public static void main(String[] args) {
Account a=new Account();
System.out.println(a.getBalance()); //0
a.deposit(100);
a.deposit(200);
System.out.println(a.getBalance()); //300
//아래와 같이 입금액이 잘못되었을 경우(즉, 0원을 초과하지 않을 경우)
//"잘못된 입금액입니다"가 출력됨
a.deposit(-1);
System.out.println(a.getBalance());
a.withdraw(200);
System.out.println(a.getBalance());
a.withdraw(-30);
System.out.println(a.getBalance());
}
}
package step4;
public class Account {
private long balance;
/*
* 입금하는 기능의 method : balance 잔액을 누적
*/
public void deposit(long money) {
if(money>0) {
balance+=money; //balance=balance+money; (똑같음)
} else {
System.out.println("잘못된 입금액입니다.");
}
}
public void withdraw(long money) {
if(money>0) {
balance-=money;
} else {
System.out.println("잘못된 출금액입니다.");
}
}
public long getBalance() {
return balance;
}
public void setBalance(long balance) {
this.balance = balance;
}
}
🫥 withdraw 부분 혼자 만들어봄(이슈 없이 만들 수 있었음, 휴-)
↓
0
300
잘못된 입금액입니다.
300
100
잘못된 출금액입니다.
100
9. Scanner
package step4;
import java.util.Scanner;
public class TestScanner {
public static void main(String[] args) {
//콘솔로부터 정보를 입력받기 위해 java.util.Scanner class를 이용한다.
Scanner sc = new Scanner(System.in);
System.out.print("정수를 입력하세요:");
int num = sc.nextInt(); //사용자가 콘솔에 입혁한 정수 정보를 반환받는다.
System.out.print("입력한 정수: ");
if(num>19) {
System.out.println(num+"세는 성인입니다.");
} else { //13세 이하 나머지
System.out.println(num+"세는 모르겠습니다.");
}
sc.close();
}
}↓
정수를 입력하세요:24
입력한 정수: 24세는 성인입니다.
정수를 입력하세요: 2
입력한 정수: 2세는 모르겠습니다.
10. Switch 1
package step5;
import java.util.Scanner;
public class TestSwitch1 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print("등급을 입력하세요: ");
int grade=sc.nextInt();
//switch case 조건문은 상위 case가 실행되면 아래의 case가 모두 실행된다.
//해당 case만 실행되게 하려면 break가 필요하다. : TestSwitch2에서 확인
switch(grade) {
case 1:
System.out.println("하버드");
case 2:
System.out.println("콜롬비아");
case 3:
System.out.println("미시건");
default:
System.out.println("하와이");
}
sc.close();
}
}↓
등급을 입력하세요: 1 //입력
하버드
콜롬비아
미시건
하와이
등급을 입력하세요: 2 //입력
콜롬비아
미시건
하와이
11. Switch 2
package step5;
import java.util.Scanner;
public class TestSwitch2 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print("등급을 입력하세요: ");
int grade=sc.nextInt();
// break를 명시하여 해당 케이스만 실행되게 한다.
switch(grade) {
case 1:
System.out.println("하버드");
break; //switch 구문을 벗어난다.
case 2:
System.out.println("콜롬비아");
break;
case 3:
System.out.println("미시건");
break;
default:
System.out.println("하와이");
}
sc.close();
}
}↓
등급을 입력하세요: 1 //입력
하버드
등급을 입력하세요: 2 //입력
콜롬비아
12. Switch 3
package step5;
import java.util.Scanner; // 단축키 cmd + shift + o
public class TestSwitch3 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print("월을 입력하세요:");
DateService2 service= new DateService2();
service.printLastDay(sc.nextInt()); // 사용자가 입력한 값을 printLastDay method로 전2
sc. close();
}
}package step5;
public class DateService2 {
/*
* 2월 : 28
* 4,6,9,11 : 30
* 1,3,5,7,8,10,12 : 31
* 나머지 : 잘못된 입력값입니다.
*/
public void printLastDay(int month) {
switch(month) {
case 4 : case 6 : case 9: case 11:
printDetail(month,30);
break;
case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 :
printDetail(month,31);
break;
case 2 :
printDetail(month,28);
break;
default:
System.out.println("잘못된 입력값입니다.");
} // switch
} //method
//위 method에서 재사용할 상세 출력method
public void printDetail(int month,int lastDay) {
System.out.println(month+"월의 마지막 일은 "+lastDay+"일입니다.");
}
} //class↓
월을 입력하세요:2 //입력
2월의 마지막 일은 28일입니다.
월을 입력하세요:3 //입력
3월의 마지막 일은 31일입니다.
13. For
package step6;
public class TestForLoop {
public static void main(String[] args) {
//for loop(반복문) : 일정한 수를 반복할 때 주로 사용
for(int i=0;i<=10;i++) {
System.out.println(i); //초기화 된 값 실행 후 쭉 진행
}
System.out.println("****************************");
for(int i=10;i>=0;i--)
System.out.println(i); // 반복문 한줄일 때 중괄호 생략가능
}
}↓
0
1
2
3
4
5
6
7
8
9
10
****************************
10
9
8
7
6
5
4
3
2
1
0
14. While
package step7;
public class TestWhile {
public static void main(String[] args) {
int i=1;
while(i<10) {
System.out.println("소주 "+i+"잔");
i++;
}
//int j=10;
while(i>0) {
System.out.println("소주"+i+"잔");
i--;
}
}
}↓
소주 1잔
소주 2잔
소주 3잔
소주 4잔
소주 5잔
소주 6잔
소주 7잔
소주 8잔
소주 9잔
소주10잔
소주9잔
소주8잔
소주7잔
소주6잔
소주5잔
소주4잔
소주3잔
소주2잔
소주1잔
15. Do While
package step8;
public class TestDoWhile {
public static void main(String[] args) {
int i=-11;
i=1;
do { //do while 구문은 반드시 do 구문은 한번 실행되는 구조
System.out.println("do i:"+i);
i++;
} while(i<0);
}
}↓
do i:1
15. For2
package step9;
public class TestFor1 {
public static void main(String[] args) {
ForLoopService service = new ForLoopService();
service.printInfo("테라",7);
/*
* 테라 1 잔
* 테라 2 잔
* ...
* 테라 7 잔
*/
}
}package step9;
public class ForLoopService {
public void printInfo(String item, int count) {
for(count=1;count<=7;count++) {
System.out.println(item+" "+count+" 잔");
}
/* for(int i=1;1<=7;i++) {
System.out.println(item+" "+count+" 잔"); // 이거 질문하는 거 까먹음
}*/
}
}↓
테라 1 잔
테라 2 잔
테라 3 잔
테라 4 잔
테라 5 잔
테라 6 잔
테라 7 잔16. For 3
package step9;
public class TestFor2 {
public static void main(String[] args) {
ForLoopService2 service = new ForLoopService2();
service.printInfo("테라",10,5); // 테라가 10잔이 있는데 내 주량은 5잔 까지임
/*
* 테라 1 잔
* 테라 2 잔
* ...
* 테라 5 잔
*/
}
}package step9;
/*
* for 구문 안에서 if문을 이용 limit이 되면 해당 for loop를 종료한다.(break를 이용)
*/
public class ForLoopService2 {
public void printInfo(String item, int count, int limit) {
for(int i=1;i<=count;i++) { // (Error)i<=10 으로 썼었음
System.out.println(item+" "+i+" 잔");
if(i==limit) { // (Error)if(i<5)라고 썼었음;
break;
}
}
}
}↓
테라 1 잔
테라 2 잔
테라 3 잔
테라 4 잔
테라 5 잔
17. For 4
package step9;
public class TestFor3 {
public static void main(String[] args) {
System.out.print(1);
System.out.print("\t"+2);
System.out.print("\t"+3);
System.out.println();
System.out.print(1);
System.out.print("\t"+2);
System.out.print("\t"+3);
System.out.println();
System.out.println("****");
for(int i=1;i<=3;i++) {
//System.out.print("i "+i+ " : ");
for(int j=1;j<=5;j++) {
System.out.print("\t"+j);
}
System.out.println();
}
/*
* 1 2 3 4 5
* 1 2 3 4 5
* 1 2 3 4 5
* 3행 5열 표현
* nested for loop : for문안의 for문을 이용해 표현
* for(){ ->3번 반복
* for(){ ->5번 반복
* }
* sysout();
* }
*/
}
}↓
1 2 3
1 2 3
****
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
//오늘의 단축키
cmd + shift + o => Scanner import 단축키
"\t"+2 =-> tab만큼 띄어쓰기
// 오늘의 질문
- If 문에서 조건을 여러가지 선언하고 싶을 때는 어떻게 하나요? || 쓰면 된다고 답해주심(자세한 내용은 오늘의 이슈에서...)
- 아래 for문 조건에 int i 변수 선언 없이 count 바로 썼는데도 답이 똑같이 나오던데 뭐가 다른건지 내일 질문해야함!
package step9;
public class ForLoopService {
public void printInfo(String item, int count) {
for(count=1;count<=7;count++) {
System.out.println(item+" "+count+" 잔");
}
/* for(int i=1;1<=7;i++) {
System.out.println(item+" "+count+" 잔"); // 이거 질문하는 거 까먹음
}*/
}
}
//오늘의 이슈
package step5;
public class DateService {
/*
* 2월 : 28
* 4,6,9,11 : 30
* 1,3,5,7,8,10,12 : 31
* 나머지 : 잘못된 입력값입니다.
*/
public void printLastDay(int month) {
if(month==2) {
printDetail(month,28);
} else if(month==1||month==3||month==5||month==7||month==8||month==10||month==12) {
System.out.println(month+"월의 마지막 일은 31일 입니다.");
} else if(month==4||month==6||month==9||month==11) {
System.out.println(month+"월의 마지막 일은 30일 입니다.");
} else {
System.out.println(month+"올바른 입력값이 아닙니다.");
} //if
} //method
public void printDetail(int month,int lastDay) {
System.out.println(month+"월의 마지막 일은 "+lastDay+"일입니다.");
}
} //class
// 혼자 해보던 중 2월은 조건이 한개라서 쉽게 해결, 나머지는 몰라서 강사님께 여쭤봄. ||를 사용하면 된다는 것을 배움
//"System.out.println(month+"월의 마지막 일은 31일 입니다.");" 를 계속 반복해서 쓰다가 switch때 배운대로 새로운 method 만들어서 샘플 문장을 만들어주면 가능!* 그 외의 이슈들은 Eclipse 예제에 적어놓음
//오늘의 숙제
블로그에 정리하며 복습, 예습...이라기 보다 내일 할 내용들 한번씩 읽어보고 자기
