다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을
Java 언어로 구현해 보았다. 조립제법은 일명 Horner의 방법이라고도 불리우는데, 이는
x = a 에서 다항식 p(x)의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

         p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

[참고]
    * 온라인으로 조립제법 표 만들기 손으로 계산하는 조립제법 표 
    * 온라인으로 구하는 다항식의 도함수: 조립제법을 이용한 다항식의 도함수

  1. /*
  2.  *  Filename: TestSyntheticMethod.java
  3.  *
  4.  *  Purpose:  Find the quotient and remainder when some polynomial is
  5.  *            divided by a monic polynomial of the first degree.
  6.  *
  7.  *  Compile: javac -d . TestSyntheticMethod.java
  8.  *
  9.  *  Execute: java TestSyntheticMethod -2 1 3 3 1
  10.  */
  11. import java.lang.Math;
  12. public class TestSyntheticMethod {
  13.     // 사용법 표시
  14.     public static void printUsage() {
  15.          System.out.println("사용법: java TestSyntheticMethod [수] [피제식의 계수들]");
  16.          System.out.println("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.");
  17.     }
  18.     // 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
  19.     public static String simplify(double v) {
  20.         String t = "" + v;
  21.         if (t.endsWith(".0"))
  22.             t = t.substring(0, t.length() - 2);
  23.         return t;
  24.     }
  25.     // 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
  26.     // 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
  27.     public static String simplify(double v, int width) {
  28.         String t = "" + v;
  29.         if (t.endsWith(".0"))
  30.             t = t.substring(0, t.length() - 2);
  31.         int len = t.length();
  32.         if (len < width)
  33.             t = "               ".substring(0, width - len) + t;
  34.         return t;
  35.     }
  36.     // 다항식을 내림차순의 스트링 표현으로 반환
  37.     public static String toPolyString(double[] c) {
  38.         String t = "";
  39.         if (c.length > 2) {
  40.             if (simplify(c[0]).equals("1"))
  41.                 t += "x^" + (c.length-1);
  42.             else if (simplify(c[0]).equals("-1"))
  43.                 t += "-x^" + (c.length-1);
  44.             else
  45.                 t += simplify(c[0]) + " x^" + (c.length-1);
  46.         }
  47.         else if (c.length == 2) {
  48.             if (simplify(c[0]).equals("1"))
  49.                 t += "x";
  50.             else if (simplify(c[0]).equals("-1"))
  51.                 t += "-x";
  52.             else
  53.                 t += simplify(c[0]) + " x";
  54.         }
  55.         else if (c.length == 1) {
  56.             t += simplify(c[0]);
  57.         }
  58.         for (int i = 1; i < c.length; i++) {
  59.             if (c.length - 1 - i > 1) {
  60.                 if (c[i] > 0.0) {
  61.                     if (simplify(c[i]).equals("1"))
  62.                         t += " + " + "x^" + (c.length - 1 - i);
  63.                     else
  64.                         t += " + " + simplify(c[i]) + " x^" + (c.length - 1 - i);
  65.                 }
  66.                 else if (c[i] < 0.0) {
  67.                     if (simplify(c[i]).equals("-1"))
  68.                         t += " - " + "x^" + (c.length - 1 - i);
  69.                     else
  70.                         t += " - " + simplify(Math.abs(c[i])) + " x^" + (c.length - 1 - i);
  71.                 }
  72.             }
  73.             else if (c.length - 1 - i == 1) {
  74.                 if (c[i] > 0.0) {
  75.                     if (simplify(c[i]).equals("1"))
  76.                         t += " + " + "x";
  77.                     else
  78.                         t += " + " + simplify(c[i]) + " x";
  79.             }
  80.             else if (c[i] < 0.0) {
  81.                 if (simplify(c[i]).equals("-1"))
  82.                     t += " - " + "x";
  83.                 else
  84.                     t += " - " + simplify(Math.abs(c[i])) + " x";
  85.             }
  86.         }
  87.         else if (c.length - 1 - i == 0) {
  88.             if (c[i] > 0.0) {
  89.                 t += " + " + simplify(c[i]);
  90.             }
  91.             else if (c[i] < 0.0)
  92.                 t += " - " + simplify(Math.abs(c[i]));
  93.             }
  94.         }
  95.         return t;
  96.     }
  97.     // 다항식 나눗셈 결과를
  98.     //     (피제식) = (제식)(몫) + (나마지)
  99.     // 형태로 출력
  100.     public static void printDivisionResult(double a, double[] c, double[] b) {
  101.         System.out.print("  " + toPolyString(c));
  102.         System.out.println();
  103.         System.out.print("    = ( " + toPolyString( new double[] {1.0, -a} ) + " )");
  104.         double[] tmp = new double[b.length - 1];
  105.         for (int i = 0; i < tmp.length; i++) {
  106.             tmp[i] = b[i];
  107.         }
  108.         System.out.print("( " + toPolyString(tmp) + " )");
  109.         double r = b[b.length - 1];
  110.         if (r > 0.0)
  111.             System.out.print(" + " + simplify(r));
  112.         else if (r < 0.0)
  113.             System.out.print(" - " + simplify(Math.abs(r)));
  114.         System.out.println();
  115.     }
  116.     // 조립제법 계산표 출력 메소드
  117.     public static void printSyntheticTable(double a, double[] c, double[] s, double[] q) {
  118.         System.out.print("       | ");
  119.         System.out.print(simplify(c[0], 6));
  120.         for (int i = 1; i < c.length; i++) {
  121.             System.out.print("  " + simplify(c[i], 6));
  122.         }
  123.         System.out.println();
  124.         System.out.print(simplify(a, 6) + " | ");
  125.         System.out.print("        ");
  126.         System.out.print(simplify(s[1], 6));
  127.         for (int i = 2; i < s.length; i++) {
  128.             System.out.print("  " + simplify(s[i], 6));
  129.         }
  130.         System.out.println();
  131.         System.out.print("       |-");
  132.         for (int i = 0; i < q.length; i++) {
  133.             System.out.print("--------");
  134.         }
  135.         System.out.println("");
  136.         System.out.print("         ");
  137.         System.out.print(simplify(q[0], 6));
  138.         for (int i = 1; i < q.length; i++) {
  139.             System.out.print("  " + simplify(q[i], 6));
  140.         }
  141.         System.out.println();
  142.     }
  143.     // Java 애플리케이션의 실행 시작 시점 main 메소드
  144.     // (C 언어의 main 함수에 해당)
  145.     public static void main(String[] args) {
  146.         if (args.length < 3) {
  147.             printUsage();
  148.             System.exit(1);
  149.         }
  150.         //////////////////////////////////////////////////////
  151.         // 피제식은 c_0 x^n +  c_1 x^(n -1) + ... + c_n
  152.         // 제식은 x -  a
  153.         double a = Double.parseDouble(args[0]);
  154.         double[] c = new double[args.length - 1];
  155.         double[] s = new double[c.length];
  156.         double[] b = new double[c.length];
  157.         for (int i = 0; i < c.length; i++) {
  158.             c[i] = Double.parseDouble(args[i + 1]);
  159.         }
  160.         //////////////////////////////////////////////////////
  161.         // 조립제법의 주요 부분
  162.         s[0] = 0.0;
  163.         b[0] = c[0];
  164.         for (int i = 1; i < c.length; i++) {
  165.            s[i] = b[i-1]*a;
  166.             b[i] = c[i] + s[i];
  167.         }
  168.         //////////////////////////////////////////////////////
  169.         // 몫의 계수와 나머지를 출력한다.
  170.         System.out.print("몫의 계수는 ");
  171.         for (int i = 0; i < b.length - 2; i++) {
  172.             System.out.print(simplify(b[i]) + ", " );
  173.         }
  174.         System.out.print(simplify(b[b.length - 2]));
  175.         System.out.println(" 이고, 나머지는 " + simplify(b[b.length - 1]) + " 이다.");
  176.         System.out.println();
  177.         //////////////////////////////////////////////////////
  178.         // 조립제법 표를 출력한다.
  179.         printSyntheticTable(a, c, s, b);
  180.         System.out.println();
  181.         //////////////////////////////////////////////////////
  182.         // (피제식) = (제식) x (몫) + (나머지)
  183.         printDivisionResult(a, c, b);
  184.     }
  185. }





컴파일> javac -d . TestSyntheticMethod.java
실행> java TestSyntheticMethod 1 2 3 4 5


몫의 계수는 2, 5, 9 이고, 나머지는 14 이다.       |      2       3       4       5     1 |              2       5       9       |---------------------------------              2       5       9      14  2 x^3 + 3 x^2 + 4 x + 5    = ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14


Creative Commons License
이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.
Posted by Scripter
,
  1. /*
  2.  *  Filename: TestForForApp.java
  3.  *
  4.  *  Compile:  javac -d . TestForForApp.java
  5.  *  Execute:  java TestForForApp
  6.  *
  7.  *  Date:  2008. 3. 3.
  8.  */
  9. public class TestForForApp {
  10.     // static 선언자가 없으므로 이 메소드는 인스턴스 메소드이다.
  11.     // 인스턴스 메소드는 static 메소드에서는 직접 호출되지 않는다.
  12.     // 반드시 생성된 객체를 거쳐서 호출되어 진다.
  13.     public String[] getDan(int dan) {
  14.         String[] t = new String[19];
  15.         String sa, sb, sval;
  16.         for (int j = 0; j < 19; j++) {
  17.             sa = "" + dan;
  18.             if (sa.length() < 2)
  19.                 sa = " " + sa;
  20.             sb = "" + (j + 1);
  21.             if (sb.length() < 2)
  22.                 sb = " " + sb;
  23.             sval = "" + (dan*(j + 1));
  24.             if (sval.length() < 2)
  25.                 sval = "  " + sval;
  26.             else if (sval.length() < 3)
  27.                 sval = " " + sval;
  28.             t[j] = sa + " x " + sb + " = " + sval;
  29.         }
  30.         return t;
  31.     }
  32.     // 19단표를 모두 80컬럼 컨솔에 출력한다.
  33.     //
  34.     // (static 선언자가 없는) 인스턴스 메소드이므로,
  35.     // 반드시 생성된 객체를 거쳐서 호출되어 진다.
  36.     public void printAllNineteenDan() {
  37.         String[][] arr = new String[18][19];
  38.         for (int i = 2; i < 20; i++) {
  39.             arr[i - 2] = getDan(i);
  40.         }
  41.         int[] d = new int[] { 2, 7, 11, 16};      // 각 줄단위 블럭의 첫단
  42.         int[] counter = new int[] { 5, 4, 5, 4};  // 각 줄단위 블럭에 속한 단의 개수
  43.         String[] lines = new String[19];
  44.         for (int k = 0; k < d.length; k++) {
  45.             // 8-바이트 길이의 한 줄씩 완성
  46.             for (int i = 0; i < 19; i++) {
  47.                 lines[i] = arr[d[k]-2][i];
  48.                 for (int j = 1; j < counter[k]; j++) {
  49.                     lines[i] += "   " +  arr[d[k]-2+j][i];
  50.                 }
  51.             }
  52.             // 80 바이트 길이의 한 줄씩 출력
  53.             for (int i = 0; i < 19; i++) {
  54.                 System.out.println(lines[i]);
  55.             }
  56.             System.out.println();
  57.         }
  58.     }
  59.     // C 언어의 main 함수에 준하는 Java 언어의 스테틱 main 메소드
  60.     public static void main(String[] args) {
  61.         TestForForApp app = new TestForForApp();  // 객체를 생성한다.
  62.         app.printAllNineteenDan();    // 객체에 속하는 메소드 printDan()을 호출한다.
  63.     }
  64. }



컴파일> javac TestForForApp.java
실행> java TestForForApp

 2 x  1 =   2    3 x  1 =   3    4 x  1 =   4    5 x  1 =   5    6 x  1 =   6
 2 x  2 =   4    3 x  2 =   6    4 x  2 =   8    5 x  2 =  10    6 x  2 =  12
 2 x  3 =   6    3 x  3 =   9    4 x  3 =  12    5 x  3 =  15    6 x  3 =  18
 2 x  4 =   8    3 x  4 =  12    4 x  4 =  16    5 x  4 =  20    6 x  4 =  24
 2 x  5 =  10    3 x  5 =  15    4 x  5 =  20    5 x  5 =  25    6 x  5 =  30
 2 x  6 =  12    3 x  6 =  18    4 x  6 =  24    5 x  6 =  30    6 x  6 =  36
 2 x  7 =  14    3 x  7 =  21    4 x  7 =  28    5 x  7 =  35    6 x  7 =  42
 2 x  8 =  16    3 x  8 =  24    4 x  8 =  32    5 x  8 =  40    6 x  8 =  48
 2 x  9 =  18    3 x  9 =  27    4 x  9 =  36    5 x  9 =  45    6 x  9 =  54
 2 x 10 =  20    3 x 10 =  30    4 x 10 =  40    5 x 10 =  50    6 x 10 =  60
 2 x 11 =  22    3 x 11 =  33    4 x 11 =  44    5 x 11 =  55    6 x 11 =  66
 2 x 12 =  24    3 x 12 =  36    4 x 12 =  48    5 x 12 =  60    6 x 12 =  72
 2 x 13 =  26    3 x 13 =  39    4 x 13 =  52    5 x 13 =  65    6 x 13 =  78
 2 x 14 =  28    3 x 14 =  42    4 x 14 =  56    5 x 14 =  70    6 x 14 =  84
 2 x 15 =  30    3 x 15 =  45    4 x 15 =  60    5 x 15 =  75    6 x 15 =  90
 2 x 16 =  32    3 x 16 =  48    4 x 16 =  64    5 x 16 =  80    6 x 16 =  96
 2 x 17 =  34    3 x 17 =  51    4 x 17 =  68    5 x 17 =  85    6 x 17 = 102
 2 x 18 =  36    3 x 18 =  54    4 x 18 =  72    5 x 18 =  90    6 x 18 = 108
 2 x 19 =  38    3 x 19 =  57    4 x 19 =  76    5 x 19 =  95    6 x 19 = 114

 7 x  1 =   7    8 x  1 =   8    9 x  1 =   9   10 x  1 =  10
 7 x  2 =  14    8 x  2 =  16    9 x  2 =  18   10 x  2 =  20
 7 x  3 =  21    8 x  3 =  24    9 x  3 =  27   10 x  3 =  30
 7 x  4 =  28    8 x  4 =  32    9 x  4 =  36   10 x  4 =  40
 7 x  5 =  35    8 x  5 =  40    9 x  5 =  45   10 x  5 =  50
 7 x  6 =  42    8 x  6 =  48    9 x  6 =  54   10 x  6 =  60
 7 x  7 =  49    8 x  7 =  56    9 x  7 =  63   10 x  7 =  70
 7 x  8 =  56    8 x  8 =  64    9 x  8 =  72   10 x  8 =  80
 7 x  9 =  63    8 x  9 =  72    9 x  9 =  81   10 x  9 =  90
 7 x 10 =  70    8 x 10 =  80    9 x 10 =  90   10 x 10 = 100
 7 x 11 =  77    8 x 11 =  88    9 x 11 =  99   10 x 11 = 110
 7 x 12 =  84    8 x 12 =  96    9 x 12 = 108   10 x 12 = 120
 7 x 13 =  91    8 x 13 = 104    9 x 13 = 117   10 x 13 = 130
 7 x 14 =  98    8 x 14 = 112    9 x 14 = 126   10 x 14 = 140
 7 x 15 = 105    8 x 15 = 120    9 x 15 = 135   10 x 15 = 150
 7 x 16 = 112    8 x 16 = 128    9 x 16 = 144   10 x 16 = 160
 7 x 17 = 119    8 x 17 = 136    9 x 17 = 153   10 x 17 = 170
 7 x 18 = 126    8 x 18 = 144    9 x 18 = 162   10 x 18 = 180
 7 x 19 = 133    8 x 19 = 152    9 x 19 = 171   10 x 19 = 190

11 x  1 =  11   12 x  1 =  12   13 x  1 =  13   14 x  1 =  14   15 x  1 =  15
11 x  2 =  22   12 x  2 =  24   13 x  2 =  26   14 x  2 =  28   15 x  2 =  30
11 x  3 =  33   12 x  3 =  36   13 x  3 =  39   14 x  3 =  42   15 x  3 =  45
11 x  4 =  44   12 x  4 =  48   13 x  4 =  52   14 x  4 =  56   15 x  4 =  60
11 x  5 =  55   12 x  5 =  60   13 x  5 =  65   14 x  5 =  70   15 x  5 =  75
11 x  6 =  66   12 x  6 =  72   13 x  6 =  78   14 x  6 =  84   15 x  6 =  90
11 x  7 =  77   12 x  7 =  84   13 x  7 =  91   14 x  7 =  98   15 x  7 = 105
11 x  8 =  88   12 x  8 =  96   13 x  8 = 104   14 x  8 = 112   15 x  8 = 120
11 x  9 =  99   12 x  9 = 108   13 x  9 = 117   14 x  9 = 126   15 x  9 = 135
11 x 10 = 110   12 x 10 = 120   13 x 10 = 130   14 x 10 = 140   15 x 10 = 150
11 x 11 = 121   12 x 11 = 132   13 x 11 = 143   14 x 11 = 154   15 x 11 = 165
11 x 12 = 132   12 x 12 = 144   13 x 12 = 156   14 x 12 = 168   15 x 12 = 180
11 x 13 = 143   12 x 13 = 156   13 x 13 = 169   14 x 13 = 182   15 x 13 = 195
11 x 14 = 154   12 x 14 = 168   13 x 14 = 182   14 x 14 = 196   15 x 14 = 210
11 x 15 = 165   12 x 15 = 180   13 x 15 = 195   14 x 15 = 210   15 x 15 = 225
11 x 16 = 176   12 x 16 = 192   13 x 16 = 208   14 x 16 = 224   15 x 16 = 240
11 x 17 = 187   12 x 17 = 204   13 x 17 = 221   14 x 17 = 238   15 x 17 = 255
11 x 18 = 198   12 x 18 = 216   13 x 18 = 234   14 x 18 = 252   15 x 18 = 270
11 x 19 = 209   12 x 19 = 228   13 x 19 = 247   14 x 19 = 266   15 x 19 = 285

16 x  1 =  16   17 x  1 =  17   18 x  1 =  18   19 x  1 =  19
16 x  2 =  32   17 x  2 =  34   18 x  2 =  36   19 x  2 =  38
16 x  3 =  48   17 x  3 =  51   18 x  3 =  54   19 x  3 =  57
16 x  4 =  64   17 x  4 =  68   18 x  4 =  72   19 x  4 =  76
16 x  5 =  80   17 x  5 =  85   18 x  5 =  90   19 x  5 =  95
16 x  6 =  96   17 x  6 = 102   18 x  6 = 108   19 x  6 = 114
16 x  7 = 112   17 x  7 = 119   18 x  7 = 126   19 x  7 = 133
16 x  8 = 128   17 x  8 = 136   18 x  8 = 144   19 x  8 = 152
16 x  9 = 144   17 x  9 = 153   18 x  9 = 162   19 x  9 = 171
16 x 10 = 160   17 x 10 = 170   18 x 10 = 180   19 x 10 = 190
16 x 11 = 176   17 x 11 = 187   18 x 11 = 198   19 x 11 = 209
16 x 12 = 192   17 x 12 = 204   18 x 12 = 216   19 x 12 = 228
16 x 13 = 208   17 x 13 = 221   18 x 13 = 234   19 x 13 = 247
16 x 14 = 224   17 x 14 = 238   18 x 14 = 252   19 x 14 = 266
16 x 15 = 240   17 x 15 = 255   18 x 15 = 270   19 x 15 = 285
16 x 16 = 256   17 x 16 = 272   18 x 16 = 288   19 x 16 = 304
16 x 17 = 272   17 x 17 = 289   18 x 17 = 306   19 x 17 = 323
16 x 18 = 288   17 x 18 = 306   18 x 18 = 324   19 x 18 = 342
16 x 19 = 304   17 x 19 = 323   18 x 19 = 342   19 x 19 = 361




Creative Commons License
이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.
Posted by Scripter
,

소스 파일명: TestWhileLoop.java

  1. /*
  2.  *  Filename: TestWhileLoop.java
  3.  *
  4.  *  Purpose:  Example using the while loop syntax
  5.  *                while ....
  6.  *
  7.  *  Compile: javac -d . TestWhileLoop.java
  8.  *  Execute: java TestWhileLoop -200 300
  9.  *
  10.  */
  11. import java.lang.Math;
  12. public class TestWhileLoop {
  13.     // 사용법 표시
  14.     public static void printUsage() {
  15.          System.out.println("Using: java TestWhileLoop [integer1] [integer2]");
  16.          System.out.println("This finds the greatest common divisor of the given two integers.");
  17.     }
  18.     // Java 애플리케이션의 실행 시작 시점 main 메소드
  19.     // (C 언어의 main 함수에 해당)
  20.     public static void main(String[] args) {
  21.         if (args.length != 2) {
  22.             printUsage();
  23.             System.exit(1);
  24.         }
  25.         ////////////////////////////////////////////////
  26.         // 명령행 인자의 두 스트링을 가져와서
  27.         // 긴정수(long) 타입으로 변환하여
  28.         // 변수 val1과 val2에 저장한다.
  29.         long val1 = Long.parseLong(args[0]);
  30.         long val2 = Long.parseLong(args[1]);
  31.         long a, b, q, r, gcd;    // r은 나머지, q는 몫
  32.         // a는 |val1|, |val2| 중 큰 값
  33.         a = Math.abs(val1);
  34.         b = Math.abs(val2);
  35.         if (a < b) {
  36.             a = Math.abs(val2);
  37.             b = Math.abs(val1);
  38.         }
  39.         if (b == 0L) {
  40.             System.out.println("GCD(" + val1 + ", " + val2 + ") = " + a);
  41.             System.exit(0);
  42.         }
  43.         ////////////////////////////////////////
  44.         // Euclidean 알고리즘의 시작
  45.         //
  46.         // a를 b로 나누어 몫은 q에, 나머지는 r에 저장
  47.         q = a / b;
  48.         r = a % b;
  49.         ////////////////////////////////////////
  50.         // Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
  51.         while (r != 0L) {
  52.             a = b;
  53.             b = r;
  54.             q = a / b;
  55.             r = a % b;
  56.         }
  57.         // 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
  58.         gcd = b;
  59.         // 최대공약수(GCD)를 출력한다.
  60.         System.out.println("GCD(" + val1 + ", " + val2 + ") = " + gcd);
  61.     }
  62. }

컴파일> javac -d . TestWhileLoop.java

실행> java TestWhileLoop
Using: java TestWhileLoop [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

실행> java TestWhileLoop 200 300
GCD(200, 300) = 100

실행> java TestWhileLoop 50, -20
GCD(50, -20) = 10

실행> java TestWhileLoop -30, 0
GCD(-30, 0) = 30



Groovy를 사용하면 위의 소스를 (컴파일 과정 없이) 그대로 실행시킬 수 있다. 그대신 파일 확장자명을 groovy로 하여 저장하여야 한다. 아래는 파일명을 TestWhileLoop.groovy로 저장하여 실행시칸 경우이다.


실행> groovy TestWhileLoop.groovy
Using: java TestWhileLoop [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

실행> groovy TestWhileLoop.groovy -200 500
GCD(-200, 500) = 100

실행> groovy TestWhileLoop.groovy 108, 180
GCD(108, 180) = 36

실행> groovy TestArguments.groovy -30, 0
GCD(-30, 0) = 30




Creative Commons License
이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

Posted by Scripter
,

소스 파일명: TestIfThen.java

  1. public class TestIfThen {
  2.     public static void printUsing() {
  3.         System.out.println("Using: java TestIfThen [number]");
  4.         System.out.println("This determines whether the number is positive or not.");
  5.     }
  6.     // C 언어의 main 함수에 준하는 Java 언어의 main 메소드
  7.     public static void main(String[] args) {
  8.         if (args.length != 1) {
  9.             printUsing();
  10.             System.exit(1);
  11.         }
  12.         ////////////////////////////////////////////////
  13.         // 명령행 인자의 스트링을 가져와서
  14.         // 배정밀도 부동소수점수로 변환하여
  15.         // 변수 val에 저장한다.
  16.         double val = Double.parseDouble(args[0]);
  17.         // 변수 val에 저장된 값이 양수인지 음수인지 0인지를
  18.         // 판단하는 if...else... 조건문
  19.         if (val > 0.0)
  20.             System.out.println(val + " is a positive number.");
  21.         else if (val < 0.0)
  22.             System.out.println(val + " is a negative number.");
  23.         else
  24.             System.out.println(val + " is zero.");
  25.     }
  26. }

컴파일> javac -d . TestIfThen.java

실행> java TestIfThen
Using: java TestIfThen [number]
This determines whether the number is positive or not.

실행> java TestIfThen 2.1
2.1 is a positive number.

실행> java TestIfThen -2.1
-2.1 is a negative number.

실행> java TestIfThen 0
0.0 is zero.



Groovy를 사용하면 위의 소스를 (컴파일 과정 없이) 그대로 실행시킬 수 있다. 그대신 파일 확장자명을 groovy로 하여 저장하여야 한다. 아래는 파일명을 TestIfThen.groovy로 저장하여 실행시칸 경우이다.


실행> groovy TestIfThen.groovy
Using: java TestIfThen [number]
This determines whether the number is positive or not.

실행> groovy TestIfThen.groovy 2.1
2.1 is a positive number.

실행> groovy TestIfThen.groovy -2.1
-2.1 is a negative number.

실행> groovy TestIfThen.groovy 0
0.0 is zero.




Creative Commons License
이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

Posted by Scripter
,

소스 파일명: TestArguments.java

  1. public class TestArguments {
  2.     // C 언어의 main 함수에 준하는 Java 언어의 main 메소드
  3.     public static void main(String[] args) {
  4.         double sum = 0.0;    // 초기화
  5.         // 명령행 인자(command-line argument) 개수 출력
  6.         System.out.println("Count of arguments: " + args.length);
  7.         for (int i = 0; i < args.length; i++) {
  8.             // 스트링을 배정밀도 부동소수점수로 변환하여 누적
  9.             sum += Double.parseDouble(args[i]);
  10.         }
  11.         // 출력 값이 ".0"으로 끝나는 경우 꼬리 제거하기
  12.         String strSum = "" + sum;
  13.         if (strSum.endsWith(".0"))
  14.             strSum = strSum.substring(0, strSum.length() - 2);
  15.         // 누적된 값을 출력한다.
  16.         System.out.println("The sum of arguments is " + strSum);
  17.     }
  18. }

컴파일> javac -d . TestArguments.java

실행> java TestArguments 1 2 3 4
Count of arguments: 4
The sum of arguments is 10

실행> java TestArguments 1 2.1 3 4.5
Count of arguments: 4
The sum of arguments is 10.6





Creative Commons License
이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

Posted by Scripter
,

Java 언어는 C++ 언어 처럼 객체지향(obeject oriented) 언어이므로 함수(function)라는 개념이나 용어보다 메소드(method)라는 개념이나 용어를 더 많이 쓴다.
동적으로(dynamically) 생성되어 힙(heap) 메모리에 존재하는 객체(obeject)에 소속되는 메소드가 아니라 클래스 자체에 소속되어 정적 메모리에 존재하는 메소드는 정적(스태틱, static) 메소드라고 한다. Java 언어에서 static 선언자를 붙여서 메소드를 정의하면 static 메소드가 된다. Java 언어의 static 메소드는 메모리 상에서의 그 동작이 C 언어의 함수의 것 비슷하다고 보면 된다.

Java 언어의 메소드 정의 구문 양식과 for 반복문 양식은 C/C++의 것과 유사하다.
다른 점은 접근 혀용 법위 선언자(public, private 등), 메모리 상의 존재 여부 선언자(static)을 붙여서 정의하기도 한다는 것이다.

Java 언어의 메소드 정의 구문 양식은

       [public/private 등] [static] type methodName(parameters) {
             block
       }

이다.

또 Java 언어의 for 반복문 양식은

       for (varName = initialValue; condition; replicator) {
             block
       }

이다.



소스 파일명: ForTest.java
------------------------------[소스 시작]
public class ForTest {

  // static 메소드로 선언되었으므로 main 메소드에서 이 메소드를
  // 객체 생성 없이 직접 호출할 수 있다.
  public static void printDan(int dan) {
    for (int i = 1; i < 10; i++) {
      System.out.println(dan + " x " + i + " = " + (dan*i));
    }
  }

  // C 언어의 main 함수에 준하는 Java 언어의 main 메소드
  public static void main(String[] args) {
    printDan(2);    // static 메소드 printDan()을 호출한다.
  }
}
------------------------------[소스 끝]

컴파일> javac -d . ForTest.java

(참고: 에러 없이 컴파일이 순조롭게 끝나면 현재 디렉토리에 ForTest.class라는 클래스 파일이 존재할 것이다.)

실행> java ForTest
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18



소스 파일명: ForTestObject.java
------------------------------[소스 시작]
public class ForTestObject {

  // static 선언자가 없으므로 이 메소드는
  // 다른 static 메소드에서는 직접 호출되지 않는다.
  // 반드시 생성된 ForTestObject 객체를 거쳐서 호출된다.
  public void printDan(int dan) {
    for (int i = 1; i < 10; i++) {
      System.out.println(dan + " x " + i + " = " + (dan*i));
    }
  }

  // C 언어의 main 함수에 준하는 Java 언어의 스테틱 main 메소드
  public static void main(String[] args) {
    ForTestObject app = new ForTestObject();  // 객체를 생성한다.
    app.printDan(2);    // 객체에 속하는 메소드 printDan()을 호출한다.
  }
}
------------------------------[소스 끝]

컴파일> javac -d . ForTestObject.java

(참고: 컴파일이 순조롭게 끝나면 현재 디렉토리에 ForTestObject.class 라는 클래스 파일이 존재할 것이다.)

실행> java ForTestObject

(참고: 실행 결과는 java ForTest 로 실행한 결과와 같다.)





Creative Commons License
이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

Posted by Scripter
,