Scala 언어 소스:

/*
 * Filename: testHexView_03.scala
 *
 *    Purpose: Show the hexadecimal values of the given file.
 *
 * Compile: scalac -deprecation -d . testHexView_03.scala
 * Execute: scala testHexView_03 [filename]
 *
 * Date: 2013. 8. 18.
 */

import java.io._

object testHexView_03 {

    def printUsage() {
        println("Usage: scala testHexView_03 [filename]")
    }

    def toHex(n: Int) : String = {
        var s = ""
        var x1 = (n & 0xF0) >> 4
        var x2 = n & 0xF
        if (x1 < 10) {
            s = s + "%c".format(('0' + x1) toChar)
        }
        else {
            s = s + "%c".format('A' + (x1 - 10))
        }
        if (x2 < 10) {
            s = "%s%c".format(s, ('0' + x2) toChar)
        }
        else {
            s = s + "%c".format('A' + (x2 - 10))
        }
        return s
    }

    def toHex8(n: Int) : String = {
        var s = ""
        var x1 = (n & 0xF0000000) >> 28
        var x2 = (n & 0xF000000) >> 24
        var x3 = (n & 0xF00000) >> 20
        var x4 = (n & 0xF0000) >> 16
        var x5 = (n & 0xF000) >> 12
        var x6 = (n & 0xF00) >> 8
        var x7 = (n & 0xF0) >> 4
        var x8 = n & 0xF
        if (x1 < 10) {
            s = s + "%c".format(('0' + x1) toChar)
        }
        else {
            s = s + "%c".format('A' + (x1 - 10))
        }
        if (x2 < 10) {
            s = "%s%c".format(s, ('0' + x2) toChar)
        }
        else {
            s = s + "%c".format('A' + (x2 - 10))
        }
        if (x3 < 10) {
            s = "%s%c".format(s, ('0' + x3) toChar)
        }
        else {
            s = s + "%c".format('A' + (x3 - 10))
        }
        if (x4 < 10) {
            s = "%s%c".format(s, ('0' + x4) toChar)
        }
        else {
            s = s + "%c".format('A' + (x4 - 10))
        }
        s = s + " "
        if (x5 < 10) {
            s = "%s%c".format(s, ('0' + x5) toChar)
        }
        else {
            s = s + "%c".format('A' + (x5 - 10))
        }
        if (x6 < 10) {
            s = "%s%c".format(s, ('0' + x6) toChar)
        }
        else {
            s = s + "%c".format('A' + (x6 - 10))
        }
        if (x7 < 10) {
            s = "%s%c".format(s, ('0' + x7) toChar)
        }
        else {
            s = s + "%c".format('A' + (x7 - 10))
        }
        if (x8 < 10) {
            s = "%s%c".format(s, ('0' + x8) toChar)
        }
        else {
            s = s + "%c".format('A' + (x8 - 10))
        }
        return s
    }


    def main(args: Array[String]) {
            if (args.length < 1) {
                printUsage()
                System.exit(1)
            }

            var fname : String = args(0)

            var infile : File = new File(fname);
            if  (!infile.exists()) {
                 System.out.println("The file \"" + fname + "\" does not exist.");
                 System.exit(1);
            }

            if (!infile.canRead()) {
                 System.out.println("The file \"" + fname + "\" is not allowed to be read.");
                 System.exit(1);
            }   

            if  (infile.isDirectory()) {
                 System.out.println("\"" + fname + "\" is a directory.");
                 System.exit(1);
            }


            val is = new FileInputStream(fname)
            val cnt = is.available

            var lines = new Array[String](19)
            var b = new Array[Byte](1)

            printf("The size of the file \"%s\" is %d.\n", fname, cnt)
            printf("\n")

            var n = 0
            var dum = ""
            while (n < cnt) {
                if (n % 16 == 0) {
                    printf("%s: ", toHex8(n))
                }
                is.read(b)
                if (n % 16 == 8) {
                    printf("-%s", toHex(b(0) toInt))
                }
                else {
                    printf(" %s", toHex(b(0) toInt))
                }
                if ((b(0) toInt) < (' ' toInt) || (b(0) toInt) > 0x7F) {
                    dum = dum + "."
                }
                else {
                    dum = dum + "%c".format(b(0) toChar)
                }
                if (n % 16 == 15) {
                    printf("  |%s|\n", dum)
                    dum = ""
                }
                n += 1
            }
            if (n % 16 > 0) {
                for (j <- 1 to 16 - (n % 16)) {
                    printf("   ")
                }
                printf("  |%s", dum)
                for (j <- 1 to 16 - (n % 16)) {
                    printf(" ")
                }
                printf("|\n", dum)
                dum = ""
            }
            printf("\nRead %d bytes.\n", n)

            is.close()
    }
}

 

 

실행 예 1> scala testHexView_03 temp_1.bin
The size of the file "temp_1.bin" is 12.

0000 0000:  48 65 6C 6C 6F 20 74 68-65 72 65 0A              |Hello there.    |

Read 12 bytes.

실행 예 2> scala testHexView_03 myFile.ser
The size of the file "myFile.ser" is 130.

0000 0000:  AC ED 00 05 73 72 00 06-50 65 72 73 6F 6E 07 31  |....sr..Person.1|
0000 0010:  46 DB A5 1D 44 AB 02 00-03 49 00 03 61 67 65 4C  |F...D....I..ageL|
0000 0020:  00 09 66 69 72 73 74 4E-61 6D 65 74 00 12 4C 6A  |..firstNamet..Lj|
0000 0030:  61 76 61 2F 6C 61 6E 67-2F 53 74 72 69 6E 67 3B  |ava/lang/String;|
0000 0040:  4C 00 08 6C 61 73 74 4E-61 6D 65 71 00 7E 00 01  |L..lastNameq.~..|
0000 0050:  78 70 00 00 00 13 74 00-05 4A 61 6D 65 73 74 00  |xp....t..Jamest.|
0000 0060:  04 52 79 61 6E 73 71 00-7E 00 00 00 00 00 1E 74  |.Ryansq.~......t|
0000 0070:  00 07 4F 62 69 2D 77 61-6E 74 00 06 4B 65 6E 6F  |..Obi-want..Keno|
0000 0080:  62 69                                            |bi              |

Read 130 bytes.

 

 

 

Posted by Scripter
,

아래의 두 예제의 실행 결과는 똑 같다.
이 두 예제를 통해서 Java 언어와 Scala 언어의 문법적인 차이를 알아보고자 한다.


Java 예제
 

/**
 * Filename: HelloWorld.java
 *
 *  Compile: javac -d classes HelloWorld.java
 *  Execute: java -cp classes examples.HelloWorld
 */

package examples;

class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
        System.out.println("안녕하세요?");
    }
}

/*
Console Output:
Hello, world!
안녕하세요?
*/





 Scala 예제

/**
 * Filename: hello.scala
 *
 *  Compile: scalac -d classes -encoding MS949 hello.scala
 *  Execute: scala -cp classes examples.HelloWorld
 */

package examples

object HelloWorld {
    def main(args: Array[String]) {
        println("Hello, world!")
        println("안녕하세요?")
    }
}

/*
Console Output:
Hello, world!
안녕하세요?
*/



컴파일러와 인터프리터

    • javac는 명령줄에서 실행하는 Java의 컴파일 명령이고,
      scalac는 명령줄에서 실행하는 Scala의 컴파일 명령이다.
      여기서 컴파일이라 함은 소스 코드릉 번역하여
      (자바가상기계가 인식하는) 바이트 코드를 생성하는 과정을 말한다.

    • java는 명령줄에서 실행하는 Java의 인터프리터 명령이고,
      scala는 명령줄에서 실행하는 Scala의 인터프리터 명령이다.
      여기서 인터프리터 명령이라 함은 바이트 코드로 이루어진 클래스 파일을
      자바가상기계에 불러들여 인터프리트 방식으로 바이트 코드를 하나씩
      실행시킨다는 의미이다.
      명령줄에서 scala를 옵션 없이 실행하면 대화형 모드(intractive mode)에서
      Scala 코드를 직접 입력하면서 결과를 볼 수 있다. 
      이는 Python 언어의 python 명령과 유사하다.
     


Java 언어와 Scala 언어의 같은 점:

    • package 구문이 있다. (클래스 관리에 사용)
    • class 예약어가 있다.  (클래스 정의에 사용)
    • new 예약어가 있다.  (클래스 인스턴스에 사용)
    • new 예약어를 클래스명 앞에 붙인다. 
    • 중괄호 열기와 닫기 기호({와 })는 블럭을 나타내는데 사용한다.
    • String 상수의 리터럴은 쌍따옴표(")로 묶어 나타낸다.
    • String의 연결(concatenation) 연산자는 +이다.



Java 언어와 Scala 언어의 다른 점:

    • Scala는 소스 코드에 (UHC, 확장완성형) 한글이 한 자라도 포함되어 있으면,
      scalac 명령이나 scala 명령을 쓸 때 옵션 -encoding MS949를 사용한다.

    • Java 언어에서는 class 예약어로 정의된 클래스영과 소스의 파일명이 대체로
      일치하지만,  Scala 언어에서는 (public 클래스라고 하더라도) 반드시 그렇지는 않다.

    • Java 언어에서는 class 예약어로 클래스를 정의하면 그 클래스 다시 정의할 수
      없지만,  Scala 언어에서는 언제나 동일 클래스 명으로 언제나 확장 재정의할 수 있다.

    • Java 언어에서는 구문의 끝에 세미콜론(;)을 반드시 붙이지만,
      Scala 언어에서는 붙이지 않아도 된다.

    • 컨솔에 문자 출력하는 메소드가 Java 언어에서는 System.out.println이지만,
      Scala 언어에서는 println이다.

    • Java 언어와는 달리 Scala 언어에서는 클래스를 정의하는 예약어로 class 외에
      object가 있다. object 예약어로 정의된 클래스는 재정의할 수 없다.
      Scala 언어에서는 class 예약어로 정의된 클스는 언제나 확장 재정의해도 된다.
      (확장 재정의는 Ruby 언어에서도 지원하는 기능이다.)

    • 배열의 요소
       Java 언어:   배열변수명[번호]    예: args[0]
      Scala 언어:   배열변수명(번호)    예: args(0)

    • 변수의 타입선언 그리고 초기화
      Java 언어는 변수의 타입을 엄격히 적용하는 언어이지만,
      Scala 언어는 변수의 타입을 거의 엄격히 적용하는 언어이다. 여기서 '거의 엄격히'
      라고 한 것은 변수를 선언할 때 타입을 명기하지 않아도 되는 경우가 있기 때문이다.
      Scala 언어에서는 변수를 선언할 때 변수명 앞에 def, val, var 세 가지 중 하나를
      사용한다.

                 def 변수명
                 val 변수명
                 var 변수명

      그리고 변수명 뒤에는 이어서 콜론(:)과 타입명을 적어준다.

                 def 변수명 : 타입명
                 val 변수명 : 타입명
                 var 변수명 : 타입명

      또 타입명 뒤에는 이어서 등호(=)와 값을 표현하는 표현식 리터럴을 적는다.

                 def 변수명 : 타입명 = 표현식 리터럴
                 val 변수명 : 타입명 = 표현식 리터럴
                 var 변수명 : 타입명 = 표현식 리터럴

     :
                def TEN : BigInt = BigInt("10")    // BigInt 클래스는 케이스 클래스이므로
                                                             // new 예약어 없이 인스턴스된다.
                val ZERO : Double = 0.0
                var x : Int = 5

       val과 def는 그 연산 시점이 다르다.
       val로 선언된 변수는 그 우변을 계산해서 값을 할당하고 그 이후로는 줄곧
       변하지 않지만, def로 선언된 변수는 그 우변의 표현식이 저장되어, 사용될 때 마다
       그 우변의 표현식에 의하여 언제나 새로 계산된다(lazy evaluation).
        scala 인터프리터 명령으로 이 차이를 알아보자.

프롬프트> scala
Welcome to Scala version 2.7.3.final (Java HotSpot(TM) Client VM, Java 1.6.0_12)
.
Type in expressions to have them evaluated.
Type :help for more information.

scala> var x : Int = 5
x: Int = 5

scala> x = 7
x: Int = 7

scala> val y = x
y: Int = 7

scala> y = 3
<console>:6: error: reassignment to val
       y = 3
         ^

scala> def t = x*x      // lazy evaluation
t: Int

scala> t
res2: Int = 49

scala> x = 10
x: Int = 10

scala> t
res4: Int = 100

scala> exit



 

크리에이티브 커먼즈 라이선스
Creative Commons License

 

Posted by Scripter
,