165p. 예제 6-1
class Ex_JS {
public static void main(String args[]) {
Tv t;
t = new Tv();
t.channel = 7;
t.channelDown();
System.out.println("현재 채널은 "+ t.channel +"입니다.");
}
}
class Tv {
String color;
boolean power;
int channel;
void power() { power = !power; }
void channelUp() { ++channel; }
void channelDown() { --channel; }
}
출력값:
현재 채널은 6입니다.168p. 예제 6-2
class Ex_JS {
public static void main(String args[]) {
Tv t1 = new Tv();
Tv t2 = new Tv();
System.out.println("t1의 channel값은 "+ t1.channel +"입니다.");
System.out.println("t2의 channel값은 "+ t2.channel +"입니다.");
t1.channel = 7;
System.out.println("t1의 채널값을 7로 변경하였습니다.");
System.out.println("t1의 channel값은 "+ t1.channel +"입니다.");
System.out.println("t2의 channel값은 "+ t2.channel +"입니다.");
}
}
class Tv {
String color;
boolean power;
int channel;
}
출력값:
t1의 channel값은 0입니다.
t2의 channel값은 0입니다.
t1의 채널값을 7로 변경하였습니다.
t1의 channel값은 7입니다.
t2의 channel값은 0입니다.175p. 예제 6-3
class Ex_JS {
public static void main(String args[]) {
System.out.println("Card.width = " + Card.width);
System.out.println("Card.height = " + Card.height);
//클래스 변수(static)는 객체생성없이 '클래스이름.클래스변수'로 직접 사용가능하다.
Card c1 = new Card();
c1.kind = "Heart";
c1.number = 7;
Card c2 = new Card();
c2.kind = "Spade";
c2.number = 4;
//인스턴스 변수의 값을 변경한다.
System.out.println("c1은 "+c1.kind + ","+c1.number
+ "이며, 크기는 (" + c1.width + ","+ c1.height + ")" );
System.out.println("c2는 "+c2.kind + ","+c2.number
+ "이며, 크기는 (" + c2.width + ","+ c2.height + ")" );
System.out.println("c1의 width와 height를 각각 50, 80으로 변경합니다.");
c1.width = 50;
c1.height = 80;
//클래스 변수의 값을 변경한다.
System.out.println("c1은 "+c1.kind + ","+c1.number
+ "이며, 크기는 (" + c1.width + ","+ c1.height + ")" );
System.out.println("c2는 "+c2.kind + ","+c2.number
+ "이며, 크기는 (" + c2.width + ","+ c2.height + ")" );
}
}
class Card { //앞에 static가 붙은것이 클래스 변수이다. 인스턴스 변수, 클래스변수는 클래스 영역에 선언된다. 선언되는 장소로 변수의 종류를 파악하자.
String kind ;
int number;
static int width = 100;
static int height = 250;
}
출력값:
Card.width = 100
Card.height = 250
c1은 Heart,7이며, 크기는 (100,250)
c2는 Spade,4이며, 크기는 (100,250)
c1의 width와 height를 각각 50, 80으로 변경합니다.
c1은 Heart,7이며, 크기는 (50,80)
c2는 Spade,4이며, 크기는 (50,80)c1의 폭, 높이를 변경했는데 c2도 같은값으로 변경된 것을 알 수 있다.
이것은 변경한 값이 클래스 변수이기 때문이다.
클래스 변수는 Card의 인스턴스인 c1, c2는 클래스 변수인 폭과 넓이를 공유하기 때문이다.
모두 같은 저장공간을 참조하므로 항상 같은값이 나온다.
181p. 예제 6-4
//메서드의 실행 흐름
class Ex_JS {
public static void main(String args[]) {
MyMath mm = new MyMath();
long result1 = mm.add(5, 3);
long result2 = mm.subtract(5L, 3L);
long result3 = mm.multiply(5L, 3L);
double result4 = mm.divide(5L, 3L);
System.out.println("add(5L, 3L) = " + result1);
System.out.println("subtract(5L, 3L) = " + result2);
System.out.println("multiply(5L, 3L) = " + result3);
System.out.println("divide(5L, 3L) = " + result4);
}
}
class MyMath {
long add(long a, long b) {
long result = a + b;
return result;
}
long subtract(long a, long b) { return a - b; }
long multiply(long a, long b) { return a * b; }
double divide(double a, double b) { return a / b; }
}
출력값:
add(5L, 3L) = 8
subtract(5L, 3L) = 2
multiply(5L, 3L) = 15
divide(5L, 3L) = 1.6666666666666667185p. 예제 6-6
//기본형 매개변수
class Data { int x; }
class Ex_JS {
public static void main(String args[]) {
Data d = new Data();
d.x = 10;
System.out.println("main() : x = " + d.x);
change(d.x);
System.out.println("After change(d.x)");
System.out.println("main() : x = " + d.x);
}
static void change(int x) { //메서드의 매개변수가 기본형이면 > 읽기만 가능하다.
x = 1000;
System.out.println("change() : x = " + x);
}
}
출력값:
main() : x = 10
change() : x = 1000
After change(d.x)
main() : x = 10기본형은 해당 인스턴스의 주소를 모르니까 찾아가지를 못해서 값을 변경할 수 없다. 원본이 아닌 복사본이 변경된다. 직접 방문을 못하니까 원본에 아무런 영향을 미치지 못한다.
186p. 예제 6-7
//참조형 매개변수
class Data2 { int x; }
class Ex_JS {
public static void main(String args[]) {
Data2 d = new Data2();
d.x = 10;
System.out.println("main() : x = " + d.x);
change(d);
System.out.println("After change(d)");
System.out.println("main() : x = " + d.x);
}
static void change(Data2 d) {
d.x = 1000;
System.out.println("change() : x = " + d.x);
}
}
출력값:
main() : x = 10
change() : x = 1000
After change(d)
main() : x = 1000187p. 예제 6-8
//참조형 반환타입
class Data3 { int x; }
class Ex_JS {
public static void main(String args[]) {
Data3 d = new Data3();
d.x = 10;
Data3 d2 = copy(d);
System.out.println("d.x ="+d.x);
System.out.println("d2.x ="+d2.x);
}
static Data3 copy(Data3 d) {
Data3 tmp = new Data3();
tmp.x = d.x;
return tmp;
}
}
출력값:
d.x =10
d2.x =10189p. 예제 6-9
class MyMath2 {
long a, b;
//인스턴스 메서드
//인스턴스 변수 a, b만을 이용해서 작업하므로 매개변수가 필요없다.
long add() { return a + b; }
long subtract() { return a - b; }
long multiply() { return a * b; }
double divide() { return a / b; }
//static(클래스)메서드
//인스턴스 변수와 관계없이 매개변수만으로 작업이 가능하다.
static long add(long a, long b) { return a + b; } //a, b는 지역변수
static long subtract(long a, long b) { return a - b; }
static long multiply(long a, long b) { return a * b; }
static double divide(long a, long b) { return a / (double)b; }
}
class Ex_JS {
public static void main(String args[]) {
//클래스 메서드 호출, 인스턴스 생성없이 호출가능
System.out.println("클래스 메서드");
System.out.println(MyMath2.add(200L, 100L));
System.out.println(MyMath2.subtract(200L, 100L));
System.out.println(MyMath2.multiply(200L, 100L));
System.out.println(MyMath2.divide(200L, 100L));
//인스턴스 메서드 호출, 객체 생성 후에만 호출이 가능하다.
MyMath2 mm = new MyMath2();
mm.a = 200L;
mm.b = 100L;
System.out.println("인스턴스 메서드");
System.out.println(mm.add());
System.out.println(mm.subtract());
System.out.println(mm.multiply());
System.out.println(mm.divide());
}
}194p. 예제 6-10
//메서드 오버로딩(overloading)예제
class Ex_JS {
public static void main(String args[]) {
MyMath3 mm = new MyMath3();
System.out.println("mm.add(3, 3) 결과:" + mm.add(3,3));
System.out.println("mm.add(3L, 3) 결과:" + mm.add(3L,3));
System.out.println("mm.add(3, 3L) 결과:" + mm.add(3,3L));
System.out.println("mm.add(3L, 3L) 결과:" + mm.add(3L,3L));
int[] a = {100, 200, 300};
System.out.println("mm.add(a) 결과: " + mm.add(a));
}
}
class MyMath3 {
int add(int a, int b) {
System.out.print("int add(int a, int b) - ");
return a+b;
}
long add(int a, long b) {
System.out.print("long add(int a, long b) - ");
return a+b;
}
long add(long a, int b) {
System.out.print("long add(long a, int b) - ");
return a+b;
}
long add(long a, long b) {
System.out.print("long add(long a, long b) - ");
return a+b;
}
int add(int[] a) {
System.out.print("int add(int[] a) - ");
int result = 0;
for (int i=0; i < a.length;i++)
result += a[i];
return result;
}
}
출력값:
int add(int a, int b) - mm.add(3, 3) 결과:6
long add(long a, int b) - mm.add(3L, 3) 결과:6
long add(int a, long b) - mm.add(3, 3L) 결과:6
long add(long a, long b) - mm.add(3L, 3L) 결과:6
int add(int[] a) - mm.add(a) 결과: 600196p. 예제 6-11
//기본 생성자 예제
class Data_1 {
int value;//정의되어 있는 생성자가 1개도 없음> 컴파일러가 기본 생성자를 추가해준다.
}
class Data_2 {
int value;
//Data_2(){}를 추가해야됨
//이미 정의되어 있는 생성자가 있음> 기본 생성자가 추가되지 않았다.
Data_2(int x) {
value = x;
}
}
class Ex_JS {
public static void main(String[] args) {
Data_1 d1 = new Data_1();
Data_2 d2 = new Data_2();
//또는 Data_2 d2 = new Data_2(10); 로 생성자 Data_2(int x)를 사용해야된다.
}
}199p. 예제 6-12
//매개변수가 있는 생성자 예제
class Car {
String color;
String gearType;
int door;
Car(){} //생성자
Car(String c, String g, int d){ //매개변수가 있는 생성자
color = c;
gearType = g;
door = d;
}
}
class Ex_JS {
public static void main(String[] args) {
Car c1 = new Car();
c1.color = "white";
c1.gearType = "auto";
c1.door = 4;
Car c2 = new Car("White", "auto", 4); //매개변수가 있는 생성자를 사용하면 한줄로 간단히 초기화 할 수 있다.
System.out.println("c1의 color=" + c1.color + ", gearType=" + c1.gearType + ", door=" + c1.door);
System.out.println("c2의 color=" + c2.color + ", gearType=" + c2.gearType + ", door=" + c2.door);
}
}
출력값:
c1의 color=white, gearType=auto, door=4
c2의 color=White, gearType=auto, door=4200p. 예제 6-13
//생성자에서 다른 생성자 호출하기 - this()
class Car2 {
String color;
String gearType;
int door;
Car2(){ //생성자 1
this("white", "auto", 4);
}
Car2(String color){ //생성자 2
this(color, "auto", 4);
}
//생성자 1, 2는 this()를 이용하여 생성자 3을 호출한다. 다른 생성자 호출은 반드시 첫째줄에서만 가능!
Car2(String color, String gearType, int door){ //생성자 3
this.color = color;
this.gearType = gearType;
this.door = door;
}
}
class Ex_JS {
public static void main(String[] args) {
Car2 c1 = new Car2(); //생성자 1
Car2 c2 = new Car2("blue"); //생성자 2
System.out.println("c1의 color=" + c1.color + ", gearType=" + c1.gearType + ", door=" + c1.door);
System.out.println("c2의 color=" + c2.color + ", gearType=" + c2.gearType + ", door=" + c2.door);
}
}
출력값:
c1의 color=white, gearType=auto, door=4
c2의 color=blue, gearType=auto, door=4205p. 예제 6-14
//멤버변수의 초기화 예제1
class Ex_JS {
static {
System.out.println("static { }");
} //1. 클래스 변수 초기화 블럭
{
System.out.println("{ }");
} //3. 인스턴스 변수 초기화 블럭 실행
public Ex_JS() {
System.out.println("생성자");
} //4. 멤버(클래스, 인스턴스)변수 초기화 이후 생성자 메서드 실행
public static void main(String[] args) {
System.out.println("Ex_Js bt = new Ex_Js(); "); //2. main메서드 실행
Ex_JS bt = new Ex_JS();
System.out.println("Ex_Js bt2 = new Ex_Js(); "); //5.
Ex_JS bt2 = new Ex_JS();
}
}
출력값:
static { } //클래스 초기화 블럭은 처음 메모리에 로딩될 때 한번만 수행된다.
Ex_Js bt = new Ex_Js(); //인스턴스가 생성 될 때마다 인스턴스 초기화 블럭이 수행된다.
{ }
생성자
Ex_Js bt2 = new Ex_Js();
{ }
생성자206p. 예제 6-15
//멤버변수의 초기화 예제2
class Ex_JS {
static int[] arr = new int[10]; //명시적 초기화(간단한 작업)
//명시적 초기화만으로는 복잡한 초기화 작업이 불가능함. 윗줄처럼 참조형 변수만 생긴것이지 초기화 할 값이 들어가 있지 않음.
static {
for(int i=0; i<arr.length;i++) {
arr[i] = (int)(Math.random()*10) + 1;
} //그래서 static{} 클래스 초기화 블럭을 사용하여 arr의 각 값을 초기화 해준다.
}
public static void main(String[] args) {
for(int i=0; i<arr.length;i++)
System.out.println("arr["+i+"] :" + arr[i]);
}
}
출력값:
arr[0] :5
arr[1] :5
arr[2] :5
arr[3] :7
arr[4] :10
arr[5] :1
arr[6] :1
arr[7] :2
arr[8] :8
arr[9] :10