스터디 프로젝트 - 비디오마을


VideoRent_20150321_최종동작완료.zip



'WEB > JAVA' 카테고리의 다른 글

FINAL  (0) 2015.05.22
OVERRIDE(오버로딩)  (0) 2015.05.22
ABSTRACT CLASS(추상클래스)2  (0) 2015.05.22
ABSTRACT CLASS(추상클래스)1  (0) 2015.05.22
OBJECT CLASS  (0) 2015.05.22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
package com.test;
 
import java.util.Calendar;
 
public class final {
 
    public static void main(String[] args) {
        
        //static 키워드
        //1. (멤버)변수 : 지역변수x, 정적(공용)변수
        //2. 메소드
        
        //public(private) 키워드
        //1. 변수 : 지역변수x
        //2. 메소드
        //3. 클래스
        
        //final 키워드
        //1. 변수 : 지역변수o(붙임) ***
        //2. 메소드
        //3. 클래스
        
        //1. final 변수(= 상수)
        //    : 값을 변경시킬 수 없다
        
        //ex)
        final int n = 10;
        //n=20; 이게 안된다는 뜻
        System.out.println(n);
        
        //주의 : 선언과 초기화를 동시에(*****)
        //final int n2;
        //n2 = 10;
        //System.out.println(n2);
        
        
        //데이터 상수 : 의미가 없음(의미를 표현할 수 없음 -> 가독성 낮음)
        System.out.println(3.14); //파이값
        System.out.println(2*5+5/7);
        
//        double pi = 3.14;
//        System.out.println(20 * pi);
 
        int weight = 70;
        System.out.println(weight);
 
        ///상수는 의미없음 - > 의미 부여 하기 위해 -> 변수(이름) -> 수정 가능! -> 수정 불가능 -> final 상수 -> 의미있는 상수
        //가독성 -> 상수명은 모두 대문자
        final double pi = 3.14;
        //pi = 5.01; 이렇게 파이값이 바뀌면 안되잖아?
        //PI = 5.12;
        
        //Calendar.YEAR = 2;
        System.out.println(1);
        System.out.println(Calendar.YEAR);
        
                
    }
 
}
 
 
//상속시에 발생.,
class FinalA {
    
    //멤버.,
    //.,
    
    //2. final 메소드
    //    - 상속받은 자식 클래스가 재정의할 수 없는 메소드 
    //    - 안정성 문제
    public void test() {
        System.out.println("부모 메소드");
    }
}
 
class FinalB extends FinalA {
    
    //멤버.,
    //.,
    
    //메소드 오버라이딩
    public void test() {
        System.out.println("자식 오버라이딩");
    }
}
 
//3. final 클래스
//    - 프로그램 안정성 문제
//    - 처음부터 상속을 고려하지 않은 클래스 설계
//    - 최종 클래스, 봉인 클래스.,
final class FinalC {
    
    //멤버.,
    //.,
        
}
 
//class finalD extends FinalC {
//}
cs


'WEB > JAVA' 카테고리의 다른 글

비디오마을  (0) 2015.09.10
OVERRIDE(오버로딩)  (0) 2015.05.22
ABSTRACT CLASS(추상클래스)2  (0) 2015.05.22
ABSTRACT CLASS(추상클래스)1  (0) 2015.05.22
OBJECT CLASS  (0) 2015.05.22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package com.test;
 
import java.util.Calendar;
 
public class Override {
 
    public static void main(String[] args) {
        
        //오버로딩, Overloading(Overload)
        //    - 메소드명을 동일하게., 메소드를 여러개 만드는 기술(인자리스트)
        
        //오버라이딩, Overriding(Override)
        //    - 상속할 때 발생 (상속 필수)
        //    - 부모의 메소드명과 자식의 메소드명이 충돌 시 발생되는 현상(기술)
        //    - 안써도 되는 기술., 의도를 알아야., 충돌시 무조건 자식 먼저.,
        
        
        
        //p&c 인스턴스
        OverrideParent p = new OverrideParent();
        p.hello();
        
        OverrideChild c = new OverrideChild();
        c.hello(); //부모꺼
        //c.hi();
        
        //아빠와 자식을 접하는 제 3자 기준.,
        //아빠 -> hello();
        //자식 -> hi();
        
        
        
        //time2 인스턴스
        Time2 t1 = new Time2(5, 20);
        System.out.println(t1.getTime());
        
        //Date/Calendar
        Calendar c1 = Calendar.getInstance();
        System.out.println(c1); //java.util.GregorianCalendar[time=1419568910503
        System.out.println(t1); //com.test.Time2@75b84c92
        
        System.out.println(c1.toString()); //위의 getTime과같은성격., 보다 가독성↑
        System.out.println(t1.toString());
                
        
        
    }//main
}
 
//ex)
class OverrideParent {
    public void hello() {
        System.out.println("안녕하세요~");
    }
}
 
 
class OverrideChild extends OverrideParent {
    //자신만의 인사하는 메소드
    //    -> 부모꺼 hello 쓰기 싫다!!
//    public void hi() {
//        System.out.println("안녕~");
//    }
    
    //부모 메소드를 감추고 자신의 메소드를 사용하는 기술
    //    -> 메소드 오버라이딩(메소드 재정의)
    public void hello() {
        System.out.println("안녕~");
    }
}
 
 
 
 
 
 
 
 
 
//ex) 오버라이딩
//class Time2 extends Object 원형
class Time2 {
    private int hour;
    private int min;
    
    //생성자
    public Time2() {
        this.hour =1;
        this.min = 0;
    }
    
    //오버라이딩
    public Time2(int hour, int min) {
        this.hour = hour;
        this.min = min;
    }
    
    //확인용.,문자열로 받아와서.,
    public String getTime() {
        return this.hour + ":" + this.min; //5:30
    }
    
    //자신(객체)의 데이터를 반환하도록 재정의
    @Override
    public String toString() {
        return this.hour + ":" + this.min;
    }
}
 
 
 
 
cs


'WEB > JAVA' 카테고리의 다른 글

비디오마을  (0) 2015.09.10
FINAL  (0) 2015.05.22
ABSTRACT CLASS(추상클래스)2  (0) 2015.05.22
ABSTRACT CLASS(추상클래스)1  (0) 2015.05.22
OBJECT CLASS  (0) 2015.05.22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package com.test;
 
public class abstract {
 
    public static void main(String[] args) {
        
        Circle c1 = new Circle();
        Rectangle r1 = new Rectangle();
        
        c1.draw();
        r1.draw();
        
        c1.erase();
        r1.erase();
        
    }
 
}
 
 
//도형 클래스
//    - 원, 사각형 클래스
 
//부모 클래스를 일반 클래스? 추상 클래스? 할 지의 기준?
//1. 자식에게 물려줄 멤버만 필요 -> 일반 클래스
//2. 자식에게 물려줄 멤버 + 자식 행동을 표준화 -> 추상 클래스
abstract class Shape {
    
    //ex)2번
    
    //일반멤버
    public String name;
    public int width;
    public int height; 
    
    public void check() {
        System.out.printf("도형 : %s\n", this.name);
    }
    
    //추상멤버
    public abstract void draw();
    public abstract void erase();
}
 
//일반 클래스
class Circle extends Shape {
    
    @Override//추상메소드를 재정의했따..
    public void draw() {
        System.out.println("원을 그립니다.");
    }@Override
    public void erase() {
        System.out.println("원을 지웁니다.");
    }
}
 
class Rectangle extends Shape {
    
    @Override
    public void draw() {
        System.out.println("사각형을 그립니다.");
    }@Override
    public void erase() {
        System.out.println("사각형을 지웁니다.");
    }
}
cs


'WEB > JAVA' 카테고리의 다른 글

FINAL  (0) 2015.05.22
OVERRIDE(오버로딩)  (0) 2015.05.22
ABSTRACT CLASS(추상클래스)1  (0) 2015.05.22
OBJECT CLASS  (0) 2015.05.22
INHERITANCE(상속)  (0) 2015.05.22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
package com.test;
 
public class abstract {
 
    public static void main(String[] args) {
 
        
        //추상 클래스, Abstract Class
        //    - 상속받는 클래스(객체)의 사용법을 표준화 (사용자경험중시)
        //    - 멤버 중 메소드에 대한 제약 사항
        //    - 행동에 대한 강제성 부여
        //    - 부분 구현이 가능
        //    - 추상 메소드를 가림
        //    - 객체 상성 불가능
        //    - 사용 용도 : 일반 클래스의 부모 역할, 참조 변수
        //    - 추상 클래스 = 일반 클래스 + 추상 메소드
        
        //추상 메소드, Abstract Method
        //    - 상속받는 클래스(객체)의 사용법을 표준화
        //    - 구현부가 없는 메소드
        
        
        //주의! 추상클래스는 객체를 생성할 수 없다.(실체화될수x)
        //일반클래스의 부모역할만 한다., 변수는 만들 수 있다. 
        //그러면?.. 자식으로 객체를 만든다.
        //Monitor m1 = new Monitor();
        //m1.on();
        
        LG550 lg = new LG550();
        lg.on();
        lg.off();
        
        HP660 hp = new HP660();
        hp.on();
        hp.off();
    }
 
}
 
//ex) 추상클래스
abstract class Monitor {
    
    //뭘 적느냐?
    //일반 클래스 멤버 구현(변수, 메소드)와
    //추상 메소드
    
    public String model; //모델명
    public int width;      //해상도
    public int hejght;
    
    public void checkModel() {
        System.out.printf("모델명 : %s\n", this.model);
    }
    
    //추상 메소드 선언 - 구현부가 없음(구현이 안된 메소드) {}가 없음
    public abstract void on();
    public abstract void off();
        
}
 
 
//추상 클래스를 부모로 상속
//    -> 반드시(***) 추상 클래스의 추상 메소드와 동일한 메소드를 구현 
class LG550 extends Monitor {
    
    //LG550만의 멈버 추가
    
    public void on() {
        //on()-> ㅗ모니터는 on(0 사용법을 가지고 전원 켜주세요.,
        System.out.println("lG 모니터 켜기");
    }
    
    public void off() {
        System.out.println("LG 모니터 끄기");        
    }
}
 
 
//extends Monitor : LG550과 동일하게 규격을 지키겠습니다.
class HP660 extends Monitor {
    
    //HP660만의 일반 멤버 구현.,
    
    @Override
    public void on() {
        System.out.println("HP660 전원 켜기");
    }
    
    @Override
    public void off() {
        System.out.println("HP660 전원 끄기");
    }
    
    
}
cs


'WEB > JAVA' 카테고리의 다른 글

OVERRIDE(오버로딩)  (0) 2015.05.22
ABSTRACT CLASS(추상클래스)2  (0) 2015.05.22
OBJECT CLASS  (0) 2015.05.22
INHERITANCE(상속)  (0) 2015.05.22
CONSTRUCTOR(생성자)3  (0) 2015.05.22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package com.test;
 
import java.util.Calendar;
 
public class Object {
 
    public static void main(String[] args) {
 
        //Object 클래스
        //오브젝트 클래스는 가장 최상위 클래스이다(단군)
        
        DDD d = new DDD();
        d.a = 10; //증조할배
        d.b = 20; //할배
        d.c = 30; //아버지
        d.d = 40; //자신
         //d,e
 
        
        System.out.println(d.toString()); //출력 : com.test.DDD@15db9742
        System.out.println(d.hashCode());
        
        Calendar c = Calendar.getInstance();
        System.out.println(c);
        System.out.println(c.toString()); //
    }
}
 
//자바는 클래스 선언 시 부모 클래스를 지정하지 않으면
//자동으로 java.lang.Object 클래스를 부모 클래스로 지정한다.
 
//class AAA extends Object {  -> 이게 원형
class AAA {
    public int a;
}
 
class BBB extends AAA {
    public int b;
}
 
class CCC extends BBB {
    //멤버 x 3개
    public int c;
}
 
class DDD extends CCC {
    public int d;
}
 
class EEE extends CCC {
    public int e;
}
cs


'WEB > JAVA' 카테고리의 다른 글

ABSTRACT CLASS(추상클래스)2  (0) 2015.05.22
ABSTRACT CLASS(추상클래스)1  (0) 2015.05.22
INHERITANCE(상속)  (0) 2015.05.22
CONSTRUCTOR(생성자)3  (0) 2015.05.22
CONSTRUCTOR(생성자)2  (0) 2015.05.22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
package com.test;
 
import java.util.Random;
 
public class Inheritance {
 
    public static void main(String[] args) {
        
        //상속,    Inheritance
        //    - 클래스간의 상속
        //    - 뭘 상속?(재산) -> 클래스의 멤버(변수, 메소드)
        //    - 부모 클래스가 가지고 있는 멤버를 자식 클래스에게 물려줘서 자식 코드의 구현을 좀 더 빠르게.,(편하게., 정확하게.,)
        //    - 자식 클래스는 부모가 물려준 멤버를 자신이 직접 선언한것처럼 사용이 가능하다.
        //    - 코드 재사용(************* 생산성↑)
        
        //부모 클래스 vs 자식 클래스
        //기본 클래스 vs 파생 클래스
        //슈퍼 클래스 vs 서브 클래스
        
        Child c = new Child();
        c.a = 10;
        c.b = 10;
        c.Test(); //부모가 물려준
        c.c = 20;
        c.ccc(); //자기가 가진
        
        //c, d 접근 불가
        
        MyRandom rnd = new MyRandom();
        System.out.println(rnd.nextInt()); //1번기능
        System.out.println(rnd.getNum()); //2번기능
        System.out.println(rnd.getColor()); //3번기능
        
    }
}
 
//부모역할
class Parent {
    
    //재산
    public int a;
    public int b;
    public int d; //본인만 쓰기 위한 멤버(자식도 접근을 못함)**
    
    public void Test() {
        
    }
}
//자식 역할
class Child extends Parent {
    
    public int c;
    
    public void ccc() {
         
    }
}
 
 
//랜덤 클래스 -> 자식 클래스 구현
//상황] 난수 발생 잦음
//1. Random 클래스 기능 사용 난수 발생(nextInt, nextBoolean.,)
//2. 정수(5~10사이) -> Random 클래스 기본 기능 x -> 추가 가공
//3. 색상 난수 -> 새로운 기능
 
//확장용(파생)
class MyRandom extends Random {
    
    //1. Random 기본 기능 상속
    
    //2.
    public int getNum() {
        Random rnd = new Random();
        return rnd.nextInt(6) + 5; //5~10사이
    }
    
    //3.
    public String getColor() {
        Random rnd =new Random();
        String[] color = {"red", "orange", "yellow", "green", "blue"};
        return color[rnd.nextInt(color.length)];
    }
 
    
}
cs


'WEB > JAVA' 카테고리의 다른 글

ABSTRACT CLASS(추상클래스)1  (0) 2015.05.22
OBJECT CLASS  (0) 2015.05.22
CONSTRUCTOR(생성자)3  (0) 2015.05.22
CONSTRUCTOR(생성자)2  (0) 2015.05.22
CONSTRUCTOR(생성자)1  (0) 2015.05.22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
package com.test;
 
public class Constructor {
 
    public static void main(String[] args) {
 
        
        //Time인스턴스
        Time t1 = new Time();
        t1.check();
        
        Time t2 = new Time(2, 30, 50);
        t2.check();
        
        Time t3 = new Time(1, 10, 80);
        t3.check(); //1:11:20
        
        Time t4 = new Time(2, 150, 80);
        t4.check(); //4:31:20
        
        Time t5 = new Time(10000);
        t5.check(); //2:46:40
    }
 
}
 
 
//시간 클래스
class Time {
    private int hour;
    private int min;
    private int sec;
    
    //초기화
    public Time() {
        this.hour = 1;
        this.min = 0;
        this.sec = 0; //요청:1시간0분0초가 필요하다
    }
    
    //생성자 오버로딩
    //1. new Time (2, 30, 50)
    //2.추가ask] new Time (2, 70, 50)
    public Time(int hour, int min, int sec) {
/*1        this.hour = hour;
        this.min = min;
        this.sec = sec; */
 
        //초단위 60이 넘을 경우
/*2        //30초 -> 0분 30초
설명용 //70초 -> 1분 10분
        //150초 -> 2분 30초
        if (sec<60) {
            this.sec = sec;
        } else {
            this.min = sec / 60; //1
            this.sec = sec % 60;
        } 조건문 만들 필요가 없다 */
        
        this.min = sec / 60;
        this.sec = sec % 60;
        
        //분단위 60이 넘을 경우
        this.hour = min / 60;
        this.min += min % 60;
        
        this.hour += hour;
    }
    
    //오버로딩 연습 추가
    //new Time(10000) 이거반올림해달라.,
    public Time(int sec) {
        this.min = sec / 60; //160분
        this.sec = sec % 60; //40초
        
        this.hour = this.min / 60; //2시간
        this.min = this.min % 60; //46분
    }
    
    
    //확인용.,
    public void check() {
        System.out.printf("%d:%s:%s\n", this.hour, setFormat(this.min), setFormat(this.sec)); //자릿수 맞춰준 분과 초는 setFormat으로 감싸준다
    }
    
        //분,초 한자리 숫자 -> 두자리 숫자
        //5 -> "05" (숫자->문자열)
        private String setFormat(int num) {
            if (num <10) {
                return "0" + num;
            } else {
                //두자리 숫자
                return num + "";
                
                //숫자->문자열 정석st
                //String.valueOf(100);
            }
        }
} 
cs


'WEB > JAVA' 카테고리의 다른 글

OBJECT CLASS  (0) 2015.05.22
INHERITANCE(상속)  (0) 2015.05.22
CONSTRUCTOR(생성자)2  (0) 2015.05.22
CONSTRUCTOR(생성자)1  (0) 2015.05.22
STATIC(정적)2  (0) 2015.05.22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
package com.test;
 
public class Constructor {
 
    public static void main(String[] args) {
        
        //생성자
        //    -> 객체(객체 멤버 변수)를 초기화하는 역할
        
        //3. Size 인스턴스
        Size s1 = new Size();
        s1.check();
        
        //5.
        Size s2 = new Size(200, 300); //오버로딩:붕어빵에 생크림 넣어준st.,
        s2.check();
        
        Size s3 = new Size(500);
        s3.check();
        
        //Test t1 = new Test(); x 안됨
        Test t2 = new Test(5);
    }
 
}
 
//사이즈 클래스
class Size {
    
    private int width;  //너비
    private int height; //높이
    
    //private 멤버 변수를 (값을 넣기 위해)접근할 수 있는 방법
    //1. 생성자
    //    - 객체 생성 시 1회
    //    - 재호출 불가능
    //2. setter
    //    - 초기화 역할 병행
    //    - 수시로 객체의 상태를 변경
    
    //ex)1. 생성자 연습
    //기본 생성자 -> 모든 객체가 동일한 상태로 초기화가 된다.
    public Size() {
        this.width = 100;
        this.height = 100;
    }
    
        //4. 생성자 오버로딩
        //    - 오버로딩 : 메소드명을 동일하게 생성하는 기술(인자리스트 달리해서.,)
        //    - 생성자도 메소드
        //    - 객체의 초기화를 다양하게 지원하기 위해서 만드는 것(****)
        public Size(int width, int height) {
            this.width = width;
            this.height = height;
        }
        
        //6.오버로딩 더하기 : 너비는 설정하고 높이는 기본값으로 하고싶다.,
        public Size(int width) {
            this.width = width;
            this.height = 100;
        }
    
        //2. 확인용 메서드
        public void check() {
            System.out.printf("width:%d, height:%d\n"
                                ,this.width
                                ,this.height);
        }
                
}
 
//생성자 주의사항
class Test {
    
    private int a;
    
    //생성자가 1개도 없으면., 자동으로 기본 생성자를 만들어 준다.
    //생성자가 1개 이상이 있으면., 기본 생성자를 안만들어 준다.
    public Test(int a) {
        this.a = a;
    }
    
    //되도록 기본 생성자는 항상 만들어줘라! (권장)
    public Test() {
        this.a = 10;
    }
    
}
cs


'WEB > JAVA' 카테고리의 다른 글

INHERITANCE(상속)  (0) 2015.05.22
CONSTRUCTOR(생성자)3  (0) 2015.05.22
CONSTRUCTOR(생성자)1  (0) 2015.05.22
STATIC(정적)2  (0) 2015.05.22
STATIC(정적)1  (0) 2015.05.22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package com.test;
 
public class Constructor {
 
    public static void main(String[] args) {
        
        //생성자, Constructor
        
        //3
        Location l1 = new Location();
        l1.setX(100);
        l1.setX(200);
        
        System.out.printf("l1 : x(%d), y(%d)\n", l1.getX(), l1.getY());
        
        Location l2 = new Location();
        System.out.printf("l2 : x(%d), y(%d)\n", l2.getX(), l2.getY()); //이게 정석st
    }
 
}
 
//ex] 지도에서 위치
class Location {
    
    //1
    private int x;
    private int y;
    
    //생성자란..
    //    - 멤버를 초기화하는 (특수)전용 메소드
    //    - 객체 생성시 자동으로 호출 -> 다른 용도로는 호출 불가능
    //    - 접근지정자 : public
    //    - 반환타입 : 기재 안함(void 쓸 수 없음)
    //    - 나머지 : 일반 메소드와 동일
    //    - 메소드명 : 클래스명과 동일
    
    //컴파일러 자동으로 추가
    public Location() {
        this.x = 100;
        this.y = 50;
    }
    
    //2
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
    
            
    
}
cs


'WEB > JAVA' 카테고리의 다른 글

CONSTRUCTOR(생성자)3  (0) 2015.05.22
CONSTRUCTOR(생성자)2  (0) 2015.05.22
STATIC(정적)2  (0) 2015.05.22
STATIC(정적)1  (0) 2015.05.22
ACCESS(접근지정자)  (0) 2015.05.22

+ Recent posts

티스토리툴바