gnuykob_sw

1. 패키지

- 관련 있는 클래스들을 하나로 묶은 것

- 내장 패키지 & 사용자 정의 패키지

- '이름 공간' - 동일한 이름의 클래스가 각 다른 패키지에 속할 수 있어 이름 충돌을 방지할 수 있음

- 세밀한 접근 제어 구현 가능 

- 파일의 맨 처음에 package 이름;

2. 패키지 사용

- 완전한 이름으로 참조하기 (패키지 이름이 클래스 앞에 붙음)

graphics.Rectangle myRect = new graphics.Rectangle();

 - 패키지 안에서 원하는 클래스만 포함하기

import graphics.Rectangle;

Rectangle myRect = new Rectangle();

- 패키지 안의 모든 클래스 포함하기

import graphics.*;

Rectangle myRect = new Rectangle();

3. 계층 구조의 패키지 

- ex) java - awt - font 구조의 패키지들이 있을 때,

java.awt.*를 포함시키면 java.awt.font 패키지는 자동으로 포함되지 않음!

별도로 포함시키기

import java.awt.*;
import java.awt.font.*;

4. 클래스 파일 로드

- 자바 소스 파일이 컴파일되면 .class 확장자를 가지는 클래스 파일로 변환되고 파일 시스템에 저장됨

- 클래스 파일은 JVM에 의해 로드됨

5. JVM이 클래스를 찾는 순서와 방법

- 부트스트랩 클래스

    - 자바 플랫폼을 구성하는 핵심적인 클래스

    - 디렉터리 jre/lib에 있는 여러 jar 파일들

- 확장 클래스

    - 자바 확장 메커니즘 사용하는 클래스

    - 확장 디렉터리에 있는 jar 파일들

- 사용자

    - 확장 메커니즘을 활용하지 않는 개발자 및 타사에서 정의한 클래스

- 방법

    - 현재 디렉터리 찾음

    - 일반적으로는 환경 변수인 CLASSPATH에 설정된 디렉터리에서 찾음

6. 자바 API 패키지

7. Object 클래스

- java.lang 패키지에 들어있음

- 자바 클래스 계층 구조에서 맨 위에 위치하는 클래스

- 메소드

- getClass() : 객체가 어떤 클래스로 생성되었는지에 대한 정보 반환

class Circle {  }
public class CircleTest {
    public static void main(String[] args) {
        Circle obj = new Circle();
        System.out.println("obj is of type " + obj.getClass().getName());
        System.out.println("obj의 해쉬코드=" + obj.hashCode());
    }
}

// obj is of type test.Circle
// obj의 해쉬코드=1554547125

- toString() : 객체의 문자열 표현 반환

- equals() : == 연산자 사용해서 객체의 주소가 동일한지 검사

8. Wrapper 클래스

- 정수와 같은 기초 자료형을 객체로 포장하고 싶은 경우 사용

int i = 100;
Integer obj = new Integer(i);

- 메소드

- 문자열 "100" -> 정수 100 : Integer.parseInt()

- 정수 100 -> 문자열 "100" : Integer.toString()

9. 오토박싱

- intValue() 대신

- 랩퍼 객체와 기초 자료형 사이의 변환을 자동으로 해주는 기능

Integer obj;

obj = 10;                      // 정수 -> Integer 객체
System.out.println(obj + 1);   // Integer 객체 -> 정수

10. String 클래스

- 메소드

11. String 클래스의 문자열 기초 연산

- length() : 문자열 길이 반환

- charAt() : String 객체 안에 들어있는 문자 추출 (문자 번호는 0부터 시작)

String s = "Hello World!"
char c = s.charAt(0);         // 'H' 반환

- 2개의 문자열 붙이는 방법

    - concat()

    - + 연산자   (** 더 편함!)

- indexOf() : 문자열 안에서 단어 찾기

String s = "The cat is on the table";
int index = s.indexOf("table");

if(index == -1)
    System.out.println("table은 없습니다.");
else
    System.out.println("table의 위치: " + index);

// table의 위치: 18

    - 같은 단어가 여러 번 있는 경우 가장 처음에 나오는 단어의 인덱스 반환

    - 모두 찾고 싶은 경우 반복문 이용!

- split() : 문자열을 단어로 분리

String[] tokens = "I am a boy.".split(" ");
for (String token : tokens)
    System.out.println(token);

/**
I
am
a
boy
**/

- boolean contains(charSequence s) : s에 지정된 문자들을 포함하고 있으면 true 리턴

- String replace(Charsequence target, Charsequence replacement) : target이 지정하는 일련의 문자들을 replacement가 지정하는 문자들로 변경한 문자열 객체 리턴

- String subString(int beginIndex) : beginIndex 인덱스부터 시작하는 부분 문자열 반환

- String subString(int beginIndex, int endIndex) : beginIndex부터 endIndex(포함x)까지의 부분 문자열 반환

- String trim() : 문자열 앞뒤의 공백 문자들을 제거한 문자열 객체 반환

12. StringBuffer 클래스

- String 클래스의 경우 빈번하게 문자열을 변경할 때 비효율적

∵ 새로운 String 객체를 생성하고 기존의 내용을 복사해야 하기 때문

- 메소드

    - append()

    - insert()

    - 어떤 타입의 데이터도 받을 수 있도록 중복 정의 되어있음

StringBuffer sb = new StringBuffer("Hello");   // 16바이트 공간 할당
int length = sb.length();        // 5
int capacity = sb.capacity();    // 21

StringBuffer sb = new StringBuffer("10+20=");
sb.append(10+20);
sb.insert(0, "수식 ");
// sb = "수식 10+20=30"

13. Math 클래스

- 지수, 로그, 제곱근, 삼각함수와 같은 기본적인 수치 연산을 위한 메소드 제공

14. Random 클래스

- 난수 발생

import java.util.*;
public class RandomTest {
    public static void main(String[] args) {
        Random random = new Random();
        for (int i = 0; i < 10; i++) 
            System.out.print(random.nextInt(100) + ", ");
    }
}

// 12, 48, 9, 3, 44, 84, 60, 4, 34, 50,

15. Array 클래스

import java.util.*;

public class ArraysTest {
    public static void main(String[] args) {
        int[] array = {9, 4, 5, 6, 2, 1};
        Arrays.sort(array);               // 정렬
        printArray(array);
        System.out.println(Arrays.binarySearch(array, 9));     // 9 탐색
        Arrays.fill(array,8);       // 배열 8로 채움
        printArray(array);
    }
    
    private static void printArray(int[] array) {
        System.out.print("[");
        for(int i = 0; i < array.length; i++)
            System.out.print(array[i] + " ");
        System.out.println("]");
    }
}

/**
[1 2 4 5 6 9 ]
5
[8 8 8 8 8 8 ]

16. Calender 클래스

- 추상 클래스, 날짜와 시간에 대한 정보

- 특정 시각을 연도, 월, 일 등으로 변환하는 메소드

17. 예외처리

- 오류가 발생했을 때 오류를 사용자에게 알려주고, 모든 데이터를 저장하게 한 후에 사용자가 프로그램을 종료할 수 있도록 하는 것이 바람직!

- 예외: 잘못된 코드, 부정확한 데이터, 예외적인 상황에 의해 발생하는 오류

- ex) 0으로 나누는 연산, 배열의 인덱스가 한계를 넘는 경우, 디스크에서 하드웨어 오류 발생 등

public class DivideByZero {
    public static void main(String[] args) {
        int result = 10 / 0;
        System.out.println("나눗셈 결과: " + result);
    }
}

// 오류

18. try-catch 블록

try {
    // 예외가 발생할 수 있는 코드
} catch (예외 클래스 변수) {
    // 예외를 처리하는 코드
}
// 아래 구문은 생략 가능
} finally {
    // 여기 있는 코드는 try 블록이 끝나면 무조건 실행됨
}

-ex)

import java.util.Scanner;

public class DivideByZeroOk {
    public static void main(String[] args) {
        try {
            int retult = 10 / 0;   // 예외 발생
        } catch (ArithmeticException e) {
            System.out.println("0으로 나눌 수 없습니다.");
        }
        System.out.println("프로그램은 계속 진행됩니다.");
    }
}

// 0으로 나눌 수 없습니다.
// 프로그램은 계속 진행됩니다.

19. 예외의 종류

- Error : 너무 심각해서 할 수 있는 방법이 없음 -> 통과

- RuntimeException : 프로그래밍 버그이므로 스스로 고쳐야 함 -> 통과

- Error나 RuntimeException이 아닌 예외 : 반드시 처리해야 함!! -> 검사

// 배열 인덱스 예외 처리

public class ArrayError {
    public static void main(String[] args) {
        int [] array = { 1, 2, 3, 4, 5 };
        int i = 0;
        
        try  {
            for (i = 0; i <= array.length; i++)
                System.out.print(array[i] + " ");
        } catch ArrayIndexOutOfBoundsException e) {
            System.out.pritnln("인덱스 " + i + "는 사용할 수 없네요!");
        }
    }
}

// 1 2 3 4 5 인덱스 5는 사용할 수 없네요!

// 입력 예외 처리

public class ExceptionTest3 {
    public static void main(String[] args) {
        try { 
            int num = Integer.parseInt("ABC");
            System.out.println(num);
        } catch (NumberFormatException e) {
            System.out.println("NumberFormat 예외 발생");
        }
    }
}

20. try - with - resources 문장

- 문장의 끝에서 리소스들이 자동으로 닫혀지게 함

import java.io.*;

public class TryTest {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("test.txt")) {
            char[] a = new char[50];
            fr.read(a);
            for (char c : a)
                System.out.print(c);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

21. 예외 떠넘기기

- 가끔 메소드가 발생되는 예외를 그 자리에서 처리하지 않고, 자신을 호출한 상위 메소드로 전달하는 편이 더 적절할 수 있음

import java.io.*;

pulbic class ExceptionTest {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("test.txt");
        char[] a = new char[50];
        fr.read(a);
        for (char c : a)
            System.out.print(c);
    }
}

1. 상속

- 부모 클래스에 정의된 멤버 변수, 메소드를 자식 클래스가 물려 받음

- class 자식 extends 부모 { }

class Car {
    int speed;
    public void setSpeed(int Speed) {
        this.speed = speed;
    }
}

public class EletricCar extends Car {
    int battery;
    public void charge(int amount) {
        battery += amount;
    }
}

public class ElectricCarTest {
    public static void main(String[] args) {
        ElectricCar obj = new ElectricCar();
        
        obj.speed = 10;
        obj.setSpeed(60);
        obj.charge(10);
    }
}

- 상속 -> 이미 존재하는 클래스의 필드와 메소드 재사용 -> 중복되는 코드 줄일 수 있음

2. 자바 상속의 특징

- 다중 상속 지원하지 않음 (여러 개의 클래스로부터 상속 X)

- 다단계 상속은 가능 (A / B extends A / C extends B)

- 상속의 횟수에는 제한 없음 (자식 클래스의 개수 상관 X)

- 상속 계층 구조의 최상위에는 java.lang.Object 클래스가 있음

    - 모든 클래스의 부모 클래스

    - toString( ) 메소드

- 다른 패키지의 클래스도 상속 가능 (패키지.클래스 import 필요)

class Animal {
    int age;
    void eat() {
        System.out.println("먹고 있음 ... ");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("짖고 있음 ...");
    }
}

public class DogTest {
     public static void main(String[] args) {
         Dog d = new Dog();
         d.bark();
         d.eat();
     }
 }
 
 // 짖고 있음 ...
 // 먹고 있음 ...

class Shape {
    int x, y;
}

class Circle extends Shape {
    int radius;
    public Circle(int radius) {
        this.radius = radius;
        x = 0;
        y = 0;
    }
    
    double getArea() {
        return 3.18 * radius * radius;
}

public class CircleTest {
    public static void main(String[] args) {
        Circle obj = new Circle(10);
        System.out.println("원의 중심: (" + obj.x + "," + obj.y + ")");
        System.out.println("원의 면적: " + obj.getArea());
    }
}

// 원의 중심: (0,0)
// 원의 면적: 314.0

3. 상속과 접근 지정자

- 자식 클래스는 부모 클래스의 public 멤버, protected 멤버, 디폴트 멤버(같은 패키지에 있는 경우) 상속 받음

- private 멤버는 상속되지 않음!

4. 상속과 생성자 

- 자식 클래스의 객체가 생성될 때 부모 클래스의 생성자도 호출됨!

class Base {
    public Base() {
        System.out.println("Base() 생성자");
    }
}

class Derived extends Base {
     public Derived() {
         System.out.println("Derived() 생성자");
     }
 }
 
 public class Test {
     public static void main(String[] args) {
         Derived r = new Derived();
     }
 }
 
 
// Base() 생성자
// Derived() 생성자

- 자식 클래스 객체 안에는 부모 클래스에서 상속된 부분이 들어있음

-> 부모 클래스 부분을 초기화하기 위해 부모 클래스의 생성자도 호출됨

- 순서) (부모 클래스 생성자) -> (자식 클래스 생성자)

5. 명시적인 생성자 호출

- super();  : 부모 클래스의 생성자 호출

class Base {
    public Base() {
        System.out.println("Base() 생성자");
    }
}

class Derived extends Base {
     public Derived() {
         super();
         System.out.println("Derived() 생성자");
     }
 }

class TwoDimPoint {
    int x, y;
    
    public TwoDimPoint() {
        x = y = 0;
    }
    
    public TwoDimPoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

class TreeDimPoint extends TwoDimPoint {
    int z;
    public ThreeDimPoint(int x, int y, int z) {
        super(x, y);
        this.z = z;
    }
}

- 이 경우 부모 클래스의 두 생성자 중 TwoDimPoint(int x, int y)가 호출됨

- 인수의 형태에 따라 적절한 생성자 선택

6. 묵시적인 생성자 호출

class Base {
    public Base() {
        System.out.println("Base() 생성자");
    }
}

class Derived extends Base {
     public Derived() {
         System.out.println("Derived() 생성자");
     }
 }

- 컴파일러는 부모 클래스의 기본 생성자가 자동으로 호출되도록 함

- 묵시적인 생성자 호출을 하려면 부모 클래스에 기본 생성자(매개 변수가 없는 생성자)가 반드시 정의되어 있어야 함!

7. 메소드 오버라이딩

- 자식 클래스가 부모 클래스의 메소드를 자신의 필요에 맞춰 재정의하는 것

- 메소드 이름이나 매개 변수, 반환형은 같아야 함!

class Shape {
    public void draw() { System.out.println("Shape"); }
}

class Circle extends Shape {
    @override
    public void draw() { System.out.println("Circle을 그립니다."); }
}

class Rectangle extends Shape {
    @override
    public void draw() { System.out.println("Rectangle을 그립니다."); }
}

class Triangle extends Shape {
    @override
    public void draw() { System.out.println("Triangle을 그립니다."); }
}

public class ShapeTest {
    public static void main(String[] args) {
        Rectangle s = new Rectangle();
        s.draw();
    }
}

// Rectangle을 그립니다.

- Rectangle 클래스의 객체에 대해 메소드가 호출되면 Rectangle 클래스 안에서 오버라이딩된 draw()가 호출됨

- 철자를 잘못 쓰는 경우 컴파일러는 새로운 메소드로 인식하기 때문에 오버라이드가 일어나지 않음

-> @Override 어노테이션을 앞에 붙이면 이러한 경우 오류 발생시키므로 붙이는 것이 좋음!

8. 오버라이딩 & 오버로딩

- 오버로딩 (overloading) : 같은 이름을 가진 여러 개의 메소드 작성

- 오버라이딩 (overriding) : 부모 클래스의 메소드를 자식 클래스가 다시 정의하는 것

9. 정적 메소드 오버라이드

- 어떤 참조 변수를 통해 호출되는지에 따라 달라짐

class Animal {
    public static void A() {
        System.out.println("static method in Animal");
    }
}

public class Dog extends Animal {
    public static void A() {
        System.out.println("static method in Dog");
    }
    
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal a = dog;
        a.A();
        dog.A();
    }
}

// static method in Animal
// static method in Dog

10. 키워드 super 

- super는 상속 관계에서 부모 클래스의 메소드나 필드를 명시적으로 참조하기 위해 사용됨

- 부모 클래스의 메소드를 오버라이딩한 경우에 super를 사용하면 부모 클래스의 메소드 호출 가능

class Shape {
    public void draw() {
        System.out.println("Shape 중에 하나를 그릴 예정입니다.");
    }
}

class Circle extends Shape {
    @Override
    public void draw() {
        super.draw();              // 부모 클래스의 draw 호출 
        system.out.println("Circle을 그립니다.");
    }
}

public class ShapeTest {
    public static void main(String[] args) {
        Circle s = new Circle();
        s.draw;
    }
}

// Shape 중에 하나를 그릴 예정입니다.
// Circle을 그립니다.

11. 다형성

- 오버로딩은 컴파일 시간에서의 다형성 지원

- 메소드 오버라이딩은 실행 시간에서의 다형성 지원

- 다형성: 객체들의 타입이 다르면 똑같은 메시지가 전달되더라도 서로 다른 동작을 하는 것

- 동일한 코드로 다양한 타입의 객체를 처리할 수 있는 기법

12. 업캐스팅

- 부모 클래스 변수로 자식 클래스 객체 참조 가능! 

- 자식 클래스의 필드와 메소드에는 접근할 수 없음

- 자식 클래스의 부모 클래스 부분만 접근 가능!

- ex) Rectangle 클래스의 x, y (O) // width, height (X)

- 부모 클래스로 캐스팅 된다는 것은 멤버의 갯수 감소 의미! (부모 클래스의 멤버만 접근 가능)

- 업캐스팅을 하고 메소드를 실행할때 자식 클래스에서 오버라이딩한 메소드가 있을 경우, 오버라이딩 된 메소드가 실행됨!

// ex) Rectangle, Triangle, Circle 등의 도형 클래스가 부모 클래스인 Shape 클래스로부터 상속된 경우

class Shape {
    protected int x, y;      // 모든 도형의 공통 속성인 위치 기준점 (x, y)
    public void draw() { System.out.println("Shape draw"); }
}

class Rectangle extends Shape {
    private int width, height;
    public void draw() { System.out.println("Rectangle draw"); }
}

class Triangle extends Shape {
    private int base, height;
    public void draw() { System.out.println("Triangle draw"); }
}

class Circle extends Shape {
    private int radius;
    public void draw() { System.out.println("Circle draw"); }
}

public class ShapeTest {
    public static void main(String[] args) {
        Shape s1, s2;
        
        s1 = new Shape();
        s2 = new Rectangle();
    }
}

publc class ShapeTest {
    public static void main(String[] args) {
        Shape s = new Rectangle();
        // 업캐스팅
        // s는 Shape 타입, Rectangle 객체 가리킴
        
        Rectangle r = new Rectangle();
        
        s.x = 0;
        x.y = 0;
        //s.width = 100;    -> 오류!
        //s.height = 100;   -> s로 Rectangle의 필드와 메소드에 접근할 수 없음
    }
}

- 다운캐스팅: 부모 객체를 자식 참조 변수로 참조하는 것, 명시적으로 해야 함

class Parent {
    void print() { System.out.println("Parent 메소드 호출"); }
}

class Chile extends Parent {
    @Override void print() { System.out.println("Child 메소드 호출"); }
}

public class Casting {
    public static void main(String[] args) {
        Parent p = new Child();   // 업캐스팅: 자식 객체를 부모 객체로 형변환
        p.print();                // 동적 메소드 호출, 자식의 print() 호출
        
        // Child c = new Parent();  -> 컴파일 오류!
        
        Child c = (Child)p;       // 다운캐스팅: 부모 객체를 자식 객체로 형변환
        c.print();                // 메소드 오버라이딩, 자식의 print() 호출
    }
}

// Child 메소드 호출
// Child 메소드 호출

13. 업캐스팅 하는 이유

- 공통적으로 할 수 있는 부분을 만들어 간단하게 다루기 위해

- 상속 관계에서 상속 받은 자식 클래스가 몇 개이든 하나의 인스턴스로 묶어서 관리할 수 있기 때문

// 기존
Rectangle[] r = new Rectangle[];
r[0] = new Rectangle();
r[1] = new Rectangle();
 
Triangle[] t = new Triangle[];
t[0] = new Triangle();
t[1] = new Triangle();
 
Circle[] c = new Circle[];
c[0] = new Circle();
c[1] = new Circle();

// 업캐스팅
Shape[] s = new Shape[];
s[0] = new Rectangle();
s[1] = new Rectangle();
s[2] = new Triangle();
s[3] = new Triangle();
s[4] = new Circle();
s[5] = new Circle();

- 하나의 타입으로 묶어 배열을 구성

- 코드량도 훨씬 줄어들고 가독성도 좋아지며 유지보수성도 좋아짐

- 자식 고유의 메소드 실행하려면 다운캐스팅

14. 동적 바인딩

- 업캐스팅: 여러 가지 타입의 객체를 하나의 자료구조 안에 모아서 처리하려는 경우에 필요

- 도형 클래스 예제) 각 도형을 그리는 방법은 모두 다르기 때문에 종류에 따라 다른 draw() 호출해야 함

- Shape 클래스가 draw() 갖고 있고, 자식 클래스들이 이 draw() 오버라이딩 한 경우

public class ShapeTest {
    public static void main(String[] args) {
        Shape[] arrayOfShapes;         // Shape의 배열 arrayOfShapes[] 선언
        arrayOfShapes = new Shape[3];
        
        // 배열 arrayOfShapes의 각 원소에 객체를 만들어 대입
        // 다형성에 의해 Shape 객체 배열에 모든 타입의 객체 저장 가능
        arrayOfShapes[0] = new Rectangle();
        arrayOfShapes[1] = new Triangle();
        arrayOfShapes[2] = new Circle();
        
        for (int i = 0; i < arrayOfShapes.length; i++) {
            arrayOfShapes[i].draw();
        }
    }
}

// Rectangle draw
// Triangle draw
// Circle draw

15. 업캐스팅의 활용

- 메소드의 매개 변수를 부모 타입으로 선언하면 훨씬 넓은 범위의 객체 받을 수 있음

- 부모 클래스에서 파생된 모든 클래스의 객체를 다 받을 수 있음

public class ShapeTest {
    public static void print(Shape s) {
        System.out.println("x= " + s.x + " y= " + s.y);
    }
    
    public static void main(String[] args) {
        Rectangle s1 = new Rectangle();
        Triangle s2 = new Triangle();
        Circle s3 = new Circle();
        
        print(s1);
        print(s2);
        print(s3);
    }
}

16. instanceof 연산자

- 변수가 가리키는 객체의 실제 타입 반환

17. 종단 클래스와 종단 메소드

- 종단 클래스(final class) : 상속시킬 수 없는 클래스

- 보안상의 이유로 주로 사용

- 서브 클래스에서 재정의 불가

final class String {
    ...
}

class Baduk {
    enum Player { WHITE, BLACK }
    ...
    final Player getFirstPlayer() {
        return Player.BLACK;
    }
}

1. 객체지향 프로그래밍

- 데이터와 함수를 하나의 덩어리로 묶어서 생각하는 방법: 캡슐화

public class Circle {
	double radius;           // data
	String color;            // data
	double getArea() {return 3.14*radius*radius; }   // func
}

2. 정보 은닉

- 객체의 외부에서는 내부 데이터와 알고리즘을 볼 수 없게 함

- 공개된 인터페이스를 통해서만 객체에 접근하도록

3. 상속

- 이미 작성된 클래스(부모 클래스)를 이어받아서 새로운 클래스(자식 클래스) 생성 가능

- 자식 클래스는 부모의 속성과 동작 물려받음

4. 클래스

- 객체에 대한 설계도 (틀)

- 클래스로부터 만들어지는 각각의 객체 -> '인스턴스'

- 하나의 클래스로 여러 인스턴스를 만들어내지만, 인스턴스마다 속성의 값은 다름

public class Circle {
    // 필드
    public int radius;
    public String color;
    
    // 메소드
    public double getArea() {
        return 3.14*radius*radius;
    }
}

5. 객체 생성

- 참조 변수 선언

//Type   변수명  
 Circle   obj;

- 객체 생성

//변수       객체의 참조값
  obj = new Circle();

public class CircleTest {
    public static void main(String[] args) {
        // 참조 변수 선언
        Circle obj;
        
        // 객체 생성 & 객체의 참조값 -> 참조 변수에 저장
        obj = new Circle();
        
        // 객체의 필드 사용
        obj.radius = 100;
        obj.color = "blue";
        
        // 객체의 메소드 사용
        double area = obj.getArea();
        System.out.println("원의 면적= " + area);
    }
}

6. 참조 변수

- 객체 를 참조할 때 사용되는 변수 - 객체의 참조값이 저장되어 있음

- 참조값은 일반적으로 객체의 주소

- 자바에서 모든 객체는 new 연산자를 이용해야 생성됨

public class DeskLamp {
    // 인스턴스 변수 정의
    private boolean isOn;
    
    // 메소드 정의
    public void turnOn()  { isOn = true; }
    public void turnOff() { isOn = false; }
    public String toString() {
        return "현재 상태는" + (isOn == true ? "켜짐" : "꺼짐");
    }
}

public class DeskLampTest {
    public static void main(String[] args) {
        // 객체 생성
        DeskLamp myLamp = new DeskLamp();
        
        // 객체의 메소드 호출
        myLamp.turnOn();
        System.out.println(myLamp);
        myLamp.turnOff();
        System.out.println(myLamp);
    }
}

7. 메소드 오버로딩

- 이름이 동일한 여러 개의 메소드 작성 가능

- 매개변수의 수, 타입, 순서 등이 달라야 함

public class MyMath {
    int add(int x, int y)          { return x+y; }
    int add(int x, int y, int z)   { return x+y+z; }
    int add(int x, int y, int z, int w)   { return x+y+z+w; }
    
    public static void main(String[] args) {
        MyMath obj;
        obj = new MyMath();
        System.out.println(obj.add(10, 20));
        System.out.println(obj.add(10, 20, 30));
        System.out.println(obj.add(10, 20, 30, 40));
    }
}

8. 생성자

- 객체가 생성될 때 객체를 초기화하는 특수한 메소드

- 중복 정의 가능

class Pizza {
    int size;
    String type;
    public Pizza 90 {
        size = 12;
        type = "슈퍼슈프림";
    }
    
    public Pizza(int s, String t) {
        size = s;
        type = t;
    }
}

public class PizzaTest {
    public static void main(String[] args) {
        Pizza obj1 = new Pizza();
        System.out.println("(" + obj1.type + ", " + obj1.size + ",)");
        
        Pizza obj2 = new Pizza(24, "포테이토");
        System.out.println("(" + obj2.type + ", " + obj2.size + ",)");

9. 기본 생성자

- 매개변수 없는 생성자

- 생성자 하나도 정의하지 않으면 컴파일러가 자동으로 기본 생성자 만듦

10. this 참조 변수

- 현재 객체 자신을 가리키는 참조 변수

- 컴파일러에서 자동으로 생성

- 생성자에서 매개 변수 이름과 필드 이름이 동일한 경우에 사용

public Circle (int radius) {
    this.radius = radius;
}

11. this()

- 다른 생성자 의미

12. 접근 제어

- private: 클래스 안에서만 접근 가능

- public: 누구나 접근 가능

- protected: 자식 클래스만 접근 가능

- 접근지정자 x (default) : 동일 패키지 안에서만 접근 가능

13. 접근자와 설정자

- 접근자 (getters) 메소드: 필드값 반환

- 설정자 (setters) 메소드: 필드값 설정

- 접근자와 설정자 메소드만을 통해 필드에 접근해야 함!

- 설정자에서 매개변수를 통해 잘못된 값이 넘어오는 경우, 이를 사전에 차단할 수 있음

- 필요할 때마다 필드값을 동적으로 계산하여 반환할 수 있음

- 접근자만 제공 -> 읽기만 가능한 필드 만들 수 있음

- Source 메뉴에서 자동 입력 가능

class Account {
    private int regNumber;
    private String name;
    private int balance;
    
    // 접근자
    public String getName() {
    	return name;
    }
    
    // 설정자
    public String setName(String name) {
    	this.name = name;
    }
    
    public int getBalance() {
    	return balance;
    }
    
    public int setBalance(int balance) {
    	this.balance = balance;
    }
}

14. 객체의 소멸과 가비지 컬렉션

- 객체 삭제 연산자 없음

- 자동 메모리 시스템 사용: 가비지 컬렉션

- 가비지 컬렉터: 힙 메모리에서 더이상 필요없는 객체를 찾아 지움

- 가비지 컬렉션 요청 -> 모든 다른 애플리케이션 멈춤 -> JVM이 실행 여부 판단

System.gc;

15. 인수전달 방법

- 기본적으로 Call by value

- 객체를 메소드로 전달 -> 객체의 참조값만 복사되어 전달됨

- 참조 변수는 참조값(주소) 갖고 있음

- 배열도 객체 -> 배열 전달은 배열 참조 변수를 복사하는 것

public class ArrayArgumentTest {
	public static double minArray(double[] list) {
    	double min = list[0];
        for (int i = 1; i < list.length; i++) {
        	if(list[i] < min) 
            	min = list[i];
        }
        return (min);
    }
    
    public static void main(String[] args) {
    	double[] a = { 1.1, 2.2, 3.3, 4.4, 0.1, 0.2 };
        double[] b = { -2.0, 3.0, -9.0, 2.9, 1.5 };
        double min;
        
        min = minArray(a);
        System.out.println("첫번째 배열의 최솟값= " + min);
        min = minArray(b);
        System.out.println("두번째 배열의 최솟값= " + min);
    }
}

// 0.1
// -9.0

16. 정적 멤버

- 여러 개의 객체가 하나의 변수를 공유해야 하는 경우 

-> 이러한 멤버를 정적 멤버 (static member) / 클래스 멤버 (class member) 라고 함 

- 정적 변수: 클래스 당 하나만 생성되는 변수

- 여러 개가 존재할 수 있음, 한개의 static 변수는 한 번 선언됨

- 클래스를 통한 접근

Television.count = 100;

- 객체를 통한 접근

Television obj = new Televison();
obj.count = 100;

- 정적 메소드: 객체를 생성하지 않고 클래스 이름으로 접근해서 사용 가능

public class Math {
	public static double sqrt(double a) {
    	...
    }
}
...
double value = Math.sqrt(9.0);  // 클래스.함수명 으로 사용

17. 정적 변수의 활용

- 정적 메소드는 정적 멤버만 사용할 수 있음

class Test {
    int a;              // 인스턴스 변수
    static int b;       // 정적 변수
    
    void sub1() { a = 0; }         // OK
    static void sub2() { a = 0; }  // 오류! 정적 메소드에서는 인스턴스 멤버 사용할 수 없음

- 정적 메소드에서 정적 메소드를 호출하거나 정적 멤버를 사용하는건 가능

- 정적 메소드는 this를 사용할 수 없음

class Test {
    static int a;
    static void sub(int x) { this.a = x; }    // 오류!

- main()도 정적 메소드이기 때문에 인스턴스 메소드를 호출할 수 없음

- 정적 메소드는 main()에서 호출 가능!

public class Test {
    public static int cube(int x) {
        int result = x*x*x;
        return result;
    }
    
    public static void main(String args[]) {
        System.out.println("10*10*10은 " + cube(10));   // 정적 메소드 호출
    }
}

18. final 키워드

- 필드에 final을 붙이면 상수가 됨

- static과 동시에 사용하는 경우 많음

public class Car {
    static final int MAX_SPEED = 100;
}

- 상수는 클래스 변수로 만들어서 공유하는 것이 메모리 공간 절약

19. 싱글톤 패턴

- 객체 중 전체 시스템을 통틀어서 딱 하나만 존재해야 하는 것들이 있음

- ex) 환경설정 클래스, 네트워크 연결 풀 / 스레드 풀을 관리하는 클래스들

- 싱글톤 패턴은 하나의 프로그램 내에서 하나의 인스턴스만을 생성해야 하는 경우에 사용

class Single {
    private static Single instance = new Single();   
    private Single() { }      // 전용 생성자
    
    public static Single getInstance() {
        return instance;
    }
}

public class SingleTest {
    public static void main(String[] args) {
        Single obj1 = Single.getInstance();
        Single obj2 = Single.getInstance();
        System.out.println(obj1);
        System.out.println(obj2);
    }
}

20. 객체배열

- 객체를 저장하는 배열

- 객체에 대한 참조값 저장

class Rect {
    int width, height;
    
    public Rect(int w, int h) {
        this.width = w;
        this.height = h;
    }
    
    double getArea() {
        return (double) width * height;
    }
}

public class RectArrayTest {
    public static void main(String[] args) {
        Rect[] list = new Rect[5];             // 객체 배열 생성
        
        for (int i = 0; i < list.length; i++)
            list[i] = new Rect(i,i);           // 배열에 객체 값 저장 
            
        for (int i = 0; i < list.length; i++)
            System.out.println(i + "번째 사각형의 면적= " + list[i].getArea());
    }
}

/** 
0번째 사각형의 면적= 0.0
1번째 사각형의 면적= 1.0
2번째 사각형의 면적= 4.0
3번째 사각형의 면적= 9.0
4번째 사각형의 면적= 16.0
**/

for(int i = 0; i < list.length; i++)
     list[i] = new Rect(i, i);

21. 동적 객체 배열

- ArrayList<>

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("홍콩");
        list.add("싱가포르");
        list.add("괌");
        list.add("사이판");
        list.add("하와이");
        
        System.out.println("여행지 추천 시스템");
        int index = (int)(Math.random()*list.size());
        System.out.println("추천 여행지는 " + list.get(index));
    }
}

- list.add(); 로 추가

import java.util.ArrayList;

class Person {
    String name;
    String tel;
    
    public Person(String name, String tel) {
        this.name = name;
        this.tel = tel;
    }
}

public class ArrayListTest2 {
    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<Person>();
        list.add(new Person("Anna", "01023459293"));
        list.add(new Person("Jane", "01082983491"));
        list.add(new Person("Jim", "01012349722"));
        list.add(new Person("Emily", "01092938475"));
        for (Person obj : list)
            System.out.println("(" + obj.name + "," + obj.tel + ")");
    }
}

1. 클래스

- 객체 지향 언어의 기본적인 빌딩 블록

public class Name {

}

- 자바 소스파일 (.java) 는 항상 public이 붙은 클래스의 이름과 동일해야 함

- 하나의 소스파일 안에 public 클래스가 2개 이상 있으면 오류 발생

2. 메소드

- 특정한 작업을 수행하는 코드의 묶음

public static void main (String[] args) {
	System.out.println("Hello World!");
}

3. 자료형

- 기초형

    - 정수형: byte(1), short(2), int(4), long(8)

    - 실수형: float(4), double(8)

    - 논리형: boolean

    - 문자형: char (2, 유니코드)

- 참조형: 클래스, 인터페이스, 배열

- 리터럴:

    - 소스코드에 직접 쓰여있는 값 (ex, x = 100;)

    - 정수형, 부동소수점형, 문자형 등의 여러 타입 있음

- 상수: 프로그램이 실행되는 동안 값이 변하지 않는 수

4. 형변환

- 산술 연산 전에 피연산자의 타입 통일해야 함

- 강제 형변환

int x = 3;
double y = (double) x;

5. 콘솔에서 입력받기 (Scanner)

- System.in 사용

import java.util.Scanner;
Scanner sc = new Scanner(System.in);

- 키보드로부터 바이트 값 받아서 분리자를 이용하여 토큰으로 분리

- default 분리자는 공백문자 (' ', '\n', '\t')

String name = sc.next();           // 한 단어 입력
int age = sc.nextInt();            // 문자열(토큰)을 정수로 변환하여 반환
double weight = sc.nextDouble();   // 문자열을 실수로 변환하여 반환
String line = sc.nextLine();       // 한 줄 입력

6. 조건 연산자