1. Java Language Specification (Java Language 설명서)
본 문서는 Java Language를 소개한 Sun Microsystem의
"Java Language Specification"을 한글로 번역한 것입니다.
본 문서는 어느정도 ANSI C에 익숙한 사용자를 위해 작성되었다.
1.1. 프로그램 구조(Program sturucture)
Java 프로그램은 하나 또는 여러개의 compilation unit(컴파일 단위)으로 되어있다.
이러한 각각의 compilation unit으로 다음과 같은 것으로 구성되어있다.
- a package statment.
- import statements.
- class declarations.
- interface declarations.
비록 Java의 compilation unit이 여러개의 클래스와 인터페이스를 가지고
있더라고,compilation unit에서 기껏해야 하나의 클래스나, 인터페이스만이
public이다.
Java 원시화일이 compile될때, 그 결과는 java bytecode이다.
Java bytecode는 Java Runtime system에 의해서 효율적으로 해석될수 있는
기계독립적인 명령어로 구성되어있다.
Java runtime system은 가상기계(virtual machine)처럼 실행된다.
그밖의 내용은 "The Java Virtual Machine Specification"을 참조한다.
1.2 문장표현. (Lexical Issues)
Compile을 하는 동안에, Java soruce code에 있는 character는 여러개의
연속적인 토큰(token)으로 표현된다. Java Compiler는 5가지의 token 으로
인식한다 : identifiers, keywords, literals, operators, micellaneoous
separators.
주석문과 빈공백이나 탭, 개행과 같은 white space는 token을 구별하기 위해서만
쓰이고 무시된다.
Java 프로그램은 Unicode character set을 이용하거나, 컴파일시 Unicode로
변환 가능한 character set으로 작성할수 있다.
1.2.1 주석문. (Comments)
Java언어는 주석을 표현할때 3가지 방법을 사용한다.
// text
'//'이후의 모든 문자는 다음줄까지 무시된다.
/* text */
'/*'와 '*/'사이의 문자는 무시된다.
/** text */
1.2.2 선언자. (Identifiers)
선언자(Identifiers)는 문자(letter), "_", "$"로만 시작되어야 한다 ;
그 다음의 문자로는 숫자(0-9)가 들어갈 수 있다. Java는
Unicode character set을 사용한다. 적합한 문자(letter)로는 다음과 같다.
- "A" ~ "Z"까지의 문자.
- "a" ~ "z"까지의 문자.
- 16진수로 00c0이상의 문자와, 모든 Unicode character.
더 이상의 정보는 "The Unicode Standard, Worldwide chacter Encoding,
Version 1.0, Volumes 1&2"를 참조한다.
1.2.3 예약어. (Keywords)
다음은 예약어로써 다른 용도로 쓰일 수 없는것들이다.
(a표 되어 있는것은 요즘 잘쓰지 않는 것이다.)
1.2.4 데이타 표현(Literal)
Literal이란 integer, floating point, boolean, character, string value를
표현하는것을 말한다.
1.2.4.1 정수 표현(integer LIterals)
정수형은 10진수, 16진수, 8진수로 표현할 수 있다.
10진수는 (0~9)까지의 값을 가지고 접두어는 생략한다.
16진수는 (0~9, A~F)까지의 값을 가지고 접두어로 '0X 또는 0x'를 붙힌다.
8진수는 (0~7)까지의 값을 가지고 접두어로 '0'가 붙는다.
정수형의 32bit이상의 값은 long을 사용하는데, 접미어로 'L 또는 l'을 사용한다.
다음은 모두 올바른 정수형의 표현이다.
2, 2L 0777 0xDeadBeef
1.2.4.2 실수 표현(Floating Point Literals)
실수형 표현은 "."을 이용하여 소숫점이상, 이하를 표현한다. 'E 또는 e'를 사용하여 지수를 표현한다.
다음은 모두 올바른 실수형의 표현이다.
3.1415 3.1E12 .1e12 2E12
실수형 역시 float, double, 두가지 data type이 있다.
두가지를 표현하는 방법은 다음과 같다.
2.0d or 2.0D double
2.0f or 2.0F or 2.0 float
1.2.4.3 논리형 표현(Boolean Literals)
true와 false으로 2가지 값을 표현한다.
1.2.4.4 문자 표현(Character Literals)
작은 따옴표 "'"로 둘러쌓인 하나의 문자를 표현한다.
1.2.4.5 문자열 표현(String Literals)
큰따옴표 로 둘러쌓인 문자열을 표현하는 방법은 다음과 같다.
"" \\ the empty string
"\""
"This is a string"
"This is a \
two-line string"
1.2.5 연산자와 다양한 구분자. (Operators and Miscellaneous Separators)
다음은 source code에서 사용되는 연산자와 구분자이다.
+ - ! % ^ & * | ~ / > <
( ) { } [ ] ; ? : , . =
그밖에 위의것들을 조합한 형태이다.
++ -- == <= >= != << >>
>>> += -= *= /= &=|=
^= %= <<= >>= >>>= || &&
1.3 자료형. (Types)
모든 변수와 표현(expression)은 자료형을 가진다. 자료형에 의해서 변수가 가질
수 있는 값의 범위를 결정하고, 그 값을 계산할 연산자를 결정한다.
Java Language에서는 기본적인 Built-in type을 제공한다.
Java language에서는 두가지 simple, composite 형태의 자료형이 있다.
Simple type은 atomic하기 때문에 절대 손상되지 않는 type으로 integer,
floating point, boolean, charter 등이 있고, Composite type은 simple type으로
구성된 자료형으로, array, classes, interface 3가지가 있다.
1.3.1 숫자형. (Numeric Types)
1.3.1.1 정수형. (Integer Types)
정수형은 C/C++과 비슷하지만, C에서는 기계에 따라서 다르지만 Java는
기계 독립적(machine independent)으로 변수의 저장용량과는 관계없이
수학적인 특징과, 한계값에 따라 정해져있다.
다음은 4가지 정수형 type이다.
1.3.1.2 실수형. (Integer Types)
float는 32bit이고, double은 64bit이다. 두개의 float를 연산하면 결과는
float 형이지만, 어느 하나라도 double이면 결는 double형이다.
1.3.1.3 문자형. (Character Types)
문자형은 16bit로 정의되어 있다.
1.3.2 논리형. (Boolean Types)
논리형은 true, flase값만을 가지는 type이다.
논리형은 절대 숫자값이 아니고, 숫자값으로 바꿀 수 없다.
1.3.3 배열. (Array)
배열은 언어에서 first class object이다.
배열은 new 연산자를 사용하여 생성한다.
char s[] = new char[30];
배열의 첫번째 index는 0이다.
배열의 크기는 new를 이용하여 명시해야 한다.
int i[] = new int[3];
Multi-dimensional 배열은 제공되지 않는다. 대신, programmer는 배열의 배열을
정의할 수 있다.
int i[][] = new int[3][4];
배열의 배열에서 배열의 크기는 최소한 하나는 명시되어야 한다. 명시되지 않은
부분은 다음에 명시적으로 크기를 정할 수 있다.
int i[][] = new int[3][];
Java에서는 C에서의 대괄호를 이용한 배열선언의 확장된 표현이다.
다음 두 방법은 모두 올바른 배열 선언 방법이다.
int iarray[];
int[] iarray;
다음의 표현방법이 올바른지 확인해보자.
int a[] = new int[10];
a[5] = 1;
a[1] = a[0] + a[2];
a[-1] = 4; // Throws an ArrayIndexOutOfBoundsException
// at runtime
a[10] = 2; // Throws an ArrayIndexOutOfBoundsException
// at runtime
배열의 index는 정수형이여야 한다.
int n;
...
float arr[] = new float[n + 1];
배열의 크기는 .length를 사용하여 알아 낼수 있다.
int a[][] = new int[10][3];
println(a.length); // prints 10
println(a[0].length); // prints 3
1.3.3.1 배열의 내부구조. (Array Detail)
Array는 Object class의 subclass의 instance이다. 모든 type의 배열은 Array의
subclass이다. 즉, 다음의 Thread의 배열은
new Thread[n]
Thread[]의 instance를 생성한다. 마찬가지로 다음 그림에서 class A가 class B의
superclass 이면 A[]는 B[]의 superclass이다.
그러므로, 배열에는 Object를 대입할 수 있다.
Object o;
int a[] = new int[10];
o = a;
또한 Object를 배열로 형변환(cat)할 수 있다.
a = (int[])o;
Array class는 형변환 연산자를 명시해야 한다.
1.4 클래스. (Classes)
Class는 고전적으로 객체지향 프로그래밍 model을 표현하는데 사용되었다.
데이타 추상화(Data abstraction)화 data를 엮는 역할 을 한다. Java에서
class를 생성한다는것은 새로운 type을 생성하는 것을 의미한다.
새로운 class를 정의하기 위해서, programmer는 기존의 class을 기반으로 해야
한다. 이때 이런 새로운 class는 기존의 class에서 파생(derived)되었다고 말한다.
파생 class는 또한 subclass라고도 부르고 기존의 class는 superclass라고 부른다.
Class는 전달될 수 있는데, C가 B의 subclass이고, B가 A의 subclass이면,
C는 A의 subclass이다.
'extend'라는 keyword를 이용하여 class의 직속 superclass를 표현하고,
'implements'라는 keyword를 이용하여 class가 수행하는 interface를 표현한다.
[Doc comment] [Modifiers] class Classname
extends Superclassname]
implements Interface{, Interface}] {
ClassBody
}
예를 들면 다음과 같다.
/** 2 dimensional point */
public class Point {
float x, y;
...
}
/** Printable point */
class PrintablePoint extends Points implements Printable {
...
public void print() {
...
}
}
모든 class는 하나의 root class로부터 파생된다. Object를 제외한 모든 class는
하나의 직속 superclass를 가진다. 만약 class가 직속 superclass를 정의하지
않으면, superclass는 Object로 간주된다.
예를 들어서 다음 code는 같은의미이다.
class Point {
float x, y;
}
class Point extends Object {
float x, y;
}
Java에서는 오직 하나의 class로부터의 상속(simgle inheritance)만을 허용한다.
다른 언어에서 제공하는 다중 상속은 interfaces를 이용하여 극복할 수도 있다.
1.4.1 Class의 형변환. (Casting Between Class Types)
Java는 형변환을 제공한다. 또한, class는 하나의 새로운 type이기 때문에
class type간의 형변환을 제공한다. 만약 B가 A의 subclass라면, B의 instance는
A의 instance로 사용될 수 있다. 형변환 연산자가 필요없지만 명시하는것이 좋다.
이것을 'widening' 이라고 부른다. 만약 A의 instance가 B의 instance처럼 사용될
필요가 있다면 형변환이 가능한데 이것을 'narrowing'이라고 한다.
그 일반적인 표현은 다음과 같다.
(classname)ref
ref는 classname으로 형변환 된다.
형변환은 단지 참조하기 위해서만 쓰이고, object자체가 변하는것은 아니다.
다음은 형변환시, 참조되는 type에 영향을 받는다는 예제이다.
class ClassA {
String name = "ClassA";
}
class ClassB extends ClassA { // ClassB is a subclass of ClassA
String name= "ClassB";
}
class AccessTest {
void test() {
ClassB b = new ClassB();
println(b.name); // print: ClassB
ClassA a;
a = (ClassA)b;
println(a.name); // print: ClassA
}
}
1.4.2 메소드. (Mothods)
Method는 object나 class이 수행하는 일(연산)을 표현한다. Method는 class나
interface에서 선언할 수 있으나, 오직 class안에서만 일을 수행 할 수 있다.
(모든 사용자 정의 연산(user-defined operation)은 method로 구현된다.)
class에서 method를 정의하는 형식은 다음과 같다.( native, abstract method는
method body를 가지고 있지 않다.)
[Doc comment] [Modifiers] returnType methodName ( parameterList ) {
[methodBody]
}
Methods:
- Construtor를 제외한 모든 method는 return type을 가지고 있다. 만약
return 값이 없더라도 return type은 'void'이어야 한다.
- parameter list는 parameter name과 type을 포함하여, comma로 구분한다.
parameter가 없으면 비워둘 수 있다.
변수는 method안에 정의할 수 있다.(지역변수 : local variable) 같은 method
안에서 지역변수와 parameter는 같은 이름이 있어서는 안된다. 다음의 예는
잘못된 예로써 compile-time error가 발생된다.
class Rectangle {
void vertex(int i, int j) {
for (int i = 0; i <= 100; i++) { // ERROR
...
}
}
}
변수 "i"는 지역변수와, parameter와 이름이 같으므로 error이다.
Java는 overriding과 overloading기법의 polymorphic method를 제공한다.
overriding은 superclass로 부터 상속받은 같은 method를 대신하여 다른일을 하는
같은 이름의 새로운 method정의 하는것을 의미하고, overloading은 method가 오직
이름만 같고 서로 다른 method를 사용하는 것을 의미하며, parameter list로
같은 이름의 method를 서로 구별할 수 있다.
단, return type으로는 구별하지 않는다.
1.4.2.1 Instance Variables.
method의 내부에 정의되지않고, static이 아닌 모든 변수는
instance vairable이다. Instance variable은 modifier를 가질 수 있다.
Instance variable은 어떤 type이어도 되고, 초기화할 수 있다. 만약 초기화
되지 않으면 0으로 초기화된다.; boolean은 false, object는 null. 다음은
instance variable의 선언과 초기화에 대한 예이다.
class A {
int j = 23;
...
}
자기 자신을 가리키는 this라는 것이 있다. 다른 object에게 자기 자신을
argument로 넘겨줄때 사용된다.
class MyClass {
void aMethod(OtherClass obj) {
...
obj.Method(this);
...
}
}
또한, Method 내에서 자신의 instance variable이나 method를 참조할 때
암시적으로 "this."이 생략된 것이다. 다음은 그 예이다.
class Foo {
int a, b, c;
...
void myPrint(){
print(a + "\n"); // a == "this.a"
}
...
}
super는 this와 비슷한데, this는 현재 자기 자신의 object를 참조할때 사용되고,
super는 superclass를 참조할때 사용된다.
1.4.2.3 Setting Local Variables.
Method는 local variable을 참조하여 사용하기 전에 초기화 되었는지 엄격하게
검사한다. 초기화하지 않고 local variable을 사용하게 되면 compile-time error를
발생시킨다.
1.4.3 Overriding Methods
Method를 override하기 위해서, 원래의 method를 가지고 있는 class의 subclass는
이름이 같고, parameter, return type도 같은 method를 정의해야 한다.
Subclass의 interface로부터 method가 호출 될때 원래 method가 호출되지 않고
새로운 method가 호출 된다. 또한, overridden method는 super를 사용하여 호출
할 수도 있다.
setThermostat(...) // refers to the overriding method
super.setThermostat(...) // refers to the overridden method
1.4.4 Overload Resolution.
Overloaded method는 argument의 갯수나, argument의 type이 다른 같은 이름의
method를 말한다. Overload resolution은 어떤 overloaded method를 호출 할것인지
결정하는 일을 한다. method는 같은 class안에서도 overload할 수 있다.
class내에서 method의 선언 순서와는 전혀 무관하다.
Aargument의 갯수나, type을 다르게 함으로써 method를 overload한다. Compiler는
대응되는 최소한의 비용으로 method를 를 찾는다. 오직 같은이름의 같은수의
argument와 같은 type의 argument를 가지는 method를 찾는다.
class A {
int method(Object o, Thread t);
int method(Thread t, Object o);
void g(Object o, Thread t) {
method(o, t); // calls the first method.
method(t, o); // calls the second method.
method(t, t); // ambiguous - compile-time error
}
}
주의할점은 parameter의 갯수나, type에 영향을받고 parameter의 이름과는
무관하다.
1.4.5 생성자. (Constructors)
생성자는 초기를 위해 특별히 제공되는 method이다. return 값이 없고, class의
이름과 같으므로 다른 method와 구별된다. 생성자는 object가 생성될때 자동으로
호출된다. 생성자는 표면적으로 호출 할수는 없다. 만약 package 외부에서 생성자를
호출할 필요가 있다면, 생성자를 public으로 해야한다.
class Foo {
int x;
float y;
Foo() {
x = 0;
y = 0.0;
}
Foo(int a) {
x = a;
y = 0.0;
}
Foo(float a) {
x = 0;
y = a;
}
Foo(int a, float b) {
x = a;
y = b;
}
static void myFoo() {
Foo obj1 = new Foo(); //calls Foo();
Foo obj2 = new Foo(4); //calls Foo(int a);
Foo obj3 = new Foo(4.0); //calls Foo(float a);
Foo obj4 = new Foo(4, 4.0); //calls Foo(int a, float b);
}
}
현재 class의 constructor를 호출하거나, Superclass의 constructor를
호출함으로써 superclass의 instance variable을 초기화 한다. 만약 code에서
명시를 하지 않으면, parameter를 갖지않는 superclass의 constructor를 자동으로
호출하고, 명시되어있으면 우선적으로 명시되어있는 class의 constructor body에 있는
superclass의 constructor를 호출하게 된다. Constructor가 호출되기 이전에
instance variable은 참조될 수 없다. 다음은 superclass의 constructor를
호출하는 예이다.
class MyClass extends OtherClass {
MyClass(someParameters) {
/* Call immediate superclass constructor */
super(otherParameters);
...
}
...
}
다음은 자신의 constructor를 호출 하는 예이다.
class MyClass extends OtherClass {
MyClass(someParameters) {
...
}
MyClass(otherParameters) {
/* Call the constructor in this class that has the
specified parameter list. */
this(someParameters);
...
}
...
}
다음은 counsturctor Foo와 FooSub method이다.
class Foo extends Bar {
int a;
Foo(int a) {
// implicit call to Bar()
this.a = a;
}
Foo() {
this(42); // calls Foo(42) instead of Bar()
}
}
class FooSub extends Foo {
int b;
FooSub(int b) {
super(13); // calls Foo(13); without this line,
// would have called Foo()
this.b = b;
}
}
만약 constructor가 없으면, compiler는 다음과 같은 형식의 constructor를
자동으로 처리한다.
class MyClass extends OtherClass {
MyClass() { // automatically generated
super();
}
}
1.4.6 new연산자를 이용한 객체 생성. (Object Creation-the new Operator)
Class는 object의 상태와, 행동방식을 정의한 template이다. Object는 class의
instance이다. 모든 class의 instance는 garbage collected heap에 할당된다.
Object의 선언만으로는 메모리를 할당하지 않는다. Programmer는 object를 위한
메모리 할당을 명시해야만 한다. 그러나, 명시적인 메모리 반납은 필요없다.
왜냐하면, garbage collector는 더이상 필요가 없을깨 자동으로 메모리를 정리한다.
Object의 메모리 할당은 new 연산자를 사용한다. 또한, new 연산자는 instance
variable을 초기화 한 후 instance의 constructor를 호출한다. Constructor는
object를 초기화 한다. 다음은 ClassA라는 class의 instance를 새롭게 생성하는
예이다.
a = new ClassA();
다음은 argument가 있는 constructor를 후출하는 에이다.
b = new ClassA(3,2);
1.4.6.1 쓰레기정리. (Garbage Collection)
Garbage collector는 간단하고 강력한 메모리 관리자이다. Program에서는 명시적인
메모리 반납을 절대 필요하지 않는다.; 자동으로 처리해준다. Garbage collector는
여전히 참조되는 메모리는 절대 반납하는 경우가 없고, 더이상 쓰이지 않는 메모리는
항상 반납한다. 이것은 dangling pointer bug와 storage leak를 근절시킨다.
또한, designer로 하여금 system적인 메모리 관련부분을 신경쓰지 않도록 해준다.
1.4.6.2 The null Reference.
예약어 'null'은 "no instance"를 나타내는 상수값이다. null은 어떠한
instance에도 적용이 되며, 어떠한 class type으로도 형변환이 가능하다.
1.4.7 Static Methods, Variables, and Initializers.
Class에서 variable과 method는 static으로 선언될 수 있다. 이것은 class의
instance를 위한것이라기 보다는, class 자체를 위한 것이다. 또한, class 내부
code의 block도 static으로 정의할 수 있다. 이것을 static initializer라고 한다.
Static variable은 instance variable처럼, initializer를 가질수 있다.
Static variable은 instance의 수에는 상관 없이 오직 class에 하나씩만 메모리
할당이 되어 공유한다. Static variable과 static method는 둘다 class의 이름을
이용하여 접근할 수 있다. 또한 class의 instance를 이용해서도 접근할 수 있다.
class Ahem {
int i; // Instance variable
static int j; // Static variable
static int arr[] = new int[12];
static { // static initializer:
// initialize the array
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
}
}
void seti(int i) { // Instance method
this.i = i;
}
static void setj(int j) { // Static method
Ahem.j = j;
}
static void clearThroat() {
Ahem a = new Ahem();
Ahem.j = 2; // valid; static var via class
a.j = 3; // valid; static var via instance
Ahem.setj(2); // valid; static method via class
a.setj(3); // valid; static method via instance
a.i = 4; // valid; instance var via instance
Ahem.i = 5; // ERROR; instance var via class
a.seti(4); // valid; instance method via instance
Ahem.seti(5); // ERROR; instance method via class
}
}
1.4.7.1 선언 순서. (Order of Declarations)
Class, method, instance variable의 선언 순서는 상관이 없다. 그러나,
초기화 하는 순서에는 영향을 줄 수 있다. 다음은 모두 올바른 예이다.
class A {
void a() {
f.set(42);
}
B f;
}
class B {
void set(long n) {
this.n = n; }
long n;
}
1.4.7.2 초기화 순서. (Order of Initialization)
Class가 load될때, ㅁ모든 static initialization code가 실행 된다.
Static initializer는 static variable이 초기화 되는것과 같은 시간에 실행된다.
초기화는 어휘순서로 처리된다. 다음은 class C를 선언한 것이다.
class C {
static int a = 1;
static {
a++;
b = 7;
}
static int b = 2;
}
class C가 load될때 다음의 순서로 이루어진다.
- a가 1로 초기화 된다.
- static initializer가 실행되어, a는 2, b는 7로 초기화한다.
- b를 7로 초기화한다.
만약 load되지 않은 class의 static initialization code가 다른 load되지 않은
class로를 참조하면, 이 참조되는 class는 load되어서 제일먼저 자신의
static initialization code를 실행한다.
이때 참조되는 class의 static initialization code에서 다시 load되지 않은
class를 참조하게 되면, cycle이 생성되어, NoClassDefFoundException이
실행된다.
예를 들어서, 만약 ClassA가 load되면, 자신의 static initialization code가
실행 된다. 그러나, ClassA의 static initialization code는 다른 load되지 않은
다른 ClassB를 참조 할 수가 있는데, 이때 ClassB는 load되어서, ClassA보다 먼저
자신의 static initialization code를 실행한다. 그런후, ClassA의 static
initialization이 실행된다. 만약 ClassB가 다시 ClassA의 static initialization
code를 참조하면, cycle이 생성된다.
다음은 static variable의 초기화 과정에서 forward dependency에 따른
compilie-time error 예제이다.
int i = j + 2;
int j = 4;
instance variable의 초기화 에서 static vaariable에 따른 forward dependency로
보이는 예제이다.
int i = j + 2; // Instance variable
static int j = 4; // Static variable
위에서, i는 j에의해서 forward dependency처럼 보이나, i는 6으로 j는 4로 초기화
된다. 왜냐하면 static variable인 j가 instance variable인 i보다 먼저 초기화가
되기 때문이다.
Static method는 instance variable을 참조 할 수 없다. 오직 static method와ㅏ
staatic variable만을 참조 할 수 있다.
1.4.8 Access Specifiers.
Access specifier는 programmer가 method와 variable의 접근을 control하기위한
것이다. public, private, proteced가 있다. public은 어느곳에서든지 접근 할 수
있음을 의미하며, private는 자신이 선언되 class 내에서만 접근 할 수 있다.
private method는 class 외부에서는 볼 수가 없으므로, final이고 override할 수
없다. protected는 오직 subclass만이 method와 variable을 참조 할 수 있다.
Public 접근은 class, method, variable에 적용할 수 있다. Class, method,
variable이 public으로 표시되면, 다른 class나 method에서 어느 곳 에서든지
접근이 가능하다.
Package내에서 class, method, variable은 priavate, public 을 꼭 명시할
필요는 없다.
1.4.9 Varable Scoping Rules.
Class가 subclass로 정의될 때, package내에서 superclass의 선언된 내용은
subclass내에서 볼 수 있다. method내에서 선언된 variable은, 다음의
scoping 규칙에 따른다.
- 1. 제일먼저 현재 block을찾고, 현재 method에 둘러싸인 전체 block을
잦는다. 이것은 local scope에 관한 이야기이 .
- 2. 현재 class의 variable을 찾는다.
- 3. 만약 variable을 찾지 못하면, 가장 가까운 superclass롭터,
모든 superclass의 variable 에서 찾아서 Object class까지 올라간다.
그래도 찾지 못하면, Import된 class와 package를 찾는다. 그래도 못찾으면,
compile-time error를 내보이게 된다.
같은 class내에서 같은 이름의 multiple variable은 허용하지 않고, compile-time
error를 내보낸다.
1.4.10 Modifiers.
1.4.10.1 Threadsafe Variables.
Instance variable 또는 static variable은 'threadsafe'라고 명시하여,
한 thread가 변수를 사용하고 있을때, 다른 thread가 접근하여 값을 절대 부꾸지
못하도록 보호하여야 한다.(변수값 비동기적으로 바꾸지 못하도록한다.)
Primary optimization은 threadsafe를 이용하여 instance variable을 register에
caching을 한다.
1.4.10.2 Transient Variables.
'transient' flag는 interpreter로 하여금, class의 instance를
persistent object로 처리하도록 한다.
1.4.10.3 Final Classes, Methods, and Variables.
'final'로 표시된 class는 절대 subclass를 자지지못하도록 한다. Final method는
method body의 inline기능을 한다.
다음은 final의 다양한 예이다.
class Foo {
final int value = 3; // final variable
final int foo(int a, int b) { // final method
...
}
}
1.4.10.4 Native Methods.
'native'로 표시된 method는...
1.4.10.5 Abstract Methods.
Abstract method는 subclass들간의 규약을 정하기 위한 superclass 또는
interface의 기능을 제공한다. Abstract method는 subclass에서는 반드시
정의를 해야 한다. Abstract method는 method body가 없고, 대신 선언은 semicolon
으로 끝난다.
'abstract' keyword는 다음과 같은 규칙을 가지고 있다.
- Constructor는 abstract 할 수 없다.
- Static method는 abstract 할 수 없다.
- Private method는 abstract 할 수 없다.
- Abstract method는 abstract method가 선언되어있는 class의 subclass에
정의한다.
- Superclass의 method로부터 override된 method는 abstract 할 수 없다.
- Abstract method와 overriding 하지 않고 abstract method를 상속받은 class를
abstract class라고 한다.
- Abstract class를 instantiate하거나, abstract method를 직접 호출하면
compile-time error를 내보낸다.
1.4.10.6 Synchronized Methods and Blocks.
'synchronized'는 method나 block의 code에 lock을 거는것이다. Lock은
synchronized code가, 같은 시간에 같은 resource를 access하는 서로다른 code
로 실행 되지 않도록 방지하는 것이다. 각각의 object는 하나의 lock을 가지고있다.
Synchronized method가 호출 되면, 현재 instance를 위한 lock을 얻을때 까지
기다린다. Lock을 얻은 후에는 code를 실행 시킨후 lock을 반납한다.
Synchronized block은 synchronized method처럼 수행한다. 단 다른점은,
현재의 instance나 class를 위한 lock을 사용하는대신, sysnchronized block은
object와 관련된 lock이나, class에서 제공하는 block의 synchronized 문장을
사용한다는 것이다.
Synchronized block은 다음과 같이 선언한다.
/* ...preceding code in the method... */
synchronized(<object or class name>) { //sync. block
/* code that requires synchronized access */
}
/* ...remaining code in the method... */
다음은 synchronized method 선언 방법이다.
class Point {
float x, y;
synchronized void scale(float f) {
x *= f;
y *= f;
}
}
다음은 synchronized block의 예이다.
class Rectangle {
Point topLeft;
...
void print() {
synchronized (topLeft) {
println("topLeft.x = " + topLeft.x);
println("topLeft.y = " + topLeft.y);
}
...
}
}
1.5 Interface.
Interface는 body를 수행하지 않는 method의 묶음이다.
Interface는 method protocol을 캡슐화하여 제공함으로써 하나의 inheritance tree를
구성할 수 있도록 제한하는것이다.
Interface는 runtime의 부하를 없애기위해서 제공하지 않는 mulitple
inheritance의 문제를 해결한다.
그러나, interface synamic method binding을 포함하고 있으므로, 사용하는데 큰
부하가 없다.
Interface를 사용함으로써 class는 서로 어떤 일을 하는지 알 필요가 없는
programming interface를 공유 할 수 있다. 다음은 'interface' keyword를 이용하여
interface의 선언을 보여주고, interface를 수행하는 class를 보여준다.
public interface Storing {
void freezeDry(Stream s);
void reconstitute(Stream s);
}
public class Image implements Storing, Painting {
...
void freezeDry(Stream s) {
// JPEG compress image before storing
...
}
void reconstitute (Stream s) {
// JPEG decompress image before reading
...
}
}
1.5.1 Interface as Types.
선언문 "interfaceName variableName"는 interfaceName을 수행하는 class의
interface로 variable, parameter를 선언하는 문장이다. Object의 type이
무엇이고, 상속받은것을 정확히 알지 못하더라도, Object가
주어진 interfaece를 수행해야 한다는 것을 Programmer는 명시해야 한다.
다음의 pseudocode는 "interfaceName variableName"을 설명하고 있다.
class StorageManager {
Stream stream;
...
// Storing is the interface name
void pickle(Storing obj) {
obj.freezeDry(stream);
}
}
1.5.2 Methods in Interfaces.
Interface안의 method는 다음과 같이 선언한다.
returnType methodName ( parameterList );
Interface의 method는 public, abstract.. 등 모든 modifier를 적용할 수 있다.
1.5.3 Variables inInterfaces.
Interface의 variable은 final, public, static이다. 그밖의 modifier는 허용하지
않는다. Varable은 초기화 되어야 한다.
1.5.4 Combining Interfaces.
Interface는 'extends' keyword를 이용하여 하나 또는 그이상의 interface와
혼합할 수 있다. 다음은 그 예이다.
interface DoesItAll extends Storing, Painting {
void doesSomethingElse();
}
1.6 Packages.
Package는 class와 interface의 묶음이다. 많은 이름들을 관리하고, 서로의 충돌을
피하는 tool이다. 모든 class와 interface이름은 같은 package에 포함되어 있다.
편의상, packages 이름은 마침표로 구분한다.(period-separated words)
첫번째 이름은 package를 개발한 구조를 나타낸다.
1.6.1 Specifying a Compilation Unit's Package.
Compilation unit의로의 package는 'package'문장으로 나타낸다.
이문장이 나타나면, Compilation unit에서는 non-comment, non-white space line
이어야 한다. 그형식은 다음과 같다.
package packageName;
Compilation unit에 package문장이 없으면, 이름이 없는 default package로
대치된다.
1.6.2 Using Classes and Interfaces from Other Packages.
Java는 package의 class와 interface를 정의하고, 사용할 수 있는 구조를
제공한다. 'import' keyword는 class에서 package를 사용할 수 있다는것을
나타낸다. Compilation uni은 자동으로 그 package의 class와 interface를 가져온다.
Package의 code는 다른 package의 class나 interface를 한가지 또는 두가지
방법으로 명시 할 수 있다.
- package 이름과 함께 class나 interface이름을 앞에서부터 나열하여 표현한다.
// prefacing with a package
acme.project.FooBar obj = new acme.project.FooBar();
- 'import' 문장을 이용하여 사용되는 class나 interface, 또는 package의
내용을 사용함을 알린다. 다음은 사용되는 acme.project로부터 모든 public class를
사용한다는것을 의미한다.
// import all classes from acme.project
import acme.project.*;
다음은 acme.pro에서 class Emplyee_List 하나만을 import한다.
// import Employee_List from acme.project
import acme.project.Employee_List;
Employee_List obj = new Employee_List();
그러나 이것은 잘못 되었다. class 이름이 모호하므로 compile-time error를
내보내게 된다. Package의 class이름을 포함함으로써 완전히 부여된 class이름을
사용할 수 있다.
1.7 Expressions
Java의 expression은 C와 아주 유사하다.
1.7.1 Operations.
다음은 우선 순위에 따른 연산자 이다.
. [] ()
++ -- ! ~ instanceof
* / %
+ -
<< >> >>>
< > <= >=
== !=
&
^
|
&&
||
?:
= op=
,
1.7.1.1 Operators on Integers.
다음의 연산자는 결과값이 integer이다. 피연산자중 long이 있으면,
결과값은 long이고, 그외의 것은 모두 int type이다. 그러므로, 만약 변수 i가
short나 byte로 선언되어있어도 i+1은 int이다. 결과값이 연산자의 범위를 벗어나면,
modulo시킨다.
다음은 unary integer 연산자이다.
"++lvalue"는 "lvalue += 1"과 같고, "lvalue = lvalue+1"과도 같다.
다음은 binary integer 연산자이다.
나누기에서 " (a/b)*b + (a%b) == a "처럼 0으로 나누는 연산은
ArithmeticException을 실행시킨다.
<, >, <=, >=, ==, !=는 결과값이 boolean이다.
abs(x), max(x, y), min(x, y) 연산자는 integer를 포함한 모든 숫자에서 실행된다.
1.7.1.2 Operators on Boolean Values.
boolean연산과 섞인 표현은 결과값이 boolean이다. !는 boolean negation을
의미하는 연산자 이고, 이진 연산자(binary operator) &, |, ^은 의미적으로
AND, OR, XOR를 의미한다. 따라서 &&, ||, ==, !=, &=, !=, ^=을 사용할 수 있다.
1.7.1.3 Operators on Floating Point Values.
+, -, *, /, +=, -=, *=, /=, ++, --, %, %=를 사용할 수 있다.
다음의 나머지 연산은 각각 같은 의미 이다.
a % b
a - ((int)(a / b) * b)
abs(x), max(x, y), min(x, y)역시 사용할 수 있다.
>, <, >=, <=, ==, !=를 사용할 수 있다.
그밖의 내용은 부록에서 설명하겠다.
1.7.1.4 Operators on Arrays.
다음은 배열의 한원소의 값을 가저오는 형식이다. Index의 범위는 0에서 배열의
길이 -1까지인데, 그 범위는 오직 runtime에만 검사한다.
<expression>[<expression>]
1.7.1.5 Operators on Strings.
문자열은 String object로 처리된다. +연산자는 String을 연결 시켜주는데,
만약 피연산자가 String이 아니면 자동으로 피연산자를 String으로 바꾸어서
처리해준다. 또한, 피연산자가 object이면 object의 String값을 return해주는
toString() method를 호출한다.
// Examples of the + operator used with strings
float a = 1.0;
print("The value of a is " + a + "\n");
String s = "a = " + a;
+= 연산자도 허용된다.
s1 += a; //s1 = s1 + a; // a is converted to String if necessary
1.7.1.6 Operators on Objects.
'instanceof'는 특정 object가 특정 class또는 subclass의 instance인지 검사한다.
if (thermostat instanceof MeasuringDevice) {
MeasuringDevice dev = (MeasuringDevice)thermostat;
...
}
위의 예는 tthermostaat가 MeasuringDevice object의 instance인지 알아본다.
1.7.2 Casts and Conversion.
Java language와 runtime system은 system을 망치지 않도록 형변환에 제한을 둔다.
Integer는 floaaating point는 형변환이 가능하다. 그러나, integer는 arrary나
object로 형변환을 할 수 없다. Object는 base type으로 형변환을 할 수 없다.
Instance는 superclass로 아무 제한 없이 형변환을 할 수 있으나, subclass로의
형변환은 runtime check를 한다. 만약 object가 subclass의 instance가 아닌
subclass로 형변환이 되면, runtime system은 ClassCastException을 실행시킨다.
1.8 Statements.
1.8.1 선언문. (Declarations)
선언은 statement가 허용된곳이면 어느곳에서든 할 수 있다. Scope는 선언된
블럭을 벗어나면 볼 수 없다.
또한, for문 내에서도 가능하다.
for (int i = 0; i < 10; i++) {
...
}
위와같이 변수를 선언하면 for문 내에서만 유용하다.
다음은 위와 동등한 예문이다.
{
int i = 0;
for (; i < 10; i++) {
...
}
}
1.8.2 Expressions.
다음은 expression이다.
a = 3;
print(23);
foo.bar();
1.8.3 흐름 제어. (Control Flow)
다음은 흐름 제어를 요약해서 보여주는 예이다.
if(boolean) statement
else statement
switch(e1) {
case e2: statements
default: statements
}
break [label];
continue [label];
return e1;
for([e1]; [e2]; [e3]) statement
while(boolean) statement
do statement while(boolean);
Java는 labeled loop와 labeled break를 지원한다. 다음은 그 에이다.
outer: // the label
for (int i = 0; i < 10; i++) {
for (int j= 0; j< 10; j++) {
if (...) {
break outer;
}
if (...) {
}
}
}
Loop와 break에서 label을 사용할 때는 다음과 같은 규칙이 있다.
- 모든 문장은 label을 가질 수 있다.
- break문의 lable은 enclosing statement의 label이어야 한다.
- continue문의 label은 enclosing loop읜 label이어야 한다.
1.8.4 Exception.
Java program에서 오류가 발생되면, 예를 들어서 argunemt값이 잘못되었다면,
오류를 방지하기 위한 code가 실행된다. 만약 그러한 code가 없을 경우에는
오류 message를 보여주고 마치게 된다. 그러나, program은 catch, recover등을
이용하여 exception handler를 가질 수 있다.
Exception은 runtime system에 의해서 처리된다. 그러나, 모든 class는
'throw'문을 이용해서 exception을 대비할 수 있다. 'throw'문은 object를 포함한
'throw' keyword를 이용한다. 편의상, 이 object는 Exception이나 Exception
subclass의 instance이어야 한다. 'throw'문은 적당한 exception haandle을
실행 시킨다. 'throw'문이 실행 될때, 아무런 code가 실행 되는것이 아니라,
return 값이 없는 둘러싸인 method가 실행된다. 다음은 Exception의 subclass를
생성하여 exception을 처리(throw)하는 예이다.
class MyException extends Exception {
}
class MyClass {
void oops() {
if (/* no error occurred */) {
...
} else { /* error occurred */
throw new MyException();
}
}
}
Exception handler를 정의하기 위해서, 제일먼저 program은 'try'문을 사용하여
code를 둘러싼후, 오류가 발생했는지 검사한다. 오류가 발행되면, 'catch'문을
사용하여 exception handling code를 실행 시킨다. 다음은 그 예이다.
try {
p.a = 10;
} catch (NullPointerException e) {
println("p was null");
} catch (Exception e) {
println("other error occurred");
} catch (Object obj) {
println("Who threw that object?");
}
'catch'문은 parameter하나를 갖고, return type이 없는 method와 비슷하다.
Parameter는 class또는 instance이면 된다. Exception이 발생하면, 'try/catch'문의
parameter와 일치하는 exception을 찾는다. Exception의 parameter는
다음과 같이 찾는다.
- 현재 class의 exception.
- superclass의 exception.
- 만약 parameter가 interface면, exception class는 interface를 실행시킨다.
'try/catch'문은 catch문을 실행 시킬 exception에 해당하는 parameter를 갖는다.
'catch'문이 실행된후, 'try/catch'문 다음의 실행을 다시한다.
Exception이 발생한 시점에서는, exception handler를 재실행 하는것은 불가능하다.
다음은 그 예이다.
print("now ");
try {
print("is ");
throw new MyException();
print("a ");
} catch(MyException e) {
print("the ");
}
print("time\n");
위의 예는 "now is the time"이라고 출력된다. 위의 예에서처럼, exception은
오직 error handling을 위해서만 쓰일 필요는 없다. 그렇지만, 이러한 경우는
code를 이해하기 어렵게 만든다.
Exception handler는 포개질 수 있다. 즉, 하나이상의 exception handling할
수 있다. Nested exception handling은 첫번째 handler에서 오류를 완전히
복구 시킬 수 없지만, 어느정도 처리해야 할일이 있을 경우에 사용한다.
다음단계의 더 훌륭한 exception handler로 넘어갈때, 다음 예문과 같이
같은 object를 사용하여 'throw' keyword를 이용하여 다음 단계 handler로
넘어간다. 단, 이렇게 다음 단계로 넘어가면 'throw'문은 return하지 않기 때문에
다시 재실행 할 수 없다.
try {
f.open();
} catch(Exception e) {
f.close();
throw e;
}
1.8.4.1 The finally Statement.
'finally'문은 exception이 발생하더라도 몇몇 code를 실행하고 싶을때 사용한다.
'catch'문이나 'finally'문은 'try'문 다음에 사용할 수 있다. 하지만 동시에
둘을 사용할 수 없다. 다음은 그 예이다.
try {
// do something
} finally {
// clean up after it
}
위의 code는 다음 아래의 것과 비슷하다.
try {
// do something
} catch(Object e){
// clean up after it
throw e;
}
// clean up after it
'finally'문은 'try' block에서 return, break, continue, throw문을 실행
시키더라도 실행된다. 예를 들어, 다음 code의 결과는 "finally"라고 출력된다.
그러나 "after try"는 a!=10일때만 출력 된다.
try {
if (a == 10) {
return;
}
} finally {
print("finally\n");
}
print("after try\n");
1.8.4.2 Runtime Exceptions.
이번에는 여러가자 다양한 오류가 발생했을때 수행되는 Java runtime system
throw의 exception 목록을 알아보겠다.
Arithmetic Exception.
0으로 나눌때 발생된다. 그밖의 경우는 없다. ArithmeticException이 실행되는
경우는 다음 예와 같다.
class Arith {
public static void main(String args[]) {
int j = 0;
j = j / j;
}
}
NullPointerException
Variable이나 method가 null object를 참조하거나, 배열의 null element를
접근 할경우에 NullPointerException이 실행된다. 예를 들어서 o.length와 a[0]을
접근함으로 실행도중에 NullPointerException이 실행된다.
class Null {
public static void main(String args[]) {
String o = null;
int a[] = null;
o.length();
a[0] = 0;
}
}
IncompatibleClassChangeException
IncompatibleClassChageException이 실행되는 경우는 다음과 같다.
- class 내부의 variable의 선언이 static에서 non-static으로 바뀌었는데,
다른 class가 이 바뀐 variable을 참조할때.
- class 내부의 variable의 선언이 non-static에서 static으로 바뀌었는데,
다른 class가 이 바뀐 variable을 참조할때.
- class 내부의 field가 지워졌는데, 다른 class가 이 field를 참조할때.
- class 내부의 method가 지워졌는데, 다른 class가 이 field를 참조할때.
ClassCastException
object O가 class C로 형변환 할때, O는 C가 아니고 C의 subclass도 아니므로
ClassCastException이 실행 된다. 다음은 그 예이다.
class ClassCast {
public static void main(String args[]) {
Object o = new Object();
String s = (String)o; // the cast attempt
s.length();
}
}
NegativeArraySizeException
배열의 크기가 음수이면 NegativeArraySizeException이 실행된다.
다음은 그 예이다.
class NegArray {
public static void main(String args[]) {
int a[] = new int[-1];
a[0] = 0;
}
}
OutOfMemoryException
더이상 메모리 할당을 할수 없을때 OutOfMemorryExceptin이 실행된다. 이것은
오직 new 연산자를 이용하여 object를 생성할때만 발생된다. 다음은 그 예이다.
class Link {
int a[] = new int[1000000];
Link l;
}
class OutOfMem {
public static void main(String args[]) {
Link root = new Link();
Link cur = root;
while(true) {
cur.l = new Link();
cur = cur.l;
}
}
}
NoClassDefFoundException
Class를 참조할려고 하나, runtime system이 참조할 class를 찾지 못할때
실행 된다. 다음은 그 예이다.
class NoClass {
public static void main(String args[]) {
C c = new C();
}
}
위의 예에서 runtime system은 C.class를 찾지 못했다. C.class는 NoClass가
compile될때 이미 존재해야 한다.
IncompatibleTypeException
Interface의 instance를 생성할때 발생한다. 다음은 그 예이다.
interface I {
}
class IncompType {
public static void main(String args[]) {
I r = (I)new("I");
}
}
ArrayIndexOutOfBoundsException
배열의 잘못된 element를 index할 경우 실행된다. 다음은 그 예이다.
class ArrayOut {
public static void main(String args[]) {
int a[] = new int[0];
a[0] = 0;
}
}
UnsatisfiedLinkException
Method가 native로 선언되었고, method가 runtime system routine과 더이상
연결되지 않을때 발생한다.
class NoLink {
static native void foo();
public static void main(String args[]) {
foo();
}
}
InternalException
runtime system의 이름모를 오류가 발생할때 실행된다.
이러한 경우가 발생하면 WebRunner@Sun.COM으로 연락해본다.