JavaRush /Java Blog /Random-KO /์ปคํ”ผ ๋ธŒ๋ ˆ์ดํฌ #139. Java์˜ ์˜ค๋ฒ„๋กœ๋”ฉ ๋ฐ ์žฌ์ •์˜. ๋‹น์‹ ์ด ๋ชฐ๋ž๋˜ 5๊ฐ€์ง€ ์ž๋ฐ” ๋ฉ”์†Œ๋“œ

์ปคํ”ผ ๋ธŒ๋ ˆ์ดํฌ #139. Java์˜ ์˜ค๋ฒ„๋กœ๋”ฉ ๋ฐ ์žฌ์ •์˜. ๋‹น์‹ ์ด ๋ชฐ๋ž๋˜ 5๊ฐ€์ง€ ์ž๋ฐ” ๋ฉ”์†Œ๋“œ

Random-KO ๊ทธ๋ฃน์— ๊ฒŒ์‹œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค

Java์˜ ์˜ค๋ฒ„๋กœ๋”ฉ ๋ฐ ์žฌ์ •์˜

์ถœ์ฒ˜: Medium ์ด ๊ธฐ์‚ฌ์—์„œ๋Š” Java ์–ธ์–ด์˜ Overriding ๋ฐ Overloading ๋ฉ”์„œ๋“œ์— ๋Œ€ํ•ด ์•Œ์•„๋ด…๋‹ˆ๋‹ค. ์ด ๋‘ ์šฉ์–ด๋Š” ์ข…์ข… ์„œ๋กœ ํ˜ผ๋™๋˜๊ธฐ ๋•Œ๋ฌธ์— ๊ฐ ๋ฐฉ๋ฒ•์˜ ๋ชฉ์ ๊ณผ ์ ์šฉ ์˜ต์…˜์„ ๋ช…ํ™•ํ•˜๊ฒŒ ์ดํ•ดํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค. ์ปคํ”ผ ๋ธŒ๋ ˆ์ดํฌ #139.  Java์˜ ์˜ค๋ฒ„๋กœ๋”ฉ ๋ฐ ์žฌ์ •์˜.  ๋‹น์‹ ์ด ๋ชฐ๋ž๋˜ 5๊ฐ€์ง€ ์ž๋ฐ” ๋ฉ”์†Œ๋“œ - 1

๊ณผ๋ถ€ํ•˜

๋™์ผํ•œ ํด๋ž˜์Šค์—์„œ ์ด๋ฆ„์€ ๊ฐ™์ง€๋งŒ ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ๋‹ค๋ฅธ ๋‘ ๊ฐœ ์ด์ƒ์˜ ๋ฉ”์†Œ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜๊ฑฐ๋‚˜ Java์˜ ์Šˆํผํด๋ž˜์Šค์™€ ์„œ๋ธŒํด๋ž˜์Šค ๊ฐ„์— ๋ฉ”์†Œ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์„ ์˜ค๋ฒ„๋กœ๋”ฉ์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ์ด๋ฅผ ๋ฐฉ์ง€ํ•˜๊ธฐ ์œ„ํ•ด ์œ ์‚ฌํ•œ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๋Š” ์—ฌ๋Ÿฌ ๋ฉ”์„œ๋“œ ๋Œ€์‹  ๋‹จ์ผ ๋ฉ”์„œ๋“œ๊ฐ€ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด ์„ค๋ช…ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.
public class MethodOverloading {

    public static void main(String[] args){
        MethodOverloading operation = new MethodOverloading();
        operation.mod(12,4);
        operation.mod(12.4,4.2);
    }

    void mod(double a, double b){
        System.out.println(a % b);
    }

    void mod(int a, int b){
        System.out.println(a % b);
    }
}
์ด ์ฝ”๋“œ์—์„œ๋Š” ์ž‘์—… ๋ฉ”์„œ๋“œ๊ฐ€ ์˜ค๋ฒ„๋กœ๋“œ๋ฉ๋‹ˆ๋‹ค. ๋™์ผํ•œ ์ด๋ฆ„์„ ๊ฐ€์ง„ ๋ฉ”์†Œ๋“œ๋Š” ๋‹ค๋ฅธ ์œ ํ˜•์˜ ๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ํ—ˆ์šฉํ•ฉ๋‹ˆ๋‹ค. ๋ชจ๋“œ ์„ ํƒ์€ int ๋ฐ double ๋งค๊ฐœ๋ณ€์ˆ˜์— ๋Œ€ํ•ด ๋ณ„๋„๋กœ ๊ฒฐ์ •๋ฉ๋‹ˆ๋‹ค . ํ”„๋กœ๊ทธ๋žจ์„ ์‹คํ–‰ํ•˜๋ฉด Operation.mod(12,4)๋Š” void.mod(int a, int b) ๋ฅผ ์‹คํ–‰ ํ•˜๊ณ  Operation.mod(12.4,4.2) ๋Š” void.mod(double a, double b)๋ฅผ ์‹คํ–‰ํ•ฉ๋‹ˆ๋‹ค .

์žฌ์ •์˜

Java์—์„œ๋Š” ์Šˆํผํด๋ž˜์Šค์™€ ํ•ด๋‹น ํด๋ž˜์Šค๋ฅผ ์ƒ์†ํ•˜๋Š” ์„œ๋ธŒํด๋ž˜์Šค๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ํ•˜์œ„ ํด๋ž˜์Šค๋Š” ์ƒ์†๋ฐ›์€ ์ƒ์œ„ ํด๋ž˜์Šค์˜ ๋ฉ”์„œ๋“œ๋ฅผ ์žฌ์ •์˜ํ•˜๊ณ  ๋Œ€์ฒดํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋Š” Overriding ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ˆ˜ํ–‰๋ฉ๋‹ˆ๋‹ค. ์ด๋Š” ๋‹ค์Œ ์˜ˆ๋ฅผ ํ†ตํ•ด ๋” ์ž˜ ์ดํ•ดํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
public class MethodOverriding {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.sound();

        Bee bee = new Bee();
        bee.sound();
    }
}

class Animal {
    void sound(){
        System.out.println("Animal sounds");
    }
}

class Cat extends Animal{
    @Override
    void sound() {
        System.out.println("Cat : meow meow");
    }
}

class Bee extends Animal{
    @Override
    void sound() {
        System.out.println("Bee : buzz buzz");
    }
}
์ด ์ฝ”๋“œ ์˜ˆ์ œ์—์„œ๋Š” Animal ์ด๋ผ๋Š” ์Šˆํผํด๋ž˜์Šค ์™€ ํ•ด๋‹น ์Šˆํผํด๋ž˜์Šค์—์„œ ์ƒ์†๋˜๋Š” Cat ๋ฐ Bee ๋ผ๋Š” ํ•˜์œ„ ํด๋ž˜์Šค๋ฅผ ๋งŒ๋“ญ๋‹ˆ๋‹ค. ์Šˆํผํด๋ž˜์Šค์˜ ์‚ฌ์šด๋“œ ๋ฉ”์„œ๋“œ๊ฐ€ ์žฌ์ •์˜๋ฉ๋‹ˆ๋‹ค. ์ฐธ๊ณ : ์˜ค๋ฒ„๋กœ๋“œ๋œ ๋ฉ”์„œ๋“œ์˜ ๋ถ„๋ฆฌ๋Š” ์ปดํŒŒ์ผ ๋‹จ๊ณ„์—์„œ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค. ์žฌ์ •์˜๋œ ๋ฉ”์„œ๋“œ์˜ ๋ถ„๋ฆฌ๋Š” ๋Ÿฐํƒ€์ž„์— ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

๋‹น์‹ ์ด ๋ชฐ๋ž๋˜ 5๊ฐ€์ง€ ์ž๋ฐ” ๋ฉ”์†Œ๋“œ

์ถœ์ฒ˜: Javarevisited Java ๊ฐœ๋ฐœ ์ƒํƒœ๊ณ„์—๋Š” ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ํ”„๋กœ๊ทธ๋žจ์—์„œ ๊ฐ€์ ธ์™€ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๋งŽ์€ ๋„๊ตฌ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์—๋Š” ๋‚ด์žฅ ํด๋ž˜์Šค์™€ ๋ฉ”์„œ๋“œ๊ฐ€ ํฌํ•จ๋ฉ๋‹ˆ๋‹ค. ์ด๋ฅผ ํ†ตํ•ด ํ”„๋กœ๊ทธ๋ž˜๋จธ์˜ ์ž‘์—…์ด ํฌ๊ฒŒ ๋‹จ์ˆœํ™”๋˜๊ณ  ์ฝ”๋“œ๋ฅผ ๋” ์ž˜ ์ดํ•ดํ•˜๊ณ  ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ชจ๋“  ๊ฐœ๋ฐœ์ž๋Š” ์ด์— ๋Œ€ํ•ด ์•Œ์•„์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋‹ค์Œ์€ ๋งค์šฐ ๋“œ๋ฌผ์ง€๋งŒ ์ž‘์—…์— ๋งค์šฐ ์œ ์šฉํ•  ์ˆ˜ ์žˆ๋Š” 5๊ฐ€์ง€ Java ๋ฉ”์„œ๋“œ์ž…๋‹ˆ๋‹ค.

1. ๊ฐ์†Œ์ •ํ™•ํ•œ

decrementExact()๋Š” ์ฃผ์–ด์ง„ ์ธ์ˆ˜(์ˆซ์ž)๋ฅผ 1๋งŒํผ ๊ฐ์†Œ/๋นผ๊ณ  ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” Math ํด๋ž˜์Šค ์˜ ๊ธฐ๋ณธ Java ํ•จ์ˆ˜์ž…๋‹ˆ๋‹ค . ์ด ํ•จ์ˆ˜๋Š” incrementExact() ํ•จ์ˆ˜ ์™€ ๋ฐ˜๋Œ€์ž…๋‹ˆ๋‹ค . ์˜ˆ๋ฅผ ๋“ค์–ด, ์ฃผ์–ด์ง„ ์ธ์ˆ˜๊ฐ€ 11์ด๋ฉด ๊ฒฐ๊ณผ๋Š” 10์ž…๋‹ˆ๋‹ค. ์ธ์ˆ˜๋ฅผ ๊ฐ์†Œ์‹œ์ผœ ํ•ด๋‹น ๋ฐ์ดํ„ฐ ์œ ํ˜•์ด ์˜ค๋ฒ„ํ”Œ๋กœ๋˜๋Š” ๊ฒฝ์šฐ ์˜ˆ์™ธ๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์ด ๊ธฐ๋Šฅ์„ ์‚ฌ์šฉํ•  ๋•Œ ํŠนํžˆ ํฐ ์ˆซ์ž์˜ ๊ฒฝ์šฐ ์ฃผ์˜ํ•˜๋Š” ๊ฒƒ์ด ์ค‘์š”ํ•ฉ๋‹ˆ๋‹ค. ์ผ๋ฐ˜์ ์œผ๋กœ ์ด ํ•จ์ˆ˜์—๋Š” ์ •์ˆ˜๊ฐ€ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ํ†ต์‚ฌ๋ก :
Math.decrementExact(number);
์˜ˆ:
System.out.println(Math.decrementExact(11));
// Output: 10

2.getAsDouble

getAsDouble()์€ OptionalDouble ํด๋ž˜์Šค ์— ์†ํ•˜๋Š” ๋ฉ”์†Œ๋“œ์ž…๋‹ˆ๋‹ค . OptionalDouble ๊ฐœ์ฒด๋Š” ์ž ์žฌ์ ์œผ๋กœ double ์ˆซ์ž๋ฅผ ๋ณด์œ ํ•  ์ˆ˜ ์žˆ๋Š” ๊ฐœ์ฒด์ž…๋‹ˆ๋‹ค. ํด๋ž˜์Šค์˜ ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๊ฐœ์ฒด์— ์žˆ๋Š” double ๊ฐ’์— ๋Œ€ํ•ด ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๊ฑฐ๋‚˜ double ๊ฐ’์ด ์ „ํ˜€ ํฌํ•จ๋˜์ง€ ์•Š์Œ์„ ๋‚˜ํƒ€๋‚ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. getAsDouble() ์€ ๊ทธ๋Ÿฌํ•œ ๋ฉ”์†Œ๋“œ ์ค‘ ํ•˜๋‚˜์ด๋ฉฐ ์กด์žฌํ•˜๋Š” ๊ฒฝ์šฐ double ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด NoSuchElementException ์ด ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค . ํ†ต์‚ฌ๋ก :
OptionalDoubleObject.getAsDouble();
์˜ˆ:
OptionalDouble num = OptionalDouble.of(15.0);
System.out.println(num.getAsDouble());
// Output: 15.0

3. ์ ˆ๋Œ€ ์ •ํ™•

absExact() ๋ฉ”์„œ๋“œ๋Š” Math ํด๋ž˜์Šค ์˜ abs() ํ•จ์ˆ˜ ์™€ ์œ ์‚ฌํ•ฉ๋‹ˆ๋‹ค . ์ˆซ์ž์˜ ์ ˆ๋Œ€๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์ด๋Š” ๋ถ€ํ˜ธ์— ๊ด€๊ณ„์—†์ด ์ˆซ์ž์˜ ์–‘์ˆ˜ ๊ฐ’์ž…๋‹ˆ๋‹ค. ์œ ์ผํ•œ ์ฐจ์ด์ ์€ ๋ฐ์ดํ„ฐ ์œ ํ˜•( int ๋˜๋Š” long ) ์œผ๋กœ ์ •ํ™•ํ•˜๊ฒŒ ํ‘œํ˜„๋˜๋Š” ๊ฒฝ์šฐ์—๋งŒ ์ด ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•œ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค . ๋ฐ˜ํ™˜ ๊ฐ’์˜ ๊ฒฐ๊ณผ๊ฐ€ ์›๋ž˜ ๋ฐ์ดํ„ฐ ์œ ํ˜•์„ ์ดˆ๊ณผํ•˜๋Š” ๊ฒฝ์šฐ ArithmeticException์ด ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค . ํ†ต์‚ฌ๋ก :
Math.absExact(number);
์˜ˆ:
System.out.println(Math.absExact(-11));
// Output: 11

4.๋๋‚˜๋‹ค

endWith() ๋Š” ์ฃผ์–ด์ง„ ๋ฌธ์ž์—ด์ด ๋งค๊ฐœ๋ณ€์ˆ˜์˜ ํŠน์ • ์ ‘๋ฏธ์‚ฌ(๋ ๋‹จ์–ด/๋ฌธ์ž์—ด)๋กœ ๋๋‚˜๋Š”์ง€ ์—ฌ๋ถ€์— ๋”ฐ๋ผ ๋ถ€์šธ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•˜๋Š” ๋‚ด์žฅ ๋ฌธ์ž์—ด ๋ฉ”์„œ๋“œ์ž…๋‹ˆ๋‹ค. ์ด ๋ฉ”์„œ๋“œ๋Š” ๋งŽ์€ ๊ฐœ๋ฐœ์ž์—๊ฒŒ ์ต์ˆ™ํ•  startWith() ๋ฉ”์„œ๋“œ ์™€ ๋ฐ˜๋Œ€์ž…๋‹ˆ๋‹ค . ํ†ต์‚ฌ๋ก :
String.endsWith(String suffix);
์˜ˆ:
String phrase = "I like bananas";
System.out.println(phrase.endsWith("bananas")); // true
System.out.println(phrase.endsWith("Tandrew")); // false
/* Output:
true
false
*/

5. ๋ถ„ํ• ์œ ๋‹ˆ๊ทธ๋“œ

DivideUnsigned() ๋ฉ”์„œ๋“œ๋Š” ๋‘ ์ˆซ์ž๋ฅผ ๋‚˜๋ˆ„๊ณ  ๋‚˜๋ˆ—์…ˆ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•  ์ˆ˜ ์žˆ๋Š” Integer ํด๋ž˜์Šค ์˜ ๋ฉ”์„œ๋“œ์ž…๋‹ˆ๋‹ค . ๋ถ€ํ˜ธ ์—†๋Š” ์ •์ˆ˜๋Š” ์ผ๋ฐ˜ ๋ถ€ํ˜ธ ์žˆ๋Š” ์ •์ˆ˜์™€ ๋น„๊ตํ•˜์—ฌ ์–‘์ˆ˜๋งŒ ๋‚˜ํƒ€๋‚ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ถ€ํ˜ธ ์—†๋Š” ์ •์ˆ˜์™€ ๋ถ€ํ˜ธ ์žˆ๋Š” ์ •์ˆ˜ ๋ชจ๋‘ ๋ฒ”์œ„ ๋‚ด์—์„œ ๋™์ผํ•œ ์ˆ˜์˜ ์ˆซ์ž๋ฅผ ๊ฐ–์Šต๋‹ˆ๋‹ค(๋ฒ”์œ„์˜ ํฌ๊ธฐ๋Š” 65,536๊ฐœ์˜ ์ˆซ์ž์ž…๋‹ˆ๋‹ค). ๊ทธ๋Ÿฌ๋‚˜ ๋ถ€ํ˜ธ ์—†๋Š” ์ •์ˆ˜๋Š” ์Œ์ˆ˜๊ฐ€ ๋  ์ˆ˜ ์—†์œผ๋ฏ€๋กœ ์–‘์ˆ˜ ๋ฒ”์œ„์˜ ์ตœ๋Œ€๊ฐ’์€ ์ผ๋ฐ˜ ๋ถ€ํ˜ธ ์žˆ๋Š” ์ •์ˆ˜์˜ ์ตœ๋Œ€๊ฐ’๋ณด๋‹ค ํ›จ์”ฌ ๋†’์Šต๋‹ˆ๋‹ค. ์ด๋ฅผ ๋‹จ์ˆœํ™”ํ•˜๊ธฐ ์œ„ํ•ด ๋Œ€์‹  ๋ถ€ํ˜ธ ์žˆ๋Š” ๋ฐ”์ดํŠธ์™€ ๋ถ€ํ˜ธ ์—†๋Š” ๋ฐ”์ดํŠธ์˜ ์˜ˆ๋ฅผ ์‚ดํŽด๋ณผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฐ”์ดํŠธ์˜ ๋ฒ”์œ„๋Š” 256๊ฐœ ์ˆซ์ž์ž…๋‹ˆ๋‹ค. ์ผ๋ฐ˜ ๋ฐ”์ดํŠธ๋Š” -128๋ถ€ํ„ฐ 127๊นŒ์ง€์˜ ๊ฐ’์„ ๊ฐ€์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๋ถ€ํ˜ธ ์—†๋Š” ๋ฐ”์ดํŠธ๋Š” 0๋ถ€ํ„ฐ 255๊นŒ์ง€์˜ ๊ฐ’์„ ๊ฐ€์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด ํ•จ์ˆ˜๋Š” ์ •๊ทœ ๋‚˜๋ˆ„๊ธฐ์™€ ์ •ํ™•ํžˆ ๋™์ผํ•˜๊ฒŒ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค. ํ†ต์‚ฌ๋ก :
Integer.divideUnsigned(int dividend, int divisor);
์˜ˆ:
int dividend = 10;
int divisor = 5;
int quotient = Integer.divideUnsigned(dividend, divisor);
System.out.println(quotient);
// Output: 2

๊ฒฐ๋ก 

๋‹ค์Œ์€ ์ด ๋ฌธ์„œ์—์„œ ์„ค๋ช…ํ•œ ํ•จ์ˆ˜์™€ ๋ฉ”์„œ๋“œ๋ฅผ ์š”์•ฝํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค.
  • decrementExact - ์ฃผ์–ด์ง„ ์ˆซ์ž๋ฅผ 1์”ฉ ์ค„์ด๊ฑฐ๋‚˜ ๋บ๋‹ˆ๋‹ค.

  • getAsDouble - OptionalDouble ํ•จ์ˆ˜ ์˜ ์ผ๋ถ€๋กœ , double ๊ฐ’์ด ์žˆ๋Š” ์ˆซ์ž๋ฅผ ๋ฐ˜ํ™˜ํ•˜๊ฑฐ๋‚˜ ํ•ด๋‹น ๊ฐ’์ด ์—†์Œ์„ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค.

  • absExact - ์›๋ž˜ ๋ฐ์ดํ„ฐ ์œ ํ˜•์œผ๋กœ ํ‘œํ˜„๋  ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ ์ˆซ์ž์˜ ์ ˆ๋Œ€๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

  • endWith() - ์ง€์ •๋œ ๋ฌธ์ž์—ด์— ์ง€์ •๋œ ์ ‘๋ฏธ์‚ฌ๊ฐ€ ์กด์žฌํ•˜๋Š”์ง€ ์—ฌ๋ถ€์— ๋”ฐ๋ผ ๋ถ€์šธ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

  • DivideUnsigned() - ์ผ๋ฐ˜ ๋‚˜๋ˆ„๊ธฐ๋ฅผ ์ˆ˜ํ–‰ํ•˜๊ณ  ์ˆซ์ž๋ฅผ ๋‚˜๋ˆˆ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

์ฝ”๋ฉ˜ํŠธ
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION