맛있는 데이터

클래스 Class

기존의 절차지향언어에서도 소스코드를 재사용하기 위한 함수가 존재하였습니다. 소스코드를 재사용한다는 것은 매우 많은 장점을 가지고 있죠. 이미 작성된 소스코드를 또 작성할 필요가 없기 때문에 시간도 절약되고 소스코드양도 줄어듭니다. 이미 검증된 소스코드를 재사용한다면 결함에 대한 걱정없이 소스코드를 마음놓고 활용할 수도 있죠. 또한 공동작업에서 (개인이 여러일을 하든 집단이 여러일을 하든) 이미 잘 알려진 재사용된 소스코드로 이해하기 쉽거나 의사소통에 원활한 장점을 가져다 줍니다. 그리고 공통부분에 대한 전체적인 수정이 필요할때 재사용되어지는 소스코드부분만 수정하면 재사용하는 모든 소스코드에 일괄적인 수정효과를 발생시킵니다.

객체지향언어에서는 이런 재사용을 더욱 극대화하기 위해 상태를 표현해주는 데이터와 동작을 표현해주는 처리를 한번에 모아서 객체라는것으로 표현하는 것입니다. 이 세상의 모든 것들은 객체(Object) 로 표현할 수 있습니다. 모든 사물이 상태와 동작으로 표현될 수 있으니까요. 이런 객체(Object) 는 실제로 구현되어 존재하는 것입니다. 클래스는 이러한 객체를 정의하는 것입니다. 

가령 실제 세상에 존재하는 사과를 생각해 봅시다. 사과의 무게 색깔 향 을 상태로 표현하고 사과가 공중에서 놓으면 떨어지고 힘을주면 반으로 쪼개지고 깨물어 먹을때 '아삭'하는 소리가 나는것을 동작으로 표현해 봅시다. 우리는 모두 사과를 알기 때문에 머릿속에 사과의 무게,색깔,향 (상태) 와 떨어지고 쪼개지고 소리나는 것 (동작) 을 상상할 수 있습니다. 이것을 사과 클래스로 볼 수 있습니다. 그리고 실제 사과 2개가 테이블위에 있습니다. 이 사과 2개는 실제로 존재하기 때문에 각각의 사과 객체(Object) 입니다. 머릿속으로 정의된 클래스가 실제로 구현된 것이 객체(혹은 인스턴스)라고 볼 수 있습니다. 사과 한개는 그대로 두고 다른 사과를 한입베어 먹었습니다. 본래 2개는 같은 클래스로부터 실체화된 객체였는데 2개중 한개를 한입 먹었으므로 무게가 달라졌고 베어 문자리의 색깔이 달라졌습니다. 다시 온전한 사과를 한입 베어 물었습니다. 이제 사과 2개는 다시 무게가 같아졌고 베어문 자리의 색깔도 같아졌습니다. 이미 구현된 객체(인스턴스)가 독립적으로 움직이지만 본래 같은 사과 클래스였기때문에 같은 상태가 되거나 같은 동작을 할 수 있는 가능성이 있는 것입니다.

클래스는 상태를 나타내는 필드(데이터) 와 동작을 나타내는 메소드(처리) 로 구성되어 있습니다. 필드와 메소드는 클래스의 멤버라고 합니다. Book 클래스를 소스코드로 표현하면

class Book {

int price ;

int num ;

String title ;

int sum() {

return price * num ;

}

}

으로 표현할 수 있습니다. price,num,title 은 필드이고 sum() 은 메소드이고 앞의 것들은 모두 멤버입니다. 이 클래스는 정의(개념)이기 때문에 실체화된 존재가 아닙니다. 실제로 존재하기 위해서는 객체화(인스턴스 화) 되어야 합니다. 이것을 오브젝트 생성이라고 합니다. new 연산자를 통해 오브젝트를 생성할 수 있습니다.

Book book1 ;                // Book 이라는 클래스 타입으로 book1 이라는 오브젝트 명을 정의합니다.

book1 = new Book( ); // book1 이라는 오브젝트 명은 Book 이라는 클래스로부터 오브젝트가 생성됩니다.

이렇게 줄여서 작성할 수도 있습니다.

Book book1 = new Book( );

Book book2 = new Book( );

book1, book2 는 같은 Book 클래스로부터 생성된 다른 오브젝트입니다.

book1 오브젝트의 필드에 실제 값을 넣어봅시다. 같은 오브젝트에서는 필드명을 그대로 사용하여 값을 대입하거나 참조할 수 있습니다.

price = 10000;

num = price + 10000;

다른 오브젝트의 필드를 참조하거나 대입하려면 .(피리오드) 를 사용합니다.

book2.price = 5000;

num = book2.price + 10000;

메소드는 처리동작입니다. 재료를 주면 처리를하여 결과를 반환합니다.

int add(int a, int b){    // add 메소드는 a, b 라는 int 형 재료를 받아서 처리한 뒤 int 형 결과를 반환합니다.

int x;

x = a + b;             // 처리 방법

return x;             // 반환(리턴)

}

반환(리턴) 값이나 재료(인수) 값이 없을 수도 있습니다. 리턴값이 없을경우 void 라고 지정합니다. 인수값이 없을경우는 ( ) 안을 공백으로 둡니다.

동일 오브젝트 내의 메소드를 호출할때는 메소드명과 인수값 리턴값을 메소드에 정의된대로 기술하여 사용합니다.

c = add(1,2);

다른 오브젝트의 메소드를 호출할때는 필드와 마찬가지로 .(피리오드)를 사용합니다.

c = book2.add(1,2);

이 내용은 ANK Co.,Ltd. 저 김성훈 역의 Java가 보이는 그림책에서 요약 발췌하였습니다.

삼각형의 넓이를 구하는 알고리즘

먼저 수학적으로 평면상의 삼각형의 넓이를 구하는 방법을 알아보자.

출처 : http://blog.naver.com/dalsapcho/20131270309

S: 삼각형의 넓이, a,b,c: 삼각형 각 변의 길이, h: 삼각형의 높이, R:삼각형 외접원의 반지름, r:삼각형 내접원의 반지름, x1,y1,x2,y2,x3,y3: 삼각형 꼭지점의 좌표

1번 공식은 삼각형 넓이의 정의이며 2번 공식이 기본식으로 나머지식들이 유도된다. 유도되는 과정에서 코사인제2법칙, 정점과 직선사이의 거리, 직선의 방정식이 활용된다. 3번은 헤론의 공식이다.

위 출처의 6가지 공식을 정리해서 알고리즘에 적용할 수 있는 수학적 공식은 이렇게 된다.

삼각형의 한변의 길이와 높이를 알때 : 1번 공식

삼각형의 두변의 길이와 끼인각을 알때 : 2번 공식

삼각형의 세변의 길이를 알때 : 3번 공식

삼각형 세변의 좌표를 알때 : 6번 공식

내접원과 외접원의 반지름을 알아도 3번공식이 있기 때문에 꼭 4,5번 공식을 알고리즘에 활용할 이유는 적어보인다.

특히 삼각형 세변의 좌표를 알때가 많이 사용될듯 한데 꼭지점중 하나를 원점으로 이동하여 삼각형을 평행이동시키면 넓이는 동일하기때문에 공식이 아래와 같이 간단해진다.

S = |(X1 * Y2) - (X2 * Y1)|/2

이를 자바로 구현해보면 아래와 같다.

입력 : X1 Y1 X2 Y2 X3 Y3 의 좌표를 공백으로 구분하여 한줄로 입력

import java.io.*;
import java.util.*;
public class Triangle {

 public static void main(String[] args) throws Exception{
  int o_x,o_y;
  int[][] dot = new int[3][2];
  float answer;

  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st = new StringTokenizer(br.readLine());

  for(int i=0;i<3;i++)
   for(int j=0;j<2;j++)
    dot[i][j] = Integer.parseInt(st.nextToken());

  o_x = dot[2][0]; // x3 
  o_y = dot[2][1]; // y3

  for(int i=0;i<3;i++) // 평행이동
   for(int j=0;j<2;j++){
    if (j==0)
     dot[i][j] -= o_x;
    else
     dot[i][j] -= o_y;
   }
  answer = (float)Math.abs((dot[0][0]*dot[1][1] - dot[1][0]*dot[0][1]))/2;
  System.out.println(answer);
 }
}

기본 사칙연산 이외에 나머지를 구하는 mod 연산자 % 가 여러 program language 에 많이 사용된다.

알고리즘을 보다가 (a+b)%c = (a%c+b%c)%c 가 맞는걸로 바로 넘어가서 저게 과연 맞는것일까 하는 의문이 들었다.

일단 mod 연산자에 대한 분배법칙은 성립하지 않는다.

즉, (a+b)%c != (a%c + b%c) 이다.

하지만 (a+b)%c = (a%c+b%c)%c 은 성립한다. 이를 입증할 수 있는 간단한 증명을 메모해둔다.

 증명대상 : (a+b)%c = (a%c+b%c)%c
 A = kc + n
 B = k'c + n' 로 치환한다.
 위 치환식을 좌우에 대입
 (kc+n + k'c + n')%c = ((kc+n)%c + (k'c+n')%c)%c
  (k+k') = m 로 정의하고 (XZ + Y)%Z = Y%Z 이므로 (mc + n + n')%c = (n+n')%c 이 성립한다.

단순 부분 문자열 찾기

import java.io.*;
public class Findsubstring {

 public static void main(String[] args) throws Exception{
  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  String A = br.readLine();
  String B = br.readLine();
  
  br.close();
  int num=0;
  String ans="";
  
  for(int i=0;i<=A.length()-B.length();i++){
   if (B.equals(A.subSequence(i,B.length()+i))){
    num++;
    if ("".equals(ans))
     ans = ans + Integer.toString(i+1);
    else
     ans = ans+" "+ Integer.toString(i+1);
   }
  }
  System.out.println(num);
  System.out.println(ans);
 }
}

입력

ABAABCCA
AA

출력

1
3

입력

AAAA
AA

출력

3
1 2 3

반복문 for

public class Multiply {
 public static void main(String[] args){
//  for(초기값;반복횟수조건;카운터증가)
  for(int j=1; j<=9; j++)
   for(int i=1; i <=9; i++)
    System.out.println(j + "X" + i +"="+ j*i );    
 }
}
구구단 출력

반복문 while

public class Sum {
 public static void main (String[] args){
  int s = 0, i = 0;
//  while 의 값이 참일경우 계속해서 반복수행한다. 항상 조건이 참일경우 무한히 실행되는 무한루프에 빠지지 않도록 주의해야합니다.
  while(i<10){
   i++;
   s = s + i;
  };
  System.out.println("1에서 "+ i + "까지의 합은 " + s);
 }
}

반복중단

(라벨을 이용한 break 가능)

public class Break {
 public static void main(String[] args){
  int a, b = 1;
  
  for(a = 0; a < 4; a++) {
   if(a + b == 2) {
//    break를 만날경우 가장 가까운 반복문의 끝으로 이동합니다.
//    break;
//    continue 를 만날경우 가장 가까운 반복문의 시작으로 이동합니다.
    continue;    
   }

   System.out.println(a + "+" + b + "=" + (a+b));
  }  
 }
}

이 내용은 ANK Co.,Ltd. 저 김성훈 역의 Java가 보이는 그림책에서 요약 발췌하였습니다.

제어문 if

public class Rank {
 public static void main(String[] args){
  int num = 1234;
  System.out.print(num+"은");
//  if 와 else if, else 로 제어문을 만들 수 있습니다.
  if( 0 <= num && num <= 9)
   System.out.println("1자리 수");
  else if( 10 <= num && num <= 99)
   System.out.println("2자리 수");
  else if( 100 <= num && num <= 999)
   System.out.println("3자리 수");
  else
   System.out.println("4자리 수");
 }
}

public class Score {
 public static void main(String[] args){
  int s = 65;

  System.out.println("당신의 점수는 "+s+"점입니다.");
//  if  문은 중첩해서 사용할수 있습니다. 이를 nest라고 합니다.
  if(s<70){
   if(s==100)
    System.out.println("최고입니다");
   else
    System.out.println("평균까지앞으로 "+(70-s) + "점");
  }
  else
  {
   System.out.println("잘했습니다");
  }
 }
}

제어문 switch

public class Select {
 public static void main(String[] args){
  for(int a = 5; a <= 8; a++){
   System.out.println(a + " / 3 = " + a/3);
//   여러개의 선택지중 맞는것을 비교할때 switch 를 사용합니다. 맞는것이 없을경우 default 가 수행됩니다.
   switch(a%3){
   case 1:
    System.out.println(" : 나머지는 1 입니다.");
    break;
   case 2:
    System.out.println(" : 나머지는 2 입니다.");
    break;
   default :
    System.out.println(" : 나머지는 0입니다.");
    break;
   }
  }
 } 
}

이 내용은 ANK Co.,Ltd. 저 김성훈 역의 Java가 보이는 그림책에서 요약 발췌하였습니다.

논리연산자

public class Compare {
 public static void main(String[] args){
  int a = 1, b = 2;
  
//  비교연산자의 결과는 참과 거짓 true , false 로 나타낸다
  System.out.println("a = " + a + " b = " + b);
  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));
 }
}
 

public class Or {
 public static void main(String[] args){
  int a = 1, b = 2;
  boolean x, y;
  
  x = (a < 0);
  y = (b > 0);
//  && 는 AND 로 교집합을 의미하고 || 는 OR 로 합집합을 의미하며
//  !는 NOT 으로 여집합을 의미합니다.
  System.out.println((a == 1) && (b == 1));
  System.out.println(x || y);  
 }
}

public class Truth {
 public static void main(String[] args){
  String right = "맞음", wrong = "틀림";
  boolean value;
  
  value = true;
//  ? : 조건연산자는 ? 앞의 조건식이 true일경우 : 왼쪽 선택, false일경우 : 오른쪽선택을 합니다.
  String answer = value ? right : wrong;
  System.out.println(answer);
  
  value = false;
  answer = value ? right : wrong;
  System.out.println(answer);
 } 
}

이 내용은 ANK Co.,Ltd. 저 김성훈 역의 Java가 보이는 그림책에서 요약 발췌하였습니다.

기본 연산자

public class Calculation {
// 기본산술이 가능합니다.
 public static void main(String[] args){
  System.out.println("2+2는 " + (2+2) + "입니다.");
  System.out.println("2-2는 " + (2-2) + "입니다.");
  System.out.println("2x2는 " + (2*2) + "입니다.");
  System.out.println("2/2는 " + (2/2) + "입니다.");
  System.out.println("2/2의 나머지는 " + (2%2) + "입니다.");
  
  int a = 0;
  a = a + 1;
  System.out.println(a);
//  아래와 같이 단축표현이 가능합니다. a = a+1; 과 같습니다. +=,-=,*=,/=,%= 가 있습니다.
  a += 1;  
  System.out.println(a);
 }
}

결과

2+2는 4입니다.
2-2는 0입니다.
2x2는 4입니다.
2/2는 1입니다.
2/2의 나머지는 0입니다.
1
2

public class Position {
 public static void main(String[] args){
//  값을 1 증가시키는 증가 연산자
  int a = 1, b = 1;
  System.out.println("전치일 경우 " + ++a );
  System.out.println("후치일 경우 " + b++);
  System.out.println(b);
  
//  값을 1 감소시키는 감소 연산자
  System.out.println("전치일 경우 " + --a );
  System.out.println("후치일 경우 " + b--);
  System.out.println(b);  
 }
}

결과

전치일 경우 2
후치일 경우 1
2
전치일 경우 1
후치일 경우 2
1

public class Compare {
 public static void main(String[] args){
  int a = 1, b = 2;
  
//  비교연산자의 결과는 참과 거짓 true , false 로 나타낸다
  System.out.println("a = " + a + " b = " + b);
  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 = 1 b = 2
a < b... true
a > b... false
a == b... false
a = b... 2

public class Cast {
 public static void main(String[] args){
  System.out.println("3 / 2 = " + 3/2);
  System.out.println("3.0 / 2.0 = " + 3.0/2.0);
  System.out.println("3 / 2.0 = " + 3/2.0);
  System.out.println("3.0 / 2 = " + 3.0/2);
//  자료형을 ()로 명시하여 강제로 변환하는 것을 캐스트라고 합니다.
  System.out.println("3 / 2 = " + (float)(3/2));
  System.out.println("3 / 2 = " + 3/(float)2);
 }
}

결과

3 / 2 = 1
3.0 / 2.0 = 1.5
3 / 2.0 = 1.5
3.0 / 2 = 1.5
3 / 2 = 1.0
3 / 2 = 1.5

이 내용은 ANK Co.,Ltd. 저 김성훈 역의 Java가 보이는 그림책에서 요약 발췌하였습니다.

다차원 배열

public class Number1 {
 public static void main(String[] args){
//  다차원 배열 선언이 가능합니다. X,Y,Z ... 계속해서 확장 가능합니다.
  int [][] a = { {1,2},{3,4},{5,6} };
  
  System.out.println("a[0][0]= " + a[0][0] + " a[0][1]" + a[0][1]);
  System.out.println("a[1][0]= " + a[1][0] + " a[1][1]" + a[1][1]);
  System.out.println("a[2][0]= " + a[2][0] + " a[2][1]" + a[2][1]);
 }
}

public class Number2 {
 public static void main(String[] args){
//  각 차원의 배열수를 자유롭게 설정할 수 있습니다.
  int [][] a = {{1,2},{3,4,5},{6,7,8,9}};
  
  System.out.println("X차원 수 " +a.length );
  System.out.println("a[0]의 수 " +a[0].length );
  System.out.println("a[1]의 수 " +a[1].length );
  System.out.println("a[2]의 수 " +a[2].length );
 }
}

이 내용은 ANK Co.,Ltd. 저 김성훈 역의 Java가 보이는 그림책에서 요약 발췌하였습니다.

배열

public class Number0 {
 public static void main(String[] args){
//  배열은 복수의 동일한 타입을 묶어 놓은 것. 배열의 선언은 new 연산자를 이용합니다.
//  int[] a 라고 할수도 있고 int a[]라고 할 수도 있습니다.
  int [] c = new int [4];
//  선언과 동시에 초기화도 가능합니다. 이때는 배열의 크기를 기술하지 않습니다.
  int b[] = new int[] { 1, 2, 3, 4 };
//  이렇게 생략이 가능합니다.
  int[] a = {1,2,3,4};
  System.out.println(a[0]);
  System.out.println(a[1]);
  System.out.println(a[2]);
  System.out.println(a[3]);  
  
 }
}

이 내용은 ANK Co.,Ltd. 저 김성훈 역의 Java가 보이는 그림책에서 요약 발췌하였습니다.