jmap -dump:format=b,file=heapdump.hprof 14434

개요

Java 어플리케이션을 배포하는 새로운 방식인 JNLP 를 테스트 해 보도록 한다.

테스트 프로그램

<DayTime.java>

package net.cranix.daytime.model;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;

public class DayTime {
    /**
     * DayTime 서버로부터 결과를 받아서 돌려주는 함수
     * @param server
     * @return
     * @throws IOException
     * @throws UnknownHostException
     */
    public String getRemoteTime(String server) throws UnknownHostException, IOException {
        StringBuffer sb = new StringBuffer();
        BufferedReader br = null;
        try {
            Socket sock = new Socket(server,13);
            br = new BufferedReader(new InputStreamReader(sock.getInputStream()));
            String line = null;
            while((line = br.readLine()) != null) {
                sb.append(line).append("\n");
            }
        }
        finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString().trim();
    }

}

 

<MainFrame.java>

package net.cranix.daytime.view;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.net.UnknownHostException;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

import net.cranix.daytime.model.DayTime;

public class MainFrame extends JFrame {
    private JLabel label = null;
    private JButton closeBtn = null;
    private JButton reloadBtn = null;
    private DayTime model = null;
    public MainFrame(DayTime model) {
        super();
        this.model = model;
        init();
        updateTime();
    }
    public void updateTime() {
        try {
            label.setText(model.getRemoteTime("time.nist.gov"));
            pack();
        } catch (UnknownHostException e) {
            JOptionPane.showMessageDialog(this, e);
        } catch (IOException e) {
            JOptionPane.showMessageDialog(this, e);
        }
    }
    public void init() {
        // 이벤트 처리
        label = new JLabel("TimeLabel");
        reloadBtn = new JButton("Reload");
        reloadBtn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                updateTime();
            }
        });
        closeBtn = new JButton("Close");
        closeBtn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent arg0) {
                dispose();
            }
        });
        // 컴포넌트 배치
        JPanel btnPanel = new JPanel();
        btnPanel.add(reloadBtn,BorderLayout.EAST);
        btnPanel.add(closeBtn,BorderLayout.WEST);
        getContentPane().add(label,BorderLayout.CENTER);
        getContentPane().add(btnPanel,BorderLayout.SOUTH);
        // 프레임 설정
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("DayTime");
        setResizable(false);
    }
}

 

<Main.java>

package net.cranix.daytime;

import net.cranix.daytime.model.DayTime;
import net.cranix.daytime.view.MainFrame;

public class Main {
    public Main() {
        DayTime model = new DayTime();
        MainFrame view = new MainFrame(model);
        view.setVisible(true);

    }
    public static void main(String args[]) {
        new Main();
    }
}

 

JNLP XML 설정

<?xml version="1.0" encoding="UTF-8"?>
<jnlp spec="1.0+" codebase="file:///E:/cranix/workspace/DayTime">
    <information>
        <title>DayTime</title>
        <vendor>cranix</vendor>
        <homepage href="http://cranix.net" />
        <description>demo daytime</description>
        <offline-allowed/>
    </information>
    <security>
        <all-permissions/>
    </security>
    <resources>
        <j2se version="1.2+" />
        <jar href="DayTime.jar"/>
    </resources>
    <application-desc main-class="net.cranix.daytime.Main" />
</jnlp>

jar 파일 서명하기

keytool –genkey –keystore cranixKeystore –alias cranix

keytool –selfcert –alias cranix –keystore cranixKeystore

keytool –list –keystore cranixKeystore

jarsigner –keystore cranixKeystore DayTime.jar cranix

실행하기

생성한 jnlp 파일을 더블클릭

윈도우에서 JAVA 로 IP 주소 가지고 오는소스는 아래와 같다.

[code]try {
    ip = InetAddress.getLocalHost().getHostAddress();
   } catch (UnknownHostException e) {
    e.printStackTrace();
}[/code]

그러나 이것을 리눅스에서 쓴다면 127.0.0.1 즉 루프백 아이피 주소가 나오게 된다.
어떻게 해야할까?
구글링결과 아래와같은 결론을 얻었다.

[code]try {
    boolean isLoopBack = true;
    Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();
    while(en.hasMoreElements()) {
     NetworkInterface ni = en.nextElement();
     if (ni.isLoopback())
      continue;
     
     Enumeration<InetAddress> inetAddresses = ni.getInetAddresses();
     while(inetAddresses.hasMoreElements()) {
      InetAddress ia = inetAddresses.nextElement();
      if (ia.getHostAddress() != null && ia.getHostAddress().indexOf(".") != -1) {
       ip = ia.getHostAddress();
       isLoopBack = false;
       break;
      }
     }
     if (!isLoopBack)
      break;
    }
   } catch (SocketException e1) {
    e1.printStackTrace();
   }[/code]

NetworkInterface 라는 클래스를 이용하여 각 네트웍 인터페이스를 검색해서 알아내는 방법이다.
어찌되었건 이렇게 하면 윈도우건 리눅스건 돌아간다.
 
어째 자바스크립트가 된 기분이다.
이것은 자바의 철학인 WORA(Write Once Run Anyware) 를 위배한다.

앞으로 자바가 어떻게 발전할지는 모르겠지만 가장 기본적인 자바 철학은 지켜 주었으면 하는 바램이다.

connection pool 같이 성능에 지대한 영향을 미치는것들은 이런 유명라이브러리를 사용하여 만드는게 맞다고 본다. 일단 믿을수 있으니까.

그런데 문제는 apache 의 commons-dbcp 는 여러 컨테이너나 웹 프레임워크 상에서 지원하지만, 정작 그런 컨테이너나 프레임워크의 도움 없이는 사용하는방법을 몰랐었다.

나중에도 유용할꺼 같아서 네이버를 뒤져서 만들어봤다.

먼저 필요한 라이브러리를 받자.

1. commons-dbcp  --> http://commons.apache.org/dbcp/
2. commons-pool  -->  http://commons.apache.org/pool/

<ConnectionPool.java>

[code]package common.util;

import java.sql.Connection;
import java.sql.DriverManager;
import org.apache.commons.dbcp.ConnectionFactory;
import org.apache.commons.dbcp.DriverManagerConnectionFactory;
import org.apache.commons.dbcp.PoolableConnectionFactory;
import org.apache.commons.dbcp.PoolingDriver;
import org.apache.commons.pool.impl.GenericObjectPool;

public class ConnectionPool {
 private String driverName = null;

 private String poolingDriverClassName = "org.apache.commons.dbcp.PoolingDriver";
 private String poolUrl = "jdbc:apache:commons:dbcp:";

 public ConnectionPool(String driverName, String driverClassName,String dbUrl, String dbUserId, String dbUserPass) {
  this(driverName, driverClassName, dbUrl, dbUserId, dbUserPass, 30, 10,100, false, true);
 }

 public ConnectionPool(String driverName, String driverClassName,String dbUrl, String dbUserId, String dbUserPass, int maxActive,int maxIdle, int maxWait) {
  this(driverName, driverClassName, dbUrl, dbUserId, dbUserPass,maxActive, maxIdle, maxWait, false, true);
 }

 public ConnectionPool(String driverName, String driverClassName,String dbUrl, String dbUserId, String dbUserPass, int maxActive,int maxIdle, int maxWait, boolean isReadOnly, boolean isAutoCommit) {
  this.driverName = driverName;
  try {
   Class.forName(driverClassName);
   GenericObjectPool connectionPool = new GenericObjectPool(null);
   connectionPool.setMaxActive(maxActive);
   connectionPool.setMaxIdle(maxIdle);
   connectionPool.setMaxWait(maxWait);

   ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(dbUrl, dbUserId, dbUserPass);

   PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory, connectionPool, null, null, isReadOnly,isAutoCommit);
   Class.forName(poolingDriverClassName);

   PoolingDriver driver = (PoolingDriver) DriverManager.getDriver(poolUrl);

   driver.registerPool(driverName, connectionPool);
  } catch (Exception e) {
   throw new RuntimeException(e);
  }
 }

 public Connection getConnection() {
  Connection conn = null;
  try {
   conn = DriverManager.getConnection(poolUrl + driverName);
  } catch (Exception e) {
   throw new RuntimeException(e);
  }
  return conn;
 }
}[/code]
이제 클래스 생성하고 getConnection() 을 호출하면 connection pool 에 의해 얻어진 connection 을 쓸 수 있다.

1. rpc 란?

xmlrpc 를 알아보기전에 먼저 rpc 를 알아보자.
rpc 란 Remote Procedure Call 의 약자로 말그대로 원격지에 있는 Procedure 를 호출하는 기능을 말한다.

2. xmlrpc 란?

xmlrpc란  xml과 http 프로토콜을 바탕으로 만들어진 원격 프로시저 콜 시스템 이다.
다른 컴퓨터와 주고받을수 있는 여러 프로토콜이 있지만 방화벽이나 기타 사정으로 제약을 받는 프로토콜들이 많다. 그중 가장 유연한 프로토콜이 http 프로토콜 이다. 바로 이 http 를 이용하여 xml 형태로 데이터를 간단하게 주고 받을수 있는것이 xmlrpc 이다.

3. 준비사항

오늘 만들어볼것은 xmlrpc 서버(단독서버,서블릿서버,서블릿단독서버), 클라이언트 이다.

먼저 apache 그룹에서 제공하는 xmlrpc 라이브러리를 다운받자.
http://ws.apache.org/xmlrpc/  - xmlrpc 3.1
3.1 버젼을 다운받도록 하자.
(이전 버젼을 사용해보지는 않았지만 만들면서 다른사람이 2.0 으로 만들어 놓은 예제에 3.1 라이브러리를 임포트 시켰더니 오류가 나는것을 봤을때 호환되지 않는거 같다.)

다음은 xmlrpc 라이브러리 실행에 필요한 라이브러리인데 xmlrpc 홈페이지 어디에도 이같은 라이브러리가 필요하다고 명시되어있지 않아서 삽질좀 했다.-_-;
아래 두 라이브러리를 다운받자
http://hc.apache.org  - commons-httpclient 3.1
http://commons.apache.org/codec/ - commons-codec 1.3

이제 이클립스를 켜고 다이나믹 웹 프로젝트를 생성한다음
WebContents/lib 디렉토리에 모든 라이브러리를 넣는다.

4. 서버만들기

서버는 3가지 형태로 만들수 있다.

1) 단독서버형 - 이것은 톰켓의 도움없이 단독으로 실행해서 xmlrpc 서비스를 해 줄수있는 서버이다.
 
2) 서블릿서버형 - 이것은 톰켓의 서블릿에 추가해서 서비스 해 줄수있는 서버이다. 내가 생각하기에 이것이 가장 많이 쓰이는방법 일 거같다.

3) 서블릿단독서버형 - 이것은 1번과 2번을 합쳐놓은것인데 2번을 만들어 놓고 톰켓을 실행하지 않은상태에서 xmlrpc 만을 실행해서 서비스 해 줄수있는 방법이다.

- 먼저 서비스해줄 프로시저를 만들자.
<Calculator.java>

[code]package test;
public class Calculator {
 public int add(int i1, int i2) {
  return i1 + i2;
 }
public int subtract(int i1, int i2) {
  return i1 - i2;
 }
}[/code]

- 그리고 서비스 해 줄 프로시저를 xmlrpc 라이브러리에 알려주기 위해 프로퍼티 파일을 만들자.
- 이 파일은 기본적으로 "org/apache/xmlrpc/webserver/XmlRpcServlet.properties" 디렉토리에 파일명 그대로 위치시켜야 한다.
- 이 파일의 디렉토리와 파일명은 XmlRpcServlet 클래스의 newXmlRpcHandlerMapping 메소드를 오버라이드 해서 변경할수 있지만 이렇게 구지 고정시켜 놓은 이유는 서블릿단독서버형 으로 실행할수 있도록 만들기 위해서이다.
<XmlRpcServlet.properties>

[code]Calculator=test.Calculator[/code]

4-1) 단독서버형
<StandaloneServer.java>

[code]package test;
import org.apache.xmlrpc.server.PropertyHandlerMapping;
import org.apache.xmlrpc.server.XmlRpcServer;
import org.apache.xmlrpc.server.XmlRpcServerConfigImpl;
import org.apache.xmlrpc.webserver.WebServer;
public class StandaloneServer {
 private static final int port = 8080;

 public static void main(String[] args) throws Exception {
   WebServer webServer = new WebServer(port);

   XmlRpcServer xmlRpcServer = webServer.getXmlRpcServer();

   PropertyHandlerMapping phm = new PropertyHandlerMapping();
  /* Load handler definitions from a property file.
   * The property file might look like:
   *   Calculator=org.apache.xmlrpc.demo.Calculator
   *   org.apache.xmlrpc.demo.proxy.Adder=org.apache.xmlrpc.demo.proxy.AdderImpl
   */
  phm.load(Thread.currentThread().getContextClassLoader(),"org/apache/xmlrpc/webserver/XmlRpcServlet.properties");

  /* You may also provide the handler classes directly,
   * like this:
   * phm.addHandler("Calculator",
   *     org.apache.xmlrpc.demo.Calculator.class);
   * phm.addHandler(org.apache.xmlrpc.demo.proxy.Adder.class.getName(),
   *     org.apache.xmlrpc.demo.proxy.AdderImpl.class);
   */
  xmlRpcServer.setHandlerMapping(phm);

  XmlRpcServerConfigImpl serverConfig = (XmlRpcServerConfigImpl) xmlRpcServer.getConfig();
  serverConfig.setEnabledForExtensions(true);
  serverConfig.setContentLengthOptional(false);

   webServer.start();
 }
}[/code]

- 애플리케이션으로 실행하면 xmlrpc 서비스 주소는 http://127.0.0.1:8080 이 된다.


4-2) 서블릿서버형
- servlet 클래스를 따로 만드는게 아니라 제공되는 클래스를만 끌어다 쓰면 바로 설정된다. 단 properties 파일은 제위치에 있어야 한다.
- web.xml 파일에 아래 설정을 추가한다.
<web.xml>

[code]<servlet>
  <servlet-name>XmlRpcServlet</servlet-name>
  <servlet-class>org.apache.xmlrpc.webserver.XmlRpcServlet</servlet-class>
        <init-param>
          <param-name>enabledForExtensions</param-name>
          <param-value>true</param-value>
        </init-param>
</servlet>
<servlet-mapping>
        <servlet-name>XmlRpcServlet</servlet-name>
        <url-pattern>/xmlrpc</url-pattern>
</servlet-mapping>[/code]

- 톰켓을 실행하면 xmlrpc 서비스주소는 http://[톰켓서버]:[톰켓포트]/[톰켓어플리케이션]/xmlrpc 가 된다.



4-3) 서블릿단독서버형
  -> 이것은 4-2 가 셋팅되어있어야지 실행할 수 있다.
<ServletStandaloneServer.java>

[code]package test;

import org.apache.xmlrpc.webserver.ServletWebServer;
import org.apache.xmlrpc.webserver.XmlRpcServlet;

public class ServletStandaloneServer {
    private static final int port = 8080;

    public static void main(String[] args) throws Exception {
        XmlRpcServlet servlet = new XmlRpcServlet();
        ServletWebServer webServer = new ServletWebServer(servlet, port);
        webServer.start();
    }
}[/code]

- 애플리케이션으로 실행하면 xmlrpc 서비스 주소는 http://127.0.0.1:8080 이 된다.


5. 클라이언트만들기

위의 서버들이 제대로 작동한다면 xmlrpc 서비스 주소를 얻을수 있을것이다.
이제 이 주소만 있으면 인터넷이 되는 어디서든 내 서비스를 받을수 있게 되는것이다.

- 클라이언트파일만들기
<Client.java>

[code]package test;

import java.net.URL;

import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;

public class Client {
 public static void main(String[] args) throws Exception {
  // create configuration
  XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
  config.setServerURL(new URL("http://127.0.0.1:8080/XMLRPCTest/xmlrpc"));
  config.setEnabledForExtensions(true);
  config.setConnectionTimeout(60 * 1000);
  config.setReplyTimeout(60 * 1000);

  XmlRpcClient client = new XmlRpcClient();

  // set configuration
  client.setConfig(config);

  // make the a regular call
  Object[] params = new Object[] { new Integer(2), new Integer(3) };
  Integer result = (Integer) client.execute("Calculator.add", params);
  System.out.println("2 + 3 = " + result);

 }
}[/code]

6. 실행

이제 위 세가지 서버중에 하나를 띄우고 클라이언트를 실행하면 아래와같이 원하는 결과가 나오는것을 확인할수 있습니다.

annotation 한글로 읽으면 어노테이션 사전적 의미로는 "주석" 이다.

주석은 이미 있지않은가?

이게 java5 에 왜 추가가되었을까?

뭐..좀더 확장된 개념의 주석이라고 보면되겠다.

기존의 주석과 달라진점은 프로그램상에서 처리가 가능하다는것이다.

주석을 프로그램상에서 처리할일이 뭐가있지? 라고 생각은 했는데..

아래예제와같이 테스트프로그램 같은데서 쓰일수 있다.

먼저 어노테이션 사용법을 알아보자

1. 먼저 어노테이션 인터페이스를 선언하자

- maker.java

package cranix.test;
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
public @interface maker {
int num();
String name();
String id();
String date() default "unsigned";
}

- 위에서 주석이라고 했지만 class 형태로 만들어진다.

- 어노테이션은 인터페이스에만 선언이 가능하다.

- @Retention(RetentionPolicy.RUNTIME) : 이 어노테이션을 쓰게되면 정보를 CLASS 파일에 저장하도록 한다. (이래야지만 파싱할수 있다.)

- 어노테이션의 선언은 @interface 로 하면된다.

- 메소드들의 내용은 올수없고 형태만 올수있다.

- default 가 찍히지 않은 메소드는 필수로 입력해야 한다.

2. 자 이제 위에서 만든 어노테이션을 사용해 보자

AnnotationCopyright.java

package cranix.test;
import java.lang.annotation.*;

@maker(
num=1,
name="정의돈",
id="cranix"
)
public class AnnotationCopyright {
public static void main(String args[]) {
for (Annotation a: AnnotationCopyright.class.getAnnotations()) {
  System.out.println("Annotation : " + a);
}
}
}

- class.getAnnotations() 와 같이 어노테이션을 파싱할수 있다.

- 물론 어노테이션 인터페이스에서 @Retention(RetentionPolicy.RUNTIME) 를 선언해 줘야지만 가능하다

3. 이제 위엣걸 실행시켜 보자

Annotation : @cranix.test.maker(date=unsigned, num=1, name=정의돈, id=cranix)

- @ 하나는 하나의 어노테이션이니까 루프를 한번만 도는거다.

이제 annotation을 이용해서 jUnit 과 비스무리한 초간단 테스트 프로그램을 만들어 보겠다.

1. 어노테이션 인터페이스를 만들어준다.

- Test.java

package cranix.test.annotation;
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Test {}

2. 테스트할 프로그램을 만든다.

- TestClass.java

package cranix.test;
import cranix.test.annotation.*;

public class TestClass {
@Test public static void m1() {}
public static void m2() {}
@Test public static void m3() {
throw new RuntimeException("런타임 익셉션");
}
public static void m4() {}
@Test public static void m5() {}
@Test public static void m6() throws Exception {
throw new Exception("엑셉션");
}
public static void m7() {}


public static void main(String args[]) throws Exception {
AnnotationTest.test(TestClass.class);
}
}

- 어노테이션이 들어간것이 보이는가?

- 테스트를 원하는 메소드 앞에 @Test 라는 어노테이션을 선언해 주자.

3. 이제 어노테이션이 들어간 클래스를 파싱해서 테스트 해보도록 하자

- AnnotationTest.java

package cranix.test.annotation;
import java.lang.reflect.*;

public class AnnotationTest {
public static void test(Class clazz) throws Exception {
int passed = 0;
int faild = 0;
for (Method m: clazz.getMethods()) {
  if (m.isAnnotationPresent(Test.class)) {
   try {
    m.invoke(null);
    passed++;
   }
   catch(Throwable e) {
    System.out.printf("%s 메소드에서 테스트실패 - 이유 : %s\n",m,e.getCause());
    faild++;
   }
  }
}
System.out.printf("테스트 종료 - 성공 : %d, 실패 : %d\n",passed,faild);  
}
}

- m.isAnnotationPresent(Test.class) 라는것은 메소드가 Test.class 어노테이션을 받고있는것인가 검사하는 것이다.

- 이렇게 하면 @Test 어노테이션을 받고있는 메소드만 테스트를 수행하게 되는것이다.

4. 실행을 하면 아래와같이 나온다.

public static void cranix.test.TestClass.m3() 메소드에서 테스트실패 - 이유 : java.lang.RuntimeException: 런타임 익셉션
public static void cranix.test.TestClass.m6() throws java.lang.Exception 메소드에서 테스트실패 - 이유 : java.lang.Exception: 엑셉션
테스트 종료 - 성공 : 2, 실패 : 2

- 이런 멍청한 테스트 프로그램을 쓰지는 않겠지만 충분히 응용가능하다고 본다.

자 이제까지 간단하게 어노테이션을 알아봤다.

jUnit,EJB3 에서도 어노테이션을 쓴다고 한다.

EJB3 는 안써봐서 모르겠고 jUnit 은 충분히 이해할만 하다.

자바 프로그래밍의 개념이 조금 확장된것이 느껴지지 않는가?

java5 로 넘어오면서 많이 바꼈는데 가장 맘에드는건 저너릭스와 enum 타입이 생긴것이다.

annotation 은 어떤곳에 써야할지 아직은 감이 안잡힌다.

1. static 멤버 import 하기

  - static import 를 사용하면 클래스명을 안쓰고 static 멤버변수와 static 메소드에 접근할수 있다.

import static java.lang.Math.*;

public class StaticImportTest {
public static void main(String args[]) {
double y = sin(1.2);
System.out.println("SIN(1.2) : " + y);
System.out.println("PI : " + PI);
}
}

2. Eunumerated 타입

  - c 언어의 enum 타입처럼 자동으로 숫자를 매겨주는 변수를 만들수 있다

  - 이것과 관련해서 enumMap 이라는 클래스도 있다

public class EnumTest {
public enum testEnum {ITEM1,ITEM2,ITEM3};

public static void main(String args[]){
System.out.println(testEnum.ITEM1);
}
}

3. 새로운 for 문 형태

  - 자바스크립트의 for in 구문 같이 배열을 자동으로 탐색할수있다.

  - 단 for 문 안에서 꼭 String tmp 와 같은형태로 선언해야 한다는것은 좀 이상했다.

public class NewForTest {
public static void main(String args[]) {
String strs[] = {"test1","test2","test3"};
for (String tmp : strs) {
  System.out.println(tmp);
}
}
}

4. autoBoxing, autoUnBoxing

  - wrapper 클래스로 변환히 한층 더 자유로워졌다.

public class AutoBoxingTest {
public static void main(String args[]) {
Integer i = 10;
int i2 = i;

System.out.println("I:" + i2);
}
}

5. c언어의 printf 와 유사한기능 추가

  - . 뒤에있는것이 소숫점이하 자릿수가 아니라 전체 자릿수이다.

public class PrintfTest {
public static void main(String args[]) {
double PI = 3.141592;
System.out.printf("%7.3g",PI);
}
}

6. 가변 파라메터(varargs)를 갖는 메소드

  - 이건 왜 이제야 지원하는지 의심스럽다.

public class VarargsTest {
public static int sum(int... data) {
int total = 0;
for (int n : data) {
  total += n;
}
return total;
}
public static void main(String args[]) {
int total = sum(1,2,3,4,5,6,7,8,9,10);
System.out.println("SUM : " + total);
}
}

7. 저너릭스(generics)

  - 이제 클래스 생성할때 리턴 타입도 지정받을수 있게 됬다.

  - 아래 예제를 보면 알겠지만 클래스를 만들때 리턴 타입까지 고려해서 만들수가 있게되었다.

class MyMemory<M> {
private int size = 0;
private Object objects[];

public MyMemory(int size) {
this.size = size;
objects = new Object[size];
}

public M get(int i) {
return (M)objects[i];
}
public void put(int i,M obj) {
objects[i] = obj;
}
public int getSize() {
return size;
}
}

public class GenericsTest {
public static void main(String args[]) {
MyMemory<String> mem = new MyMemory<String>(10);
mem.put(1, "test");
mem.put(2, "test2");
mem.put(3, "test3");
System.out.println(mem.get(1));
System.out.println(mem.get(2));
System.out.println(mem.get(3));
}
}

8. 주석(annotation)

  - 이놈은 좀 길기때문에 다음회에 연재하겠다.