연산자, 제어문

<미션 설명 정리>
int tot=kor+eng+mat+compute;
float avg = tot/4; ->불가
이유->정수형 연산의 정수형은 무조건 정수이기 때문이다
결과->소숫점이 절삭된 값이 나온다
float avg =tot/4f; ->가능

[가능]
double avg=tot/4.0; 
double avg=tot/(double)4;
double avg=tot/4d;
double avg=tot/4.0d



String str="" ->가능
String str=null; ->가능
-------------------복습-------------------
<연산자>
- 자바에서 정수형끼리의 연산 결과는 무조건 정수형이다
- 산술 연산시 데이터 형이 큰 쪽으로 결과가 자동 프로모션된다



<대입 연산자>
+= : 덧셈을 한 뒤, 대입
-= : 뺄셈을 한 뒤, 대입
*= : 곱셈을 한 뒤, 대입
/= : 나눗셈을 한 뒤, 대입
%= : 나머지를 구한 뒤, 대입

ex)정수 x, y에 값을 대입한 후 몫과 나머지를 구하시오.
int x=30, y=7;
System.out.println("몫 : " + x/y); //4
System.out.println("나머지 :" + x%y); //2





<증/감 연산자>
- 변수의 앞이나 뒤에 붙여서 사용된다

[앞에 붙인 경우(전자)]
int a = 10;
int b = 0;
int c = ++a; 
System.out.println(a); ->11
System.out.println(c); ->11

[뒤에 붙인 경우(후치)]
int a = 10;
int b = 0;
int c = a++;
System.out.println(a); ->11
System.out.println(c); ->10




ex)후치인경우 ()사용 여부와 관계없이 계산된 후 무조건 나중에
  값이 바뀐다
a=10;
b=10+a++ //b=20, a=11

a=10;
b=10(a++); //b=20, a=11



ex)증감 연산자(전치, 후치)
//전치
int a = 10;
int b = 0;
int c = ++a;
System.out.println("a=" + a); //11
System.out.println("c=" + c); //11

//후치
c=a++;
System.out.println("a="+a); //12
System.out.println("c="+c); //11







<비교 연산자>
- 두 조건이 같을 경우 "="를 쓰지 않고
  "=="를 쓴다
- 두 조건이 같지 않을 경우 "!="를 쓴다
*instanceof : 두 클래스의 인스턴스가 같을 경우(즉, 객체인 경우)
                 참 값을 반환

ex)
class A{ ... }
class p extends A { ... }
...
A a = new A();
P p = new P();

System.out.println(a instanceof A); ->true
Systemout.println(p instanceof A); ->true

A(부모클래스) <- p(자식 클래스)

class p extends A { ... } 의미
A라고 하는 클래스를 상속받아서 p라는 클래스를 만들겠다


a, p = 인스턴스명(객체명)

A(), P() = 생성자

생성자
- 객체를 초기화 할 때 사용되는 메서드
- 객체를 생성할 때 사용하는 메서드
- 객체를 생성할 때는 생성자가 반드시 필요하다

System.out.println(a instanceof A) 의미
a객체가 A라는 클래스로 만들어졌니?
즉, A는 클래스명, a는 인스턴스명(객체)



ex)instanceof
int k=10;
A a1 = new A();
C c1 = new C();

System.out.println(a1 instanceof A); //true
System.out.println(c1 instanceof A); //true
System.out.println(c1 instanceof C); //true
System.out.println(a1 instanceof C); //false -1


- A라고 하는 형만 a1에 들어간다
- c1은 C형 타입
- k=3.14 X, k="abc" X
- A(부모) <- C(자식)이기 때문에 1은 false가 된다







<비트 연산자 | 비트 이동자> - java에서 쓸 일은 별로 없다





<논리 연산자>
- 조건문에 가장 많이 쓰인다
- 연산 생략 기능이 있다
&&(And 연산) : 두 조건이 모두 참이어야 참을 반환
||(Or 연산) : 두 조건 중 하나라도 참이면 참을 반환
!(논리 부정) : 참을 거짓으로, 거짓을 참으로 바꾼다


ex)논리연산자(&& || !)
System.out.println(10>5 || 10<5); //true
System.out.println(10>5 && 10<5); //false
System.out.println(!(10>5 && 10<5)); //true





<삼항 연산자>
- 조건 연산자라고도 하며 조건문을 대신하여 쓰기도 한다
변수=(조건) ? 값1 : 값2
ex) y=(x>10) ? 1 : 2;
x가 10보다 크면 y에 1이 대입되고 그렇지 않으면 2가 대입






<나열형 연산자>
- ','을 찍어 같은 형태의 변수형을 선언할 때 주로 사용

[나열형 연산자 사용 전]
int a=10;
int b=20;
int c=30;

[나열형 연산자 사용 후]
int a=10, b=20, c=30;






[접근 제한자]반환형 메서드명([매개변수형 매개변수명, ...]){  }
- 접근 제한자(생략 가능) 
- 반환형(생략 불가)
- 메서드명(생략 불가)
- 매개변수형, 매개변수명(생략 가능)
public(접근제한자) void(반환형) exam1(메서드명)
즉,
public void exam1(){
  ...
}

public void exam2(){
  ...
}
이렇게 시작한다

*만약 main함수가 없으면,
컴파일을 할 수 있겠지만 프로그래밍 되진 않는다
모든 필드(변수), 메서드(함수)는 Class안에 반드시 작성해야한다'





package core;

public class IfTest{
public void exam1(){ ... }
public void exam2(){ ... }

public static void main(String[] args){
  IfTest a =new IfTest();
  a.exam1();
  a.exam2();
  }
}
- a라고 하는 객체는 IfTest형이다





[기본예 1-exam1] 평균이 double avg=90 이 저장되어 있다.
if문을 사용하여 
평균이 60 이상이면 “합격”, 60 미만이면 
“불합격”을 출력하도록 프로그램 하시오.

[기본예 2-exam2] 두 개의 점수를 더한 평균을 계산하고 
평균이 60 이상이면 “합격”, 60 미만이면 “불합격”을 
출력하도록 프로그램 하시오.

ex)

package core;

public class IfTest {
//[접근 제한자-생략가능] 반환형-생략불가 메서드명-생략불가([매개변수형 매개변수명, ...]-생략가능){ }
public void exam1() {
double avg=90.0;
String r = "";

if(avg<60) {
r="불합격";
}
else {
r="합격";
}
System.out.println(r);

}

public void exam2() {
double x=50.5, y=90.1;
double h=x+y;
double avg=h/2;
String r="합격";
if(avg<60) {
r="불"+r;
}
System.out.println("평균:"+avg);
System.out.println("결과:"+r);
}


public static void main(String[]args){
IfTest a = new IfTest();
a.exam1();
a.exam2();
}
}







<제어문>

<if문>

[ if ]
if(조건){ 
  조건이 참인 경우
}





[ if~else문 ]
if(조건) {
  조건이 참인 경우
} else {
  조건이 거짓인 경우
}





[ 다중 if 문 ]
if(조건 1){
  조건1이 참인 경우
} else if(조건 2){
  조건2가 참인 경우
} else if(조건 3){
  조건3이 참인 경우
}
...
else{
  모든 조건이 거짓인 경우
}





<switch 문>
- break문장이 생략되면 아래에 있는 case문과 OR조건으로
  자동으로 묶어 아래에 있는 case문이 실행된다
- case문에 사용되는 값1...값n 들은 범위를 지정할 수 없다
- default문장은 case문에 해당되는 내용이 없는 경우 실행

switch(변수){
  case 상수1 : {실행문1; break;}
  case 상수2 : {실행문2; break;}
  ...
  default : {실행문1; break;}
}





[미션]
1) SwitchTest 클래스 생성
2) 정수형 매개변수가 하나 있는 exam메서드 추가
3) exam메서드 안에서 매개변수로 받은 점수를 사용하여 학점을 
  구하여 출력



ex)방법1
package core;

public static void main(String[]args) {
SwitchTest k =new SwitchTest();
k.exam(55);
}

public class SwitchTest {
public void exam(int score) {
int r =score/10;
char c;
switch(r) {
case 10 : c='A'; break;
case 9 : c='A'; break;
case 8 : c='B'; break;
case 7 : c='C'; break;
case 6 : c='D'; break;
case 5 :
case 4 :
case 3 :
case 2 :
case 1 :
case 0 : c='F'; break;
}
System.out.println("score :"+score);
System.out.println("점수 :" + c);
}
}


ex)방법2
package core;

public static void main(String[]args) {
SwitchTest k =new SwitchTest();
k.exam(55);
}

public class SwitchTest {
public void exam(int score) {
int r =score/10;
char c;
switch(r) {
case 10 : c='A'; break;
case 9 : c='A'; break;
case 8 : c='B'; break;
case 7 : c='C'; break;
case 6 : c='D'; break;
default : c='F'; break;
}
System.out.println("score :"+score);
System.out.println("grade :" + c);
}
}


☆프로그램이 실행되지 않을 경우☆
1) main함수를 정확히 작성하였는가?
- 클래스 안에서 main함수를 작성 할 수 있지만
  클래스 밖에서는 불가능하다
- 메서드안에 메서드 사용은 문법적으로 불가능하다
ex) public static void main(String[]args){ ... }

2) 실행하려는 클래스(Class)를 사용하여 객체를 생성했는가?'
SwitchTest(타입 형) k(변수 선언) = new SwitchTest(); (새로운 객체 생성)
- k : SwitchTest타입의 데이터가 존재
- k는 객체명

3) 객체를 통한 메서드를 호출했는가?
k.exam(55)

=>출력 
score : 55
grade : F



*정리1
java라고 하는 프로그램의 구조

[package] : 쓰게 된다면 한 번만 사용가능(0,1)
[import] : (생략가능)쓴다면 0,n
interface of abstract class or classd

*정리2 [class의 구조]
1) 필드(멤버변수, 프로퍼티) => 변수
2) 메서드(함수) => 기능
- 일반 메서드
- 생성자 메서드(생성자)

<while 문>
- 반복횟수가 일정하지 않거나 예측하기 힘들 때 사용되는 반복문
- while문장의 조건에 따라 해당 블럭이 한번도 실행되지 않을 수 있다
- while내부에서 실행 조건을 변경해주지 않으면 해당 블럭이
  무한 반복될 수 있다

while(조건){
  실행문;
}


<do~while 문>
- 어떤 경우든 do블럭 안에 있는 실행문이 한 번은 실행된다
- 즉, do안에 있는 문장을 실행하고 다시 실행 할 지를 
  뒤에 기술된 while문에 의해 판단된다

do{
  실행문;
} while(조건);





<for 문>
- 반복 횟수가 일정하거나 정해진 값이 있는 경우 주로 사용

for(변수=초기값; 조건; 증가값){
  실행문;
}



<for문의 실행 패턴>
for(A; B; C){
  T;
}