스터디/[whiteship]JAVA 2021. 1. 23. 22:17

목표

자바가 제공하는 다양한 연산자를 학습하세요.

학습할 것

산술 연산자
비트 연산자
관계 연산자
논리 연산자
instanceof
assignment(=) operator
화살표(->) 연산자
3항 연산자
연산자 우선 순위
(optional) Java 13. switch 연산자

연산자에 들어가기에 앞서 다음과 용어를 알아두어야 한다.

연산 : 주어진 식에서 계산하여 결과를 얻어내는 과정을 말한다.

연산자 : 주어진 식에서 사용되는 기호(+, -, /, %)등

피연산자 : 연산에 참여하는 데이터

#연산자의 종류

연산자의 종류	연산자	피연산자 수	의미
증감	++, --	단항	데이터를 1 혹은 -1씩 증감
산술	+, - , *, /, %	이항	사칙연산, 나머지
시프트	>>, <<, >>	이항	해당 데이터를 시프트 연산
비교(관계)	>, <, >=, <=, ==, !=	이항	데이터와 데이터의 크기와 같은 값인지 비교
논리	&&, \|\|, ^, ~	이항	데이터의 비트가 같은지(값이 같은지) 비교
조건	?, : -> 조건? A:B	삼항	조건이 참, 거짓에 따라 다른 값을 선택
대입	=, *=, /=, -=, &=, ^=, \|=, <<=, >>=, >>>=	이항	대입 연산자 우측의 값을 데이터와 연산후 데이터에 다시 대입

산술 연산자

public class B {
    public static void main(String[] args) {
        int a=1;
        int b=2;
        System.out.println("a + b ="+(a+b));
        System.out.println("a + b ="+(a-b));
        System.out.println("a + b ="+(a/b));
        System.out.println("a + b ="+(a%b));
    }
}

[결과 값]

a + b =3
a + b =-1
a + b =0
a + b =1

이와같이 사칙연산을 실행 할 수 있다. 여기서 a는 피연산자, +는 연산자이다.

다음은 실수형의 연산을 알아보자.

public class B {
    public static void main(String[] args) {
        double a=1;
        double b=2;
        System.out.println("a + b ="+(a+b));
        System.out.println("a + b ="+(a-b));
        System.out.println("a + b ="+(a/b));
        System.out.println("a + b ="+(a%b));
    }
}

[결과 값]

a + b =3.0
a + b =-1.0
a + b =0.5
a + b =1.0

결과 값을 보면 실수형의 연산은 소수점이다.

(+)소수점 첫 째 짜리말고 그 이상 출력을 원하면 다음과 같다.

public class B {
    public static void main(String[] args) {
        double a=1.0;
        double b=2.0;
        System.out.println(String.format("%.2f",(a+b)));
        System.out.println(String.format("%.2f",(a-b)));
        System.out.println(String.format("%.2f",(a/b)));
        System.out.println(String.format("%.2f",(a%b)));
    }
}

[결과 값]

3.00
-1.00
0.50
1.00

비트 연산자

비트 연산자는 피연산자 데이터의 비트를 연산한다

public class B {
    public static void main(String[] args) {
        int a=8;
        int b=10;
        System.out.println("a&b ="+(a&b));
        System.out.println("a|b ="+(a|b));
        System.out.println("a^b ="+(a^b));
        System.out.println("~a ="+(~a));
    }
}

[결과 값]

a&b =8
a|b =10
a^b =2
~a =-9

a의 데이터 8을 비트로 표현하면 int형 데이터 타입에 따라 4바이트의 크기를 갖는다.

|0000 0000|0000 0000|0000 0000|0000 1000|

b의 경우는 다음과 같다

|0000 0000|0000 0000|0000 0000|0000 1010|

따라서 각 비트의 연산은

AND(&) - a, b 같은 자리의 비트가 1이면 결과는 1이다.

OR(|) - a, b 둘 중 하나만 1이여도 1이다.

XOR(^) - a, b 둘 중 다른 비트만이 1이다.

NOT(~) - 각 데이터의 비트를 1->0, 0->1로 바꾼다.

관계 연산자

관계 연산자는 피 연산자들의 크기를 비교하는 연산자로 true, false와 같은 boolean값이 반환된다.

public class B {
    public static void main(String[] args) {
        int a=8;
        int b=10;
        int c=8;
        int d=9;
        System.out.println("a>b ="+(a>b));
        System.out.println("a>=b ="+(a>=c));
        System.out.println("a<=b ="+(a<=c));
        System.out.println("a!=b ="+(a!=d));
        System.out.println("a==b ="+(a==c));
    }
}

[결과 값]

a>b =false
a>=b =true
a<=b =true
a!=b =true
a==b =true

논리 연산자

논리 연산자는 식에서 true, false값을 AND, OR, XOR, NOT과 같이 논리 연산을 실행하여 boolean값을 반환한다.

-> 비트 연산자의 경우 피연산자의 데이터를 기준으로 연산을 한다. 아래 코드를 보자.

public class B {
    public static void main(String[] args) {
        int a=8; int b=10; int c=8; int d=9;
        System.out.println((a<b)&&(c>d));
        System.out.println((a<b)||(c>d));
        System.out.println((a<b)^(c>d));
        System.out.println(!(a!=b));
    }
}

false
true
true
false

(+)추가적으로 AND(&&) 연산을 설명하자면

a<b -> 8<10 -> 비교 연산자로 false가 반환된다. 이 값과 c>d의 반환 값과 논리 연산을 실행 하기 때문에 AND(&&)연산자의 경우 피 연산자의 값이 둘 다 참이여야만 참을 반환한다.

instanceof

1. instanceof의 경우 객체의 레퍼런스 타입이 어떤 클래스로 타입인지 확인하기 위해 사용하며 boolean 값을 반환한다.

2. instanceof의 경우 다음과 같이 사용하며 이항 연산자이다.

객체레퍼런스 instanceof 클래스타입

3. 단, primitive 타입을 사용 할 수 없다는 점을 주의해야한다.

아래 코드의 상속은 다음과 같다

Person은 모든 클래스의 부모, police클래스는 Person 클래스만 상속한다.

developer 클래스는 Person클래스를, senior_developer클래스는 developer를 상속받게 되면서 Person클래스까지 상속 받는다.

package ThirdWeekOfJanuary;

public class instanceTest {
    public static void test(Person p){
        if (p instanceof Person){
            System.out.println("p -> Person reference");
        }if(p instanceof  developer){
            System.out.println("p -> developer reference");
        }if(p instanceof  senior_developer){
            System.out.println("p -> senior developer reference");
        }if(p instanceof policeofficer){
            System.out.println("p -> policeofficer reference");
        }
    }
    public static void main(String[] args) {
        System.out.println("-----new person--------");
        test(new Person());
        System.out.println("-----------------------");
        System.out.println("\n");

        System.out.println("-----new developer--------");
        test(new developer());
        System.out.println("-----------------------");
        System.out.println("\n");

        System.out.println("-----new senior--------");
        test(new senior_developer());
        System.out.println("-----------------------");
        System.out.println("\n");

        System.out.println("-----new policeofficer--------");
        test(new policeofficer());
        System.out.println("-----------------------");
    }
}

[결과 값]

-----new person--------
p -> Person reference
-----------------------

-----new developer--------
p -> Person reference
p -> developer reference
-----------------------

-----new senior--------
p -> Person reference
p -> developer reference
p -> senior developer reference
-----------------------

-----new policeofficer--------
p -> Person reference
p -> policeofficer reference
-----------------------

assignment(=) operator

대입 연산자는 지금까지 보았듯이 레퍼런스에 데이터를 할당하는 연산자이다

형식은 다음과 같다.

int a = 10;

a변수에 값 10을 할당했다.

a += 10

a변수 데이터 10을 10으로 다시 더한뒤에 a에게 할당했다. -> a=20이다.

즉 대입 연산자는 왼쪽 피연산자를 오른쪽 피연산자와 연산을 시행한 후에 다시 왼쪽 피연산자한테 그 값을 할당한다.

화살표(->) 연산자

1. 화살표 연산자는 주로 람다 표현식에서 사용된다.

2. 람다 표현식은 메소드를 하나의 식으로 표현한 익명 클래스이다.

3. 함수형 인터페이스로 선언된 메서드를 호출해서 실행할때 사용한다.

-> 함수형 인터페이스란 @FunctionalInterface 어노테이션으로 지정된 인터페이스를 말하며, 인터페이스 내 구현해야 할 추상 메서드가 하나 뿐인 인터페이스이다. 예로 쓰레드의 runabble 인터페이스가 있다.

형식은 다음과 같다.

(타입 매개변수) -> {실행문;}

아래 소스코드를 보자.

package ThirdWeekOfJanuary;
@FunctionalInterface
interface summation{
    int sum(int x, int y);
}

public class instanceTest {
    public static void main(String[] args) {
        summation s = new summation() {
            @Override
            public int sum(int x, int y) {
                return x+y;
            }
        };
        int sum=s.sum(1,2);
        System.out.println(sum);
    }
}

인터페이스 타입 레퍼런스 s를 선언해주고, 추상 메서드 sum을 구현해주었다.

이렇게 함수형 인터페이스의 추상 메서드를 구현할때 람다식을 이용하면 가독성이 편해진다.

public class instanceTest {
    public static void main(String[] args) {
        summation s = (x,y) -> {return x+y;};
        int sum=s.sum(1,2);
        System.out.println(sum);
    }

람다식의 구체적인 문법은 다음과 같다.

1. 매개변수의 타입을 추론할 수 있는 경우에는 타입을 생략할 수 있습니다.

2. 매개변수가 하나인 경우에는 괄호(())를 생략할 수 있습니다.

3. 함수의 몸체가 하나의 명령문만으로 이루어진 경우에는 중괄호({})를 생략할 수 있습니다. (이때 세미콜론(;)은 붙이지 않음)

4. 함수의 몸체가 하나의 return 문으로만 이루어진 경우에는 중괄호({})를 생략할 수 없습니다.

5. return 문 대신 표현식을 사용할 수 있으며, 이때 반환값은 표현식의 결괏값이 됩니다. (이때 세미콜론(;)은 붙이지 않음)

[REFERENCE]

www.tcpschool.com/java/java_lambda_concept

코딩교육 티씨피스쿨

4차산업혁명, 코딩교육, 소프트웨어교육, 코딩기초, SW코딩, 기초코딩부터 자바 파이썬 등

tcpschool.com

3항 연산자

3항 연산자는 다음과 같이 표현한다

(조건)?참일때 반환값:거짓일 때 반환값

int a = (5>4)?5:4

반환값은 5이다. 하지만 이것을 if와 elseif 문으로 작성 한다 생각해보자. 코드 길이가 너무 길어진다... 따라서 삼항 연산자가 나온 이유가 여기에 있다.

연산자 우선 순위

다 외울 필요는 없다. 자주 사용하는 부분만 숙지하자.

(optional) Java 13. switch 연산자

기존의 switch문이 변경된 것이 아니라 switch문에 연산자가 추가 된 것이다.

기존 switch문에는 break, case등 너무많은 키워드가 존재했었다

package ThirdWeekOfJanuary;
@FunctionalInterface
interface summation{
    int sum(int x, int y);
}
public class instanceTest {
    public static void main(String[] args) {
        String days = "Wednesday";
     switch (days){
         case "Monday" :
             System.out.println("Monday");
             break;
         case "Tuesday":
             System.out.println("Tuesday");
             break;

         case "Wednesday":
             System.out.println("Wednesday");
             break;

         case "Thursday":
             System.out.println("Thursday");
             break;
             
         case "Friday":
             System.out.println("Friday");
             break;
             
         default:
         System.out.println("아저씨 평일 아니에요.");
         break;
     }
    }
}

[출력]

Wednesday

또한 break키워드를 실수로 생략 했다면 끔찍한 결과가 나온다.

   String days = "Monday";
     switch (days){
         case "Monday" :
             System.out.println("Monday");
         case "Tuesday":
             System.out.println("Tuesday");
         case "Wednesday":
             System.out.println("Wednesday");
         case "Thursday":
             System.out.println("Thursday");
             break;

         case "Friday":
             System.out.println("Friday");
             break;
         default:
             System.out.println("아저씨 평일 아니에요.");
             break;
     }
    }

[출력]

Monday
Tuesday
Wednesday
Thursday

Java12 버전부턴 switch문에 화살표 연산자를 사용 할 수 있게 되었고 화살표 연산자 사용시 default키워드를 생략해도 되는 편리함이 생겼다. 즉 default가 없어도 다음 case문으로 넘어가지 않는다.

   String days = "Monday";
     switch (days){
         case "Monday" -> System.out.println("Monday");
         case "Tuesday" ->System.out.println("Tuesday");
         case "Wednesday"-> System.out.println("Wednesday");
         case "Thursday" -> System.out.println("Thursday");
         case "Friday" -> System.out.println("Friday");
         default -> System.out.println("아저씨 평일 아니에요.");
     }

[출력]

Monday

Java13부턴 yield 키워드가 추가되었다. yield는 switch문에서 기존에 할 수 없었던 값을 반환 할 수 있게 해주었다.

public static void main(String[] args) {
        String days = "Wednesday";
        String days_switch = switch (days) {
            case "Monday", "Tuesday", "Wednesday" -> {
                System.out.println("Monday");
                yield "Monday Tusday Wednesday";
            }
            case "Thursday", "Friday" -> {
                System.out.println("Thursday");
                yield "Thursday Friday";
            }
            default -> {
                System.out.println("아저씨 평일 아니에요.");
                yield "정신차려";
            }
        };
        System.out.println("yield 반환값 "+days_switch);
    }
}

[출력]

Monday
yield 반환값 Monday Tusday Wednesday

[REFERENCE]

mkyong.com/java/java-13-switch-expressions/

'스터디 > [whiteship]JAVA' 카테고리의 다른 글

[5주차]클래스 (0)	2021.02.12
[4주차]제어문 (0)	2021.01.26
[2주차]자바 데이터 타입, 변수 그리고 배열 (0)	2021.01.12
[8주차]인터페이스 (0)	2021.01.06
[1주차]JVM (0)	2021.01.02

ABOUT ME

jjunbbang jjunbbang

목표

학습할 것

'스터디 > [whiteship]JAVA' 카테고리의 다른 글

티스토리툴바

ABOUT ME

목표

학습할 것

'스터디 > [whiteship]JAVA' 카테고리의 다른 글

관련글 관련글 더보기

티스토리툴바