OOP-4(Inheritance)

in Java, OOP

상속 (Inheritence)

상속이란

  • 클래스의 모든 멤버 변수 및 메소드를 계승하여 새로운 클래스를 생성하는 것
  • 상속 대상 - 조상 클래스, 부모 클래스, 상위 클래스, 슈퍼 클래스
  • 상속 결과 - 자손 클래스, 자식 클래스, 하위 클래스, 서브 클래스
  • 상속 대상일 필요 조건을 달성하므로 IS-A 관계라고도 부른다.

클래스의 관계

클래스의 상속

  • 부모 클래스

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Person {
    String name;

    public void work() {
    System.out.println("일하기");
    }

    public void sleep() {
    System.out.println("잠자기");
    }
    }
  • 자식 클래스

    1
    2
    3
    4
    5
    6
    7
    public class Developer extends Person {
    String mainLang;

    public void writeCode() {
    System.out.println("코딩하기");
    }
    }
    1
    2
    3
    4
    5
    6
    7
    public class Student extends Person {
    String major;

    public void writeCode() {
    System.out.println("밤새 코딩하기");
    }
    }

클래스의 포함

  • 상속과 유사하나, 한 클래스가 다른 클래스의 인스턴스를 포함하는 관계로 되어 있다.

  • 내부에 포함하고 있어, HAS-A 관계라고 부른다.

  • 클래스 컴포지션 (Composition)이라 부른다.

    1
    2
    3
    4
    5
    6
    7
    public class MainMachine {
    String model;

    public MainMachine(String model) {
    this.model = model;
    }
    }
    1
    2
    3
    4
    5
    6
    7
    public class Developer extends Person {
    MainMachine machine = new MainMachine("Macbook Air");

    public void writeCode() {
    System.out.println(machine.model + "(으)로 코딩하기");
    }
    }

메소드 재정의

  • 메소드의 기능을 재정의하는 것을 메소드 재정의 (Method overriding)이라 부른다.

    1
    2
    3
    4
    5
    public class Person {
    public void writeCode() {
    System.out.println("아무 코드나 일단 적어보았다.");
    }
    }
    1
    2
    3
    4
    5
    6
    public class Developer extends Person {
    @Override
    public void writeCode() {
    System.out.println("깔끔하고 예쁜 코드를 적어보았다.");
    }
    }

super 키워드

  • this가 현재 객체를 참조하듯, super는 부모 객체를 참조한다.

  • super로 부모의 부모 객체에는 접근할 수 없다.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class Foo {
    String x = "foo";
    }

    public class Bar extends Foo{
    String x = "bar";

    void method() {
    String x = "method";
    System.out.println(x);
    System.out.println(this.x);
    System.out.println(super.x);
    }
    }
  • 부모의 생성자를 호출하는 super

  • 반드시 생성자의 첫줄에만 올 수 있음

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public class Foo {
    String x;

    public Foo(String x) {
    this.x = x;
    }
    }

    public class Bar extends Foo {
    String y;

    public Bar(String x, String y) {
    super(x);
    this.y = y;
    }
    }

Comment and share

OOP-3(JavaDoc)

in Java, OOP

JavaDoc 주석

JavaDoc 주석이란

  • Java 클래스 및 패키지를 문서화 하기 위한 주석
  • 클래스의 용도와 사용법 등을 설명하는 규칙
  • 자동으로 JavaDoc 문서를 생성할 수 있음

JavaDoc 작성 방법

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
* Class description
* @author Author Name
*/
public class ClassA {
/**
* Comments for a member variable
*/
public int memberVar;

/**
* Comments for another member variable
*/
public int secondMemberVar;

/**
* Constructor description
* @param x description for parameter x
* @param y description for parameter y
*/
public ClassA(int x, int y) {
this.memberVar = x;
this.secondMemberVar = y;
}

/**
* A member method description
* @param string description for parameter string
* @return description for the return value
*/
public int ClassA(String string) {
return 0;
}
}

Comment and share

OOP-2(Class)

in Java, OOP

클래스 (Classes)

클래스와 객체

  • 클래스: 객체를 생성하기 위해 사용하는 추상화된 설계도
  • 객체: 클래스가 구체화하여 값으로 생성된 것
    • Instantiation: 클래스에서 객체를 생성하는 과정
    • Object, Instance: Instantiation으로 인해 생성된 객체

클래스의 구성

1
2
3
4
5
6
7
public class Car {
int speed = 0; // 멤버 변수 (속성)

void move() { // 멤버 함수 (메소드)
this.speed = 10;
}
}
  • 속성(Attribute, field) - 클래스에 속하는 멤버 변수, 상태, 필드
  • 메소드(Method) - 클래스에 속하는 멤버 함수, 행동

객체의 생성

1
2
Car car = new Car();
클래스명 변수명 = new 클래스명();
  • 클래스를 구체화하여 값을 생성한 것을 객체라 한다.
  • 하나의 클래스로 여러개의 객체를 만들 경우, 같은 타입의 독립적인 객체가 된다.

클래스와 객체의 메모리 구조

  • 클래스 영역 (Class Area, Method Area, Code Area, Static Area)

    • Field 정보
    • Method 정보
    • Type 정보
    • Constant Pool
  • 스택 영역 (Stack Area)

    • Method 호출 시 선언된 로컬 변수
  • 힙 영역 (Heap Area)

    • new 키워드로 생성된 객체

변수 (Variables)

  • 로컬 변수와 멤버 변수

    구분 선언 위치 변수 종류 특징
    멤버 변수 클래스 영역 클래스 멤버 변수 static 키워드 o
    멤버 변수 클래스 영역 인스턴스 멤버 변수 static 키워드 x
    로컬 변수 메소드 및 블록 내부 로컬 변수
    로컬 변수 메소드 내부 파라미터 변수 메소드의 입력 인자
    1
    2
    3
    4
    5
    6
    7
    8
    public class Variables {
    int instanceVar; // 인스턴스 멤버 변수
    static int classVar; // 클래스 멤버 변수

    public void method(int parameterVar) { // 파라미터 변수
    int localVar = 0; // 로컬 변수
    }
    }

인스턴스 멤버 변수 (Instance Variables)

  • 인스턴스 변수는 객체를 생성할 때 힙 영역에 생성됨

  • 인스턴스 변수는 힙 영역에 생성되므로 초기화가 이루어짐

    자료형 기본값
    boolean false
    char ‘\u0000’
    byte, short, int 0
    long 0L
    float 0.0f
    double 0.0
    Ref. type null

클래스 멤버 변수 (Class Variables)

  • 클래스 멤버 변수는 프로그램 시작 시 클래스 영역에 생성됨

  • 객체가 아닌 클래스로 접근하는 것이 권장됨 (객체로 접근도 가능하나 비권장)

    1
    2
    3
    4
    5
    6
    7
    8
    public class Foo {
    static int classVar = 10;
    }

    Foo.classVar = 0; // Recommended

    Foo foo = new Foo();
    foo.classVar = 0; // Not recommended

로컬 변수 (Local Variable)

  • 메소드 또는 중괄호 블록 내부에서 생성되는 변수

  • 스택 영역에 생성되며, 초기화가 이루어지지 않음

  • 생명 주기(Life cycle)은 생성된 중괄호 블록이 종료될 때 까지

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    void method(int paramVar) {
    int localVar;
    // System.out.println(localVar); // 초기화가 이루어지지 않음
    localVar = 10;
    System.out.println(localVar);
    {
    int localVar2 = 10;
    System.out.println(localVar2);
    }
    // System.out.println(localVar2); // 생명주기가 끝남
    }

메소드 (Methods)

메소드란

  • 객체가 하는 동작을 정의하는 어떠한 작업을 수행하는 코드의 집합
  • 코드의 중복을 방지하고 유지보수성을 향상시키기 위해 사용
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Car {
String name;

void printModel() { // 메소드의 정의 (Method definition)
System.out.println(name);
}
}

Car hyundai = new Car();
Car kia = new Car();

hyundai.name = "Hyundai";
kia.name = "Kia";

hyundai.printModel(); // 메소드의 호출 (Method call)
kia.printModel();

메소드의 구현

  • 메소드는 함수의 형태로 구성된다.

    • 파라미터 (Parameters, 입력)
    • 실행문 (Executional Statements)
    • 리턴 값 (Return Value, 출력)
  • 함수의 작성

    1
    2
    3
    4
    5
    6
    7
    public int add(int x, int y) {
    return x + y;
    }

    제한자 리턴타입 메소드명(파라미터타입1 파라미터이름1, 파라미터타입2 파라미터이름2, ...) {
    // 실행문
    }
  • 가변 인자 (Variable Arguments)

    • 입력 인자의 개수가 정해지지 않은 경우
    1
    2
    3
    4
    5
    6
    7
    public int sumAll(int... params) {
    int sum = 0;
    for (int i: params) {
    sum += i;
    }
    return sum;
    }
  • 기본형 vs. 참조형 변수

    • 기본형: 메소드 인자로 값이 전달됨 (Call by value)
    • 참조형: 메소드 인자로 참조가 전달됨 (Call by reference)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    public class Foo {
    int value;
    }

    public class Bar {
    public void swapPrimitive(int x, int y) {
    int temp = x;
    x = y;
    y = temp;
    }

    public void swapReference(Foo x, Foo y) {
    int temp = x.value;
    x.value = y.value;
    y.value = temp;
    }
    }

    Bar bar = new Bar();

    int x = 1, y = 10;
    bar.swapPrimitive(x, y);
    System.out.println(x); // 1
    System.out.println(y); // 10

    Foo foo1 = new Foo(1);
    Foo foo2 = new Foo(10);
    bar.swapReference(foo1, foo2);
    System.out.println(foo1.value); // 10
    System.out.println(foo2.value); // 1
  • 클래스 메소드 (Class method)

    • static 키워드를 이용하여 선언된 메소드
    • 인스턴스가 아닌 클래스에 속하는 메소드
    • 대표적으로 main 메소드가 클래스 메소드이다.
    1
    2
    3
    4
    5
      public class Foo {
    static public void main(String args[]) {
    // class method
    }
    }
  • 메소드 호출 스택 (Method Call Stack)

    • 메소드가 호출될 때 마다 메소드 동작과 로컬 변수가 쌓이는 메모리 영역
    • 메소드가 종료될 때 메모리가 함께 반환됨

메소드 오버로딩

  • 동일 기능의 함수를 추가로 구현하는 방법

  • 입력 파라미터를 달리하는 동일 함수명으로 구현한다.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class Foo {
    public int sumAll(int ... params) {
    int sum = 0;
    for (int i: params) {
    sum += i;
    }
    return sum;
    }

    public float sumAll(float ... params) {
    float sum = 0.0f;
    for (float x: params) {
    sum += x;
    }
    return sum;
    }
    }

    Foo foo = Foo();
    int sum1 = foo.sumAll(1, 2, 3, 4, 5);
    float sum2 = foo.sumAll(1.0f, 2.0f, 3.0f, 4.0f, 5.0f);

생성자 (Constructor)

  • 클래스에서 인스턴스를 생성할 때 사용되는 메소드

    • new 키워드를 이용해 호출
  • 기본 생성자 (Default Constructor)

    • 구현하지 않아도 자동으로 생성되는 생성자
    • 아무런 동작도 하지 않고, 객체만을 생성
  • 파라미터 생성자 (Parameter Constructors)

    • 입력 파라미터를 받는 생성자
    • 여러개의 파라미터 생성자를 오버로딩할 수 있음
    • 보통 멤버 변수를 초기화하는 동작 수행
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Foo {
int x;
int y;
String z;

// public Foo() {} // Default Constructor

public Foo(int a, int b, String c) { // Parameter Constructor
x = a;
y = b
z = c;
}
}

this 키워드

  • 객체가 스스로를 가르키는 참조

  • 멤버 변수와 로컬 변수의 이름이 같을 때, 멤버 변수임을 명시

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class Foo {
    int x;
    int y;

    public Foo(int x, int y) {
    this.x = x;
    this.y = y;
    }
    }
  • 생성자를 호출하는 데에도 사용할 수 있다.

  • 반드시 생성자의 첫 줄에서만 사용해야 한다.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public class Foo {
    int x;
    int y;
    String z;

    public Foo(int x, int y, String z) {
    this.x = x;
    this.y = y;
    this.z = z;
    }

    public Foo(String z) {
    this(0, 0, z);
    }

    public Foo(int x, int y) {
    this(x, y, "Nothing");
    }
    }

Getter와 Setter

  • 클래스의 멤버 변수를 간접적으로 다룰 수 있게 하는 메소드

  • 멤버 변수의 캡슐화(Encapsulation)를 구현하기 위해 사용

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Foo {
    private int x;

    public int setX(int x) {
    this.x = x;
    }

    public void getX() {
    return x;
    }
    }

초기화 블록 (Initializer)

  • 클래스 또는 인스턴스를 생성할 때 단 한번 실행되는 코드 블록

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public class Foo {
    static int classVar;
    int instanceVar;

    static { // Class Initializater
    classVar = 100;
    }

    { // Instance Initializer
    instanceVar = 10;
    }

    static {
    // May be more than one block
    }
    }

Comment and share

OOP-1(Basic)

in Java, OOP

객체지향 프로그래밍 (Object Oriented Programming; OOP)

객체지향 프로그래밍이란

  • 컴퓨터 프로그래밍 패러다임 중 하나
  • 프로그램을 명령어의 목록으로 보는 시각에서 벗어나, 독립된 단위인 객체의 모임으로 파악
  • 각각의 객체는 메세지를 주고받고, 데이터를 처리

객체지향의 기본 구성 요소

  • 클래스 (Class)
    • 같은 종류의 집단에 속하는 속성과 행위를 정의한 것
    • 클래스는 다른 클래스 또는 외부 요소와 독립적으로 디자인해야 함
  • 객체 (Object)
    • 클래스의 인스턴스로, 실제로 메모리상에 할당된 것
    • 자신 공유의 속성을 가지며, 클래스에 정의된 행위를 수행
  • 메소드 (Method)
    • 클래스로부터 생성된 객체를 사용하는 방법
    • 메소드는 한 객체의 속성을 조작하는 데에 사용

객체 지향의 특징

  • OOP is A.P.I.E
    • Abstraction (추상화): 자료 표현을 추상적으로 나타내는 추상 자료형을 사용한다.
    • Polymorphism (다형성): 오버로딩과 오버라이딩을 하여 하나의 메소드명으로 다양한 동작을 구현할 수 있다.
    • Inheritence (상속): 부모 클래스로부터 속성과 메소드를 상속받아 사용할 수 있다.
    • Encapsulation (캡슐화): 사용자에게 불필요한 정보를 은닉/보호해야 한다.

Comment and share

배열 (Arrays)

배열의 특성

  • 하나의 변수로 여러개의 값을 다룰 수 있다.
  • 동일한 자료형의 값만 다룰 수 있다.
  • 한번 생성된 배열의 크기는 변하지 않는다.
  • 배열에 속한 값은 메모리에 연속적으로 위치한다.

배열의 생성

  • 배열의 선언

    1
    2
    int[] intArray;// 자료형[] 변수명; recommended
    int integerArray[];// 자료형 변수명[]; old c-style
  • 배열의 생성/초기화

    • 생성 후 값 할당

      1
      2
      3
      int[] intArray = new int[10];
      intArray[0] = 4;
      intArray[1] = 10;
      1
      2
      int[] intArray;
      intArray = new int[]{4, 5, 1, 2, 5};
    • 생성과 동시에 값 할당

      1
      2
      int[] intArray = {3, 5, 1, 20, 65};
      int[] intArray2 = new int[]{4, 6, 2, 3, 4};

배열과 반복문

  • 인덱스를 이용한 배열 접근

    1
    2
    3
    4
    float[] floatArray = new float[10];
    for (int i = 0; i < floatArray.length; i++) {
    floatArray[i] = i * 0.5;
    }
  • 향상된 for 문을 이용한 배열 접근

    1
    2
    3
    4
    int[] intArray = {4, 5, 1, 2, 7, 5};
    for (int value: intArray) {
    System.out.println(value);
    }

배열의 크기 변경

  • 배열의 크기는 변경할 수 없으므로 새로운 배열을 만들고 데이터를 옮겨야 한다.
1
2
3
4
5
int[] src = {1, 2, 3, 4, 5};
int[] dst = new int[10];
for(int i = 0; i < source.length; i++) {
dst[i] = src[i];
}
1
2
3
int[] src = {1, 2, 3, 4, 5};
int[] dst = new int[10];
System.arraycopy(src, 0, dst, 0, src.length);

Comment and share

문자열 (Strings)

문자열의 특징

  • 클래스로 구현되어 있다.
  • 내부에 문자의 배열로 데이터가 구현되어 있다.
  • 한번 만든 문자열은 변하지 않는다. (Immutable)

문자열의 생성

  • new 키워드를 이용하여 생성

    1
    String string = new String("문자열 생성");
  • new 키워드 없이 생성 (권장)

    1
    String string = "문자열 생성";

문자열 메소드

메소드 메소드 선언 설명
length() public int length() 문자열의 길이를 출력
charAt() public char charAt(int index) index번째에 위치한 문자 출력
indexOf() public int indexOf(char ch) ch가 위치한 index 출력. 없을 시 -1
equals() public boolean equals(Object anObject anObject와 비교한 결과 출력
equalsIgnoreCase() public boolean equalsIgnoreCase(String anotherString) 대소문자 구분없이 anotherString과 비교 결과 출력
replace() public String replace(char odlChar, char newChar) oldChar를 찾아 newChar로 변경된 문자열 출력
substring() public String substring(int beginIndex, int endIndex) 문자열을 beginIndex부터 endIndex-1까지 잘라서 출력
trim() public String trim() 문자열 좌우 공백을 없앤 결과를 출력
matches() public boolean matches(String regex) 문자열을 정규표현식 regex 확인 결과 출력
split() public String[] split(String regex) 문자열을 정규표현식 형태로 나눈 후 배열로 출력

Comment and share

다차원 배열 (N-D Arrays)

다차원 배열의 정의

  • 배열을 담고 있는 배열을 다차원 배열이라고 한다.
  • 수학의 선 -> 면 -> 공간 등과 동일한 개념

다차원 배열의 생성

  • 다차원 배열의 선언

    1
    2
    3
    int[] array2D[];
    int[][] array2D;
    int array2D[][];
  • 다차원 배열의 생성

    • 여러 차원의 배열을 동시에 생성

      1
      int[][] array2D = new int[5][10];
    • 상위 차원의 배열부터 생성

      1
      2
      3
      4
      int[][] array2D = new int[5][];
      for (int i = 0; i < array2D.length; i++) {
      array2D[i] = new int[10];
      }
  • 다차원 배열의 초기화

    1
    2
    3
    int[][] array2D = {{3, 5, 1, 20, 65},
    {5, 2, 6}, // length may vary
    {10, 3, 5, 67, 3}};

배열과 반복문

  • 인덱스를 이용한 배열 접근

    1
    2
    3
    4
    5
    6
    int[][] array2D = new int[10][10];
    for (int i = 0; i < array2D.length; i++) {
    for (int j = 0; j < array2D[i].length; j++) {
    array2D[i][j] = i * j;
    }
    }

Comment and share

반복문 (Loops)

반복문의 일반적인 구성

  • 초기화 (Initialization)
  • 조건식 (Conditional Expression)
  • 실행문 (Execution Statement)
  • 증감식 (Increment and Decrement Statement)

다양한 반복문

for 문

1
2
3
for(초기화; 조건식; 증감식) {
// 실행문
}

while 문

  • while 문의 경우 실행문이 한번도 실행되지 않을 수도 있다.
1
2
3
4
5
// 초기화
while(조건식) {
// 실행문
// 증감식
}

do ~ while 문

  • do ~ while 문의 경우 실행문은 무조건 한번 이상 실행된다.
1
2
3
4
5
//초기화
do {
//실행문
//증감식
} while(조건식)

반복문 제어

break 문

  • 반복문을 곧바로 종료한다.
1
2
3
4
5
6
7
while (조건식) {
if (종료조건) {
break;
}
//실행문
//증감식
}

continue 문

  • 반복문을 곧바로 다음 반복으로 건너 뛴다.
  • while 문의 경우 증감식이 실행되지 않을 수 있다.
1
2
3
4
5
6
7
8
while (조건식) {
if (제어조건) {
//증감식
continue;
}
//실행문
//증감식
}

label

  • 중첩 반복문에서 어떤 반복문을 제어할지 결정
1
2
3
4
5
6
7
8
9
10
11
12
loop1: for (int i = 0; i < 10; i++) {
loop2: for (int j = 0; j < 10; j++) {
if (j == 3) {
break;
// break loop1;
// break loop2;
// continue;
// continue loop1;
// continue loop2;
}
}
}

Comment and share

조건문 (Conditional Statements)

조건문의 구성

  • 조건식 (Conditional Expression), 실행문 (Execution Statement)

다양한 조건문

if 계열 조건문

if 문

1
2
3
4
5
6
if(조건식)
// 실행문

if(조건식) {
// 실행문
}

if ~ else 문

1
2
3
4
5
if(조건식) {
// 조건식이 true일때 실행할 실행문
} else {
// 조건식이 false일때 실행할 실행문
}

if ~ else if ~ else 문

1
2
3
4
5
6
7
if(조건식1) {
// 조건식1이 true일때 실행할 실행문
} else if(조건식2) {
// 조건식1이 false이고, 조건식2가 true일때 실행할 실행문
} else {
// 모든 조건식이 false일 때 실행할 실행문
}

Nested if 문

1
2
3
4
5
6
7
8
9
if(조건식1) {
if(조건식2) {
// 조건식1과 조건식2가 true일때 실행할 실행문
} else {
if(조건식3) {
// 조건식1과 조건식3이 true이고 조건식2가 false일때 실행할 실행문
}
}
}

switch ~ case

  • 조건식과 비교할 대상이 여럿일 때 사용
    • 조건식의 출력은 정수값, 문자열, 열거형 등 정확한 값을 리턴
1
2
3
4
5
6
7
8
9
10
switch(조건식) {
case 비교값1:
// 실행문1
break;
case 비교값2:
// 실행문2
break;
default:
// 실행문3
}
  • Fall-through
    • break 문을 사용하지 않고 다음 case문을 실행시키는 방법
1
2
3
4
5
6
7
8
9
10
11
switch(조건식) {
case 비교값1:
// 실행문1
case 비교값2:
// 실행문2
default:
// 실행문3
}
// 비교값1에 해당할 경우: 실행문1, 실행문2, 실행문3 실행
// 비교값2에 해당할 경우: 실행문2, 실행문3 실행
// 해당하는 값이 없을 경우: 실행문3 실행

Comment and share

연산자 (Operators)

연산의 구성

  • 연산자 (Operator), 피연산자 (Operand), 연산식 (Expression)

우선순위 표

  • 우선순위가 같은 경우, 결합 방향 순으로 이루어진다.

    연산자 결합 방향 우선순위
    () 1
    ++ – + - ~ ! (int) 2
    * / % 3
    + - 4
    << >> >>> 5
    > < >= <= instanceof 6
    == != 7
    & 8
    ^ 9
    | 10
    && 11
    || 12
    ?: 13
    = += -= *= /= %= ^= |= <<= >>= >>>= 14

다양한 연산자

산술 연산자 (Arithmatic Operators)

연산자 기능
+ 두 피연산자의 합
- 두 피연산자의 차
* 두 피연산자의 곱
/ 두 피연산자의 나눈 몫
% 두 피연산자의 나눈 나머지(Modulus)
  • 산술 연산자 사용 시 주의점
    • 정수형: 오버플로우
    • 실수형: 정확도
    • /, % : Infinity, NaN

대입 연산자 (Assignment Operators)

연산자 기능
= 우측 피연산자의 값을 좌측 피연산자 변수에 할당
+= 두 피연산자의 합을 좌측 피연산자에 할당
-= 두 피연산자의 차를 좌측 피연산자에 할당
*= 두 피연산자의 곱을 좌측 피연산자에 할당
/= 좌측 피연산자를 우측 피연산자로 나눈 몫을 좌측 피연산자에 할당
%= 좌측 피연산자를 우측 피연산자로 나눈 나머지를 좌측 피연산자에 할당

비교 연산자 (Comparison Operators)

연산자 기능
< 좌측 피연산자가 우측 피연산자보다 작은가?
> 좌측 피연산자가 우측 피연산자보다 큰가?
<= 좌측 피연산자가 우측 피연산자보다 작거나 같은가?
>= 좌측 피연산자가 우측 피연산자보다 크거나 같은가?
== 좌측 피연산자와 우측 피연산자가 같은가?
!= 좌측 피연산자와 우측 피연산자가 다른가?
  • 비교 연산자의 출력은 true 또는 false이다.

논리 연산자 (Logical Operators)

연산자 기능
& AND
| OR
! NOT
^ XOR
Short Circuit 연산자 기능
&& AND
|| OR

증감 연산자 (Increment and Decrement Operators)

연산자 기능
++ (Prefix) 피연산자의 값을 1 증가한 후 연산식 평가
++ (Postfix) 연산식을 평가한 후에 피연산자의 값을 1 증가
– (Prefix) 피연산자의 값을 1 감소시킨 후 연산식 평가
– (Postfix) 연산식을 평가한 후에 피연산자의 값을 1 감소

삼항 연산자 (Ternary Operator)

연산자 기능
? : 첫 피연산자의 값의 true이면 두번째 연산자를, false이면 세번째 연산자를 출력

비트 연산자 (Bitwise Operator)

  • 비트 연산자는 정수형을 피연산자를 대상으로 한다.

  • 논리 비트 연산자

    연산자 기능
    & Bitwise AND
    | Bitwise OR
    ~ Bitwise INV
    ^ Bitwise XOR
  • 이동 비트 연산자 (Shift Operator)

    연산자 기능
    << 좌측 피연산자의 각 비트를 왼쪽으로 우측 피연산자만큼 이동시킨다. 빈자리는 0으로 채운다.
    >> 좌측 피연산자의 각 비트를 우측으로 우측 피연산자만큼 이동시킨다. 빈자리는 Sign Bit로 채운다.
    >>> 좌측 피연산자의 각 비트를 우측으로 우측 피연산자만큼 이동시킨다. 빈자리는 0으로 채운다.

Comment and share

Yechan Kim

author.bio


author.job