JAVA basic grammar (자바 기본 문법)
JAVA 기본 실행 class
public class Hello
{
public static main(String[] args)
{
}
}class 정의 방법
public class A
{
}
class B
{
}
주석
1. JAVA DOC 형태
html file로 주석을 저장
/** ~~~ */ 주석 생성 (html file로)
javadoc test.java -> test.html file 생성
2. 그냥 주석
/* ~~~ */
//
자바 식별자 규칙과 관례
identifier
: 변수나 상수, 메소드, class등을 이름 짓는 것
ex. index, _Variable, Test100, $var, 이름 <- 가능
3_grade, class, this, #abc <- 불가능 (특수 문자는 _와 $만 가능)
관례
class, interface의 첫 번째 이름은 항상 대문자
클래스 이름은 noun
변수 명, method 명
첫 번째 문자는 항상 소문자
getName(), getPointSize(), name, age, deptName
상수 이름 관례
상수는 모두 대문자 (단어 사이는 _ 로 연결)
ex. MAX_VALUE
참조형 상수는
대/소문자 모두 사용
black, darkGray, UndefinedProperty
JAVA keyword list
abstract, assert, boolean, break, byte, case, catch
char, class, continue, default, do, double
else, extends, false, final, finally, float, for, goto, if
implements, import, instanceof, int, interface
length, long, native, new, null, package, private,
protected, public, return, short, static, super, switch,
synchronized, this, throw, throws, transient, true, try,
void, volatile, while
특이한 것
abstract, extends, final, finally, implements, import, instanceof, interface
native, package, super, synchronized, throws, transient
const, goto는 현재 JAVA에서 keyword가 아님
TRUE, FALSE, NULL도 아님
sizeof도 아님
자바의 기본형 변수
변수를 선언하면, JVM이 메모리를 할당
메모리 구조
class area <- JAVA의 method, code, constant
stack area <- local variables
heap area <- stack 영역의 변수가 참조형 일때, 참조형 변수가 참조하는 실제 값을 저장하는 영역
primitive type
boolean, char, byte, short, int, long, float, double
JAVA에서 double은 64 bits
reference data type
메모리의 크기가 고정되지 않고 가변적인 데이터
new operation을 사용해서 동적으로 heap 영역에 데이터를 할당하고 주소 값을 참조하여 사용.
class TestVar {
public static void main(String[] args){
String msg; // only declaration
msg = new String("~~~"); // must be executed for memory allocation
String msg2 = new String("~~");
String msg3 = "~~"; // literal 만으로도 object가 생성 (String은 unicode 사용 - 2 bytes per char)
}
}
자바의 참조형 변수는 메모리의 주소값을 갖기에 pointer와 유사하나, C의 pointer와는 달리 산술 연산이 불가능하다.
(즉, const pointer인 셈이다)
JAVA의 primitive 변수 size는 platform에 independent하다. (늘 동일하다)
boolean b-bit true/false
char 16-bit unicode '\u0000' ~ '\uffff'
byte 8-bit signed integer -127 ~ 127
short 16-bit signed integer -32768 ~ 32767
int 32-bit signed integer -21억 ~ 21억 (-2^31 ~ 2^31 - 1)
long 64-bit signed integer -920해 ~ 920해 (-2^63 ~ 2^63-1)
float 32-bit signed floating point 1.4E-45 ~ 3.4028235E38
double 64-bit signed floating point 4.9E-324 ~ 1.7976931348623157E308
JAVA API에는 primitive type에 대한 wrapper class들이 있다.
이를 사용하여 데이터 type의 maximum value와 minimum value를 query할 수 있다.
ex.
byte type : Byte.MAX_VALUE
char ch1 = '\n'; // new line
char ch2 = '\r'; // carriage return
char ch3 = '\t'; // tab
char ch4 = '\u88ab' // unicode
char ch5 = 'a';
\u 뒤에는 2-byte UNICODE값 즉, 4자리의 16 진수가 올 수 있다.
double doubleVal = 1.34e10;
double doubleVal2= 0.2d;
double doubleVal3= 0.3D;
float floatVal1 = 3.14E5F;
float floatVal2 = 0.2f;
f or F 가 없으면 double로 사용.
lonb longVal = 1L; // L or l
long longVal2= 076L; // 8 진수
long longVal3= 0x1234L; // 16 진후
ex.
public class PrimitiveDataTest {
public static void main(String[] args)
{
boolean b;
long l = 10L;
float f = 3.14f;
char c;
c = 'a';
b = true;
System.out.println(" booelan b = " + b);
System.out.println(" long l = " + l);
System.out.println(" char c = " + c);
System.out.println(" float f = " + f);
}
}
자바의 연산자
type cast
float f = 0.1f;
int i = (int)f;
// (data_type) 이 방식은 boolean 은 안됨.
자동 형변환 - wide cast
명시적형변환 - shorten cast
자동 형변환의 예
byte b = 10l
int i = b;
byte -> short -> int -> long -> float -> double
char -> int -> long -> float -> double
산술 연산자
++val
val++
--val
val--
는 test를 해 보자.
++val과 val++의 순서가 C와는 반대
비교 연산자
instanceof
val1 instanceof val2 <-- val1이 val2의 객체인 경우 true
ex.
String str1 = new String("~~");
if (str1 instanceof String)
{
// str1이 String type instance이면 true
}
expressionA && expressionB
// expressionA가 false면 B의 조건을 검사하지 않고 out
expressionA || expressionB
// expressionA가 true면 B의 조건을 검사하지 않고 in
그러나
expressionA & expressionB
// 이 경우는 둘 다 계산을 수행 (bit 연산 이므로)
if ((s != null) && (s.length() > 0))
{
....
}
이 경우
if ((s != null) & (s.length() > 0))
{
}
이와같이 작성하게 되면, s가 null인 경우 s.length()를 수행하여 exception 발생
bit operation
>>> val1 >>> val2 : val1을 val2 만큼 우측으로 shift하고 왼쪽에는 0이 채워짐
삼항 연산자
expression ? true시 : false시;
* 연산자 우선순위
-----------------
+-------------------------------------+
| 1 () [] . |
+-------------------------------------+
| 2 ++ -- ~! (data_type) |
+-------------------------------------+
| 3 * / % |
+-------------------------------------+
| 4 + - |
+-------------------------------------+
| 5 >> >>> << |
+-------------------------------------+
| 6 > >= < <= |
+-------------------------------------+
| 7 == != |
+-------------------------------------+
| 8 & |
+-------------------------------------+
| 9 ^ |
+-------------------------------------+
| 10 | |
+-------------------------------------+
| 11 && |
+-------------------------------------+
| 12 || |
+-------------------------------------+
| 13 ?: |
+-------------------------------------+
| 14 =및 각종 축약된 대입 연산자 |
+-------------------------------------+
int table[][] = new int[10][10];
table.length 가능
table[0].length 가능
int 역시 class이며, 여러 operation을 지니고 있다.
break;
out_ter: for (int i = 0; i < 3; i++) // out_ter는 임의로 지정한 것
{
for (int j = 0; j < 2; j++)
{
if (i==2)
break out_ter;
System.out.println("i = " + i + ", j = " + + j);
}
}
배열 선언 방법
int intArray[];
double [] dArray;
String strArray[];
이후 = new type[size]; 를 수행해야 한다. (초기화에 바로 하는 것도 가능)
intArray = new int[5];
하고
intArray.length는 5이다. 개수임.
배열을 선언하면, 초기화 값이 자동으로 들어간다.
모두 0이며, boolean은 false이고, char는 '\u0000', float는 0.0f, double은 0.0d, long은 0L, 참조형 변수 type은 null이다.
int intArray[] = {10, 20, 30}; // 가능
String sArray[] = {"hello", "exam"};
ex.
final int k_nums = 5;
int [] numbers_1 = new int[5];
int numbers_2[] = new int[5];
for (int i = 0; i < k_nums; ++i) {
numbers_1[i] = i;
numbers_2[i] = i;
}
for (int i = 0; i < k_nums; ++i) {
print(numbers_1[i]);
print(numbers_2[i]);
}
다차원 배열
int twoDimArray[][] = new int[4][10];
int twoDim[][] = new int[4][];
twoDim[0] = new int[5];
twoDim[1] = new int[4];
..
즉, 2차원 배열이 동적인 길이를 지닐 수 있다.
JAVA class 내에는 main method가 반드시 정의 되어 있어야 한다.
main만큼은 예외적으로 객체의 일부로서 호출되지 않을 수 있다. (JVM에서 자동으로 호출하게 된다)
modifier
class, member variable, method 앞에 해당 class나 member variable, method들을 사용할 수 있는 권한을 지정하거나 활용 방법을 지정하는 몇 개의 keyword를 제공
이런 keyword가 modifier
modifier들은 public, protected, private, static, final, abstract 등이 있고, 각각의 의미가 있음
JAVA app.의 main method는 사용자가 정하는 것이 아니라 이미 정해져 있는 modifier를 사용하게 되어 있는데,
public과 static이라는 modifier가 사용된다.
main의 arg 사용 ex.
public static void main(String arg[])
{
for (int i = 0; i < arg.length; i++)
{
System.out.println("arg = " arg[i]);
}
}
java ArgTest param1 param2 <- 와 같이 실행 가능
위와 같이 실행하면, arg[] = {"param1", "param2"} 이런 식으로 저장된 상태가 된다.
연산자 casting
실수 + 실수 -> 실수
실수 + 정수 -> 실수
정수 + 실수 -> 실수
정수 + 정수 -> 정수
String + non-String(실수 혹은 정수) -> non-String을 String으로 자동 변환 한 후 문자열로 결합해 준다.
public static void main(String arg[])
{
int first = Integer.parseInt(arg[0]); // String을 int로 변경
double dVal = Double.parseDouble(arg[1]); // String을 double로 변경
}
switch
int genger = 0;
switch (gender) {
case 0:
// ...
break;
case 1:
// ...
break;
default:
break;
}
this
class Person {
}
class Student{
String name;
Student(String name)
{
this.name = name; // member를 access하는 this의 사용
}
Student()
{
this("none"); // this를 사용한 생성자 호출
// super(..); // super는 하위에서 상위의 생성자 호출 시 사용
}
}
package
관련 class와 interface들을 하나의 folder or directory에 적절히 배치 가능
=> 이것이 package
package는
충돌회피
관리 용이
access 권한을 package 단위로 제어
ex.
java.lang.Integer
java.io.FileInputStream
* import keyword
package화 된 class들을 사용하기 위한 예약어
(별도 지정 없을 시 default package 사용 - default는 현재 java source file이 위치한 같은 directory)
java.lang은 별도의 import를 안해도 사용 가능
ex.
import java.lang.Integer;
import java.io.FileInputStream;
import java.awt.*; // 하나의 package 내의 여러 class 사용 경우 *로 표현
ex.
Date d = new Date(); // Date는 java.util package 내의 api임. - package name의 언급이 없으므로 에러
-->
java.util.Date d = new java.util.Date();
그러나 위처럼 하면 귀찮으니..
import java.util.Date;
class..{
Date d = new Date();
}
ex.
import java.util.Date;
import java.util.ArrayList;
class..{
Date d = new Date();
ArrayList array = new ArrayList();
}
ex.
import java.util.*;
class..{
Date d = new Date();
ArrayList array = new ArrayList();
}
* package keyword
사용자가 작성한 클래스 package 화를 위함
연관성 있는 class들의 package 화
package package_name;
class class_name
{
}
public class class_name2 {
}
상속과 인터페이스
JAVA 언어에서는 class 선언부에 extends 키워드를 명시하지 않은 경우라도 java.lang.Object class를 자동으로 상속받게 된다.
class Student {
}
라고만 해도 Object class는 자동 상속
즉, 위 코드는
class Student extends Object {
}
와 같음
JAVA에서는 extends 다음에 다중 상속이 불가능하다.
멤버 변수의 상속
private < default(no modifier) < protected < public
상위의 메소드에 no modifier면, 하위는 public/private/protected 모두 선언 가능
상위 method가 public이면, 하위도 public으로만 가능
class Base {
void Method(int num1) throws IOException {}
}
class Drived extends Base {
public void Method(int num1) throws Exception <-- 에러 -- IOException 외에 다른 종류의 exception을 포함하여 error
{
}
}
final
final int VAL = 20; // constant 화
final class AClass {...} // final class는 하위로 subclassing 불가능
final method는 overriding이 불가능
abstract
class와 method에 사용
instance화 불가능
abstract method는 subclass에서 overriding해야 한다.
abstract class로 해야하는 경우
1) abstract method를 지닌 경우
2) 상위 class가 abstract method를 지녔는데, overriding 하지 않은 경우
3) interface를 상속받고 상위의 모든 method를 overriding 구현 하지 않은 경우
final과 abstract는 동시에 사용 불가능
interface
모든 method가 abstract method임
생성자 호출과 super keyword
class Base {
int memVar = 100;
int Method(int num)
{
}
}
class Drived extends Base
{
int memVar = 200;
public void Method(int memVar)
{
this.membVar = memVar;
super.Method(this.memVar);
System.out.println(super.memVar);
}
}
super는 객체를 의미하므로,
static member는 super를 사용할 수 없음
static class
public class Main {
...
static class Person { <- static이 아니면, static context에서는 non-static 변수인 this를 참조할 수 없음 에러
int m_age; static method이므로, this가 없어서
String m_name;
Person(int age, String name) {
m_age = age;
m_name = name;
}
}
public static void main(String[] args) {
...
Person person = new Person(30, "A");
}
}
객체의 형변환과 다형성
class Parent {}
class Child1 extends Parent{}
class Child2 extends Parent{}
Parent p;
Child1 c1 = new Child1(); p = c1; // 가능 (자동 형 변환 - super type의 원리)
Parent p = new Child1();
Child1 p = new Parent(); /// 에러
Child2 c2 = new Child1(); // 에러 (상속 관계 없기 때문)
Child2 c2 = (Child2)new Child1(); Parent p = new Parent();
Child c1;
c1 = (Child1)p; //// 에러만 안나고.. 잠재적 문제를 지님
class Employee {
int empBoune;
void calcSalary() { salary = base + empBonus; }
}
class Manager extends Employee {
int manBonus;
void setDept() { dept = "Manager"; }
}
Employee e1 = new Manager();
Manager man = (Manager)e1;
man.manBonus = 700; // 가능
man.setDept(); // 가능
그러나 불편하고, 좋지 않다. (잠재적 위험성)
instanceof 연산자를 사용하자.
void aMethod(Employee emp) {
if (emp instanceof Manager) { // 하위로 생성된 상위 reference 이면, (즉, 확인을 하자는 것)
Manager man = (Manager)emp;
man.setDept();
}
}
상위의 function을 하위에서 override하고, 상위의 reference로 하위를 가리킬때, override된 method를 call하면, 하위것이 호출됨 (virtual이 기본인 것)
Interface
멤버변수는 상수로 - public static final 변수만 포함
메소드는 abstract로 선언 - public abstract method만 포함
생성자 없음
즉, 객체생성 불가능
super 사용 불가능
abstract class는 부분적으로 완성된 미완성 설계도 <- abstract method와 implemented method 모두 포함 가능
interface class는 구현이 없는 blue print라고 할 수 있음
inetrface는 다중 상속 가능
ex.
interface Teachable
{
public final static String JOB = "teacher";
public abstract void teach();
}
인터페이스 내에서
public static final 혹은 public abstract등은 생략 가능 (interface가 알아서 추가해 줌)
interface Teachable {
String JOB = "~";
void teach();
}
interface Learnable {
String TASK = "~~";
void learn();
}
class PostGraduate implements Teachable, Leanable {
public void teach()
{
System.out.println("~~~");
}
public void learn()
{
System.out.println("~~~");
}
}
interface의 상속은 implements로 상속 (다중 상속 가능)
Teachable t = new PostGraduate();
t.teach(); // Teachable interface가 teach를 가지고 있기에 가능
t.learn(); // Teachabel interface가 learn을 가지고 있지 않기에 불가능 (에러) t instanceof Teachable <- 을 사용하여 형변환 type을 확인 가능
예외 처리
ex. 예외 상황
Object o = new Integer(100);
String s = (String)o; // Intergert type으로만 casting 가능 - 예외 발생
FileInputStream in = new FileInputStream("a.txt"); // file이 없으면 예외 발생
String s = null;
if (s.length() >= 0) {...} /// 예외
예외 class
Exception --> ClassNotFoundException
--> ClonNotSupportedException
--> InstantiationException
--> IOException
--> ...
--> RunttimeException
--> ArithmeticException
--> IllegalArgumentException
--> IndexOutOfBoundsException
...
--> ClassCastException
에외 발생 시,
JVM에 의해서 예외 객체 생성 전달
예외 처리 NO --> 예외 처리가 된 구문 수행
or
예외 처리 YES--> 에러 메시지를 화면에 출력하고 수행 정지
class ExceptionTest {
public static void main(String arg[])
{
int x[] = new int[4];
int i = 0;
while (true)
{
i = (int)(Math.random() * 10);
System.out.println("x[" + i + "] = " + x[i]); // 예외를 발생 시킴..0~3의 index가 아니면, 예외 처리 확인 위한 test 코드
}
}
}
예외 처리
try-catch
try
{
예외가 발생할 만한 코드 - 여기서는 out of bound exception test를 위해서 x[i] <-- i 값이 문제 있는 값일 수 있는 경우
}
catch (ArrayIndexOutOfBoundException e) // index에 벋어난 access를 하게 되면 이리로 온다.
{
예외처리 코드
}
catch (Exception e) // catch block은 나열된 순서대로 처리하게 된다.
{
나머지 예외 처리
}
finally 키워드
try-catch와 유사
try-catch는 예외 타입에 따라서 실행이 안 될수도 있음
finally block은 예외의 발생 여부와 관계없이 실행됨
try {
fd = FildOpen("test.txt");
fd.read();
}
catch (IOException e) {
....
}
finally { // finally block 다음에는 catch가 와도 소용 없음
CloseFile(fd);
} try {
fd = FildOpen("test.txt");
//fd.read();
return;
}
catch (IOException e) {
....
}
finally { // try block 내에 return이 있어도 finally block은 실행됨. (finally block을 실행하고 return 됨)
CloseFile(fd);
}
예외의 간접 처리
throws 키워드
메소드 내부의 예외를 다른 메소드로 전달
void method1(void)
{
...
try {
t.method2(args[0]);
}
catch ( notFoundException이 e ){
...
}
}
void method2(String name)
{
throws ClassNotFoundException {
Class.forName(name); // name 의 class가 존재하지 않으면 notFoundException이 발생하고 -> t.method2를 호출한 곳으로 notFoundException을 전달
...
}
}
public static void main (String args[]) throws ClassNotFoundException {.. <-- 기본 예외 처리기에 일임한다는 것
예외 처리를 안 하면 안되는 경우가 존재하며 이때 예외처리가 없다면, 에러 처리
예외 처리는
1) exception이 발생된 곳에서 try-catch를 사용
2) 예외가 발생한 메소드를 호출한 곳으로 예외를 넘기는 throws 처리
Exception의 종류
1) Exception class 상속 계열
ClassNotFoundException
ClonNotSupportedException
InstantiationException
IOException
예측 가능한 예외들이기에
compiler가 처리하기를 요구
2) Exception --> RuntimeException
--> ArithmeticException
--> IllegalArgumentException
--> IndexOutOfBoundsException
--> NullpointerException
프로그래머의 부주의로 발생할 수 있는 예외들이기에,
compiler에서 처리를 하지 않는다.
Multi-threading programming
java.lang.Thread class
java.lang.Thread <-- class
java.lang.Runnable <-- interface class
1. java.lang.Thread를 상속 받아서 thread를 구현하는 경우
1) Thread class의 상속
2) run() method를 overriding
3) 객체 생성
4) start() method를 호출하여 thread를 실행
class MyThread extends Thread {
public void run() {
...
}
}
class TestMyThread {
public static void main (String args[]) {
MyThread myThread = new MyThread();
myThread.start();
}
}
2. java.lang.Runnable interface
다른 상위 class를 상속 받으면서 multithread로 동작할 class를 정의한다면,
자바 언어의 한계로 인하여 다중 상속이 불가능하기에,
java.lang.Thread를 상속 받을 수 없음.
이 경우, java.lang.Runnable interface를 구현하는 방법으로 multi-thread를 구현
방법
1) Runnable interface를 구현하는 class를 정의
2) run() method를 overriding
3) 객체 생성
4) 위에서 생성한 객체를 Thread type의 객체로 casting
5) start()
ex.
class MyRunnable implements Runnable {
public void run()
{
...
while (1)
{
...
}
}
}
class TestMyRunnable {
public static void main (String args[])
{
MyRunnable myRunnable = new MyRunnable();
Thread athread = new Thread(myRunnable);
athread.start();
}
}
Thread 상태도와 Scheduling
JVM이 사용되는 Platform에 따라서 다름
new, start, ready, run, dead, suspend --> (waiting, sleeping, joining, blocked)
ready는 start()를 실행 시켰지만, OS에 의해서 아직 실행되지 못한 상태
suspend의 상태 4가지
- sleeping : 일정 시간 기다림
- waiting : notify() event를 기다림
- joining : JOIN된 다른 thread의 실행 완료를 기다림
- blocked : IO method등의 호출로 인하여 해당 메소드가 종료될 때까지 기다리는 상태
우선순의
1~10
기본은 5 (클수록 높음)
Thread
getPriority();
setPriority();
MIN_PRIORITY
NORM_PRIORITY
MAX_PRIORITY
Thread.sleep(1); // 1ms동안 sleep
join
어떤 thread의 join method를 호출하면, join을 호출한 thread는 실행시킨 어떤 thread의 동작의 종료까지 기다림
--> 어떤 thread의 동작 결과를 사용하고자 할때 사용될 수 있음
class JoinThread implements Runnable {
int i = 0;
public void run() {
try {
Thread.sleep(10);
i = 10;
}
catch (InterruptedException e) {
...
}
}
}
public class TestJoinThread {
pubilc static void main (String args[]) {
try {
JoinThread joinT = new JoinThread();
Thread thread = new Thread(joinT);
thread.start();
thread.join();
System.out.println(thread.i); // 여기서 thread의 i는 10의 값을 지님
}
catch (Exceptoin e<font style="background-color: #000000"></font>) {
...
}
}
}
Synchronized (동기화)
특정 시간에는 하나의 thread만 동작 시키고 싶은 경우 사용
어떤 thread가 synchronized라고 정의된 method를 사용 중일 때는, 다른 thread들이 종료를 기다림.
-> 하나의 class 내에서만..
class SyncThraed extends Thread {
public synchronized void syncFunc() { ... }
public void run()
{
syncFunc();
}
}
class TestSyncThread {
public static void main(String args[])
{
SyncThread t1 = new SyncThread();
SyncThread t2 = new SyncThread();
t1.start();
t2.start(); // t2의 syncFunc의 호출은 t1의 syncFunc의 호출이 완료 될 때까지 막힘 (동기화됨)
}
}
wait(), notify()
synchronized는 하나의 method 뿐만 아니라, 해당 class 내에서 여러 method에 대해서 사용 가능 (ex. send, receive method)
그러나 순서대로의 실행을 보장해 주지는 못함
순서대로 번갈아 실행을 시키고자 하면,
wait(), notify()로 처리
class MainBox {
public synchronized void storeMsg(String msg) {
while (m_waitCond == true) {
wait();
}
m_waitCond = true;
msg 처리
notify(); // waiting 상태의 thread를 ready 상태로 이동
}
public synchronized String SendMsg() {
while (m_waitCond == false) {
wait();
}
m_waitCond = false;
msg 처리
notify();
return msg;
}
}
java.lang package의 주요 class들
object class
equals()
toString()
모든 class의 최상위 class
extends java.lang.Object를 선언하지 않아도 기본적으로 상속받음
Object
equal : 두 객체가 같으면 true (== 로도 가능)
toString : 현재 객체의 문자열 표현 리턴
(class_name@object_code_value_as_16bit_hexa) <- ex. MyObject@c17164)
clone : object의 복사
finalize : gabage collection 직전에 객체의 resource 정리 시 호출
getClass : 객체의 class type return
hashCode : 객체의 코드 값 리턴
notify : wait 된 thread 실행 재개 시 호출
notifyAll : wait 된 모든 thread 실행 재개 시 호출
wait : 스레드 일시 중지 호출
wait(long) : 주어진 시간만큼 thread 일시 중지 시 호출
wait(lg,it) : 주어진 시간만큼 thread 일시 중지 시 호출 (lg는 long, it는 int)
System.out.println( <-- 여기에 object를 주면, toString method가 자동 호출되어 처리된다. )
String class
java.lang.String
한번 만들어진 String class 객체의 값은 변경 불가능
Wrapper class
Wrapper class
ex.
Integer class
int i = 10;
Ingeger.toBinaryString(i); ---> 1010
Integer.toHexString(i); --> A
Integer.toString(i); ---> 10
기본형 변수 type의 데이터를 다양한 연산이 가능하도록 유용한 method들을 모아 놓은 utility 형식의 class가 Wrapper class이다.
자바의 기본형 변수들은 모두 8가지,
각 기본형 변수에 대응되는 Wrapper class가 존재하므로, Wrapper class또한 8 종류가 제공
Wrapper class 이름 --- Primitive variable type
-----------------------------------------------
Boolean boolean
Character char
Byte byte
Short short
Integer int
Long long
Float float
Double double
Wrapper class로 객체를 생성하기
boolean b = true;
Boolean wb = new Boolean(b);
int i = 100;
Integer wi = new Integer(i);
위 과정이 J2SE 1.5 부터는 Auto-boxing에 의해서 아래와 같이 처리 가능
int i = 20;
Integer in = i;
자동으로 wrapper class type의 type-casting
Unboxing도 제공
Integer in = 20;
int val = in;
Integer arr [] = new Integer[3]; 도 가능
java.util package와 collection framework
SWING component와 Event 처리 programming
JFC(Java Foundation Class)는 AWT(Abstract Window Toolkit), SWING과 같은 자바 GUI programming API 임
SWING은 AWT와 유사한 기능을 수행하지만, AWT와는 달리 platform 마다 다른 interface를 제공
AWT는 OS에 따라서 실행되는 program의 모습이 차이를 보일 수 있음.
SWING component는 JAVA language에서 각각의 component를 rendering하고 기능을 구현하는 새로운 기술인 lightweight component 기법을 적용한 것.
SWING component의 package들
javax.swing UI SWING component class 포함 package
javax.swing.border SWING package 경계선 처리 요소 포함 package
javax.swing.event java.awt.event package 내에 정의된 event 외에 SWING에서 추가적으로 사용될 수 있는 각종 event 및 리스너 제공 package
javax.swing.tree javax.swing.JTree 생성 class와 interface 제공 package
javax.swing.table javax.swing.JTable 생성 class와 interface 제공 package
100개 이상의 classes
SWING component들은 javax.swing.JComponent로부터 상속받고, JComponent가 java.awt.Container로부터 상속받으므로 SWING component들은 container 역할을 수행
java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
SWING components
SWING component는 AWT component와 비교될 수 있는 component와(modified) SWING에서 새롭게 추가된 component로 구분하여 볼 수 있다.
1) AWT component와 대응되는 SWING component 관계
JComponent
AbstractButton <-- AbstactButton <---- JCheckBoxMenuItem
<---- JMenu
<---- JRadioButtonMenuItem
JComboBox
JList <---- JCheckBox
<---- JRadioButton
<-- JLabel
<-- JMenuBa
<-- JPanel
<-- JScrollBar
<-- JTextComponent <-- JTextArea
<-- JTextField <-- JPasswordField
<-- JEditorPane <-- JTextPane
SWING에서 새롭게 소개되는 components
JComponent
JColorChooser
JDirectoryPane <-- FileChooser
JInternalFrame
JLayeredPane <-- JDesktopPane
JProgressBar
JSlider
JSplitPane
JTablePane
JTable
JToolBar
JToolTip
JTree
댓글