• 데이터의 구분

정량적 데이터 : 주로 숫자로 이루어진 데이터 정성적 데이터 : 문자와 같은 텍스트로 구성되며 함축적 의미

• 데이터의 유형

정형 : 테이블 구조 (DB), RDB, CSV, 스프레드시트 반정형 : 웹로그, 알람, XML, HTML, JSON, RSS 비정형 : 이미지, 오디오, 문자, NoSQL

• 데이터 기반 지식 구분

• 암묵지
  • 학습과 경험을 통해 개인에게 체화되어 있지만 겉으로 드러나지 않은 지식
  • 사회적으로 중요하지만 다른 사람에게 공유되기 어려움
• 형식지
  • 명시적으로 알 수 있는 형태, 형식을 갖추어 표현되고 공유가 가능한 지식
  • 전달과 공유가 용이함

• DIKW 피라미드

• Data
  • 개별 데이터 자체로는 의미가 중요하지 않은 객관적 사실
• Infotmation
  • 데이터의 가공, 처리와 데이터 간 연관 관계 속에서 의미가 도출된 것
• Knowledge
  • 데이터를 통해 도출된 다양한 정보를 구조화하여 유의미한 정보를 분류하고 개인적인 경험을 결합시켜 고유의 지식으로 내재화된 것
• Wisdom
  • 지식의 축적과 아이디어가 결합된 창의적인 산물

• 빅데이터의 특징

3V : Volume(규모), Variety(유형, 다양성), Velocity(속도) 5V : Value(가치), Veracity(품질)

• 빅데이터의 가치

경제적 자산, 불확실성 제거, 리스크 감소, 타분야 융합, 스마트 경쟁력

• 빅데이터의 가치 측정의 어려움

데이터 활용 방식, 가치 창출 방식, 분석 기술 발전, 데이터 수집 원가

• 빅데이터의 본질적인 변화

1. 사전처리 -> 사후처리
2. 표본조사 -> 전수조사
3. 질 -> 양
4. 인과관계 -> 상관관계

• 빅데이터 활용을 위한 3요소

1. 인력 : 데이터사이언티스트
2. 자원 : 빅데이터
3. 기술 : 빅데이터플랫폼, AI

• 분석조직의 구조

1. 집중구조(전담조직구성)
   2. 분산구조(분석인력들을 현업부서로 직접배치)
   3. 기능구조(별도의 조직이 없고, 해당 부서에서 수행)

• 데이터 사이언티스트 요구역량

• Hard Skill : 이론적 지식, 분석기술 숙련(이과적 지식)
• Soft Skill : 통찰력, 설득력 있는 전달, 협업 능력(문과적 지식)

• 데이터베이스 특징

공용 데이터, 통합 데이터, 저장된 데이터, 변화되는 데이터(공통저변)

• 데이터웨어하우스(DW) 특징

특징 : 주제지향성, 통합성, 시계열성, 비휘발성 구성요소 : 데이터모델, ETL(Extract, Transform, Load), ODS, DW메타데이터, OLAP, 데이터마이닝, 분석도구, 경영기반솔루션

• ETL
  • 기업의 내부 또는 외부로부터 데이터를 추출, 정제 및 가공하여 데이터웨어하우스에 적재
• ODS
  • DBMS 시스템에서 추출한 데이터를 통합적으로 관리
• 데이터 마이닝
  • 대용량 데이터로부터 인사이트를 추출

• 데이터 산업의 진화순서

처리 -> 통합 -> 분석 -> 연결 -> 권리

• 인공지능 경쟁력 3요소

알고리즘, GPU, 풍부한 데이터

2. 데이터 분석 계획

• 분석의 기획

• 하향식 접근법(Top-Down)

  • 비즈니스 문제 -> 분석 과제 도출
  • 전략중심, 문제 중심 접근

• 상향식 접근법(Bottom-Up)

  • 데이터 분석 -> 인사이트 발견
  • 데이터 중심 접근

• 디자인 사고(Design Thinking)

  • 사용자 문제 해결 중심 분석

• 데이터 분석 거버넌스 구성요소

  • 조직, 운영 프로세스, 분석 인프라, 데이터 거버넌스, 분석교육

• KDD 분석방법론

  • 통계적 패턴이나 지식을 찾기 위해 정리한 데이터

• CRISP-DM 분석방법론

  • 유럽연합의 ESPRIT에서 시작, 주요 5개 업체들이 주도

• SEMMA 분석방법론
  • SAS사의 주도로 만들어진 기술중심, 통계중심의 방법론
  • 추출 -> 탐색 -> 수정-> 모델링 -> 평가

• 데이터 거버넌스

  • 전사 차원의 모든 데이터에 대해 정책 및 지침, 표준화, 운영조직과 책임 등 표준화된 관리 체계 수립
  • 데이터의 가용성, 유용성, 통합성, 보안성을 확보

    마스터 데이터 : 마스터 파일을 형성하는 데이터 메타 데이터 : 다른 데이터를 설명하기 위해 사용되는 데이터 데이터 사전 : 자료의 이름, 표현방식, 의미, 사용방식 등을 저장

• 데이터 분석 성숙도

• 데이터 처리 프로세스

  

• 사분면 분석

  

3 데이터 수집 및 저장 계획

오버라이딩이란?

조상클래스로부터 상속받은 메서드의 내용을 변경하는 것을 오버라이딩이라고 한다. 상속받은 메서드를 그대로 사용하기도 하지만, 자손 클래스의 메서드에 맞게 변경해야하는 경우가 많아 조상의 메서드를 오버라이딩을 한다.

오버라이딩의 조건

오버라이딩은 메서드의 내용만을 새로 작성하는 것이므로, 메서드의 선언부는 조상의 것과 완전히 일치해야 한다.

자손 클래스에서 오버라이딩하는 메서드는 조상 클래스의 메서드와 1. 이름이 같아야 한다. 2. 매개변수가 같아야 한다. 3. 반환타입이 같아야 한다.

오버로딩과 오버라이딩

많은 자바에 입문하는 사람들이 헷갈려하는 부분 중 하나가 오버로딩과 오버라이딩의 차이에 대해 헷갈려하는 경우가 많다. 필자 또한 둘의 차이를 이해하지 못해 많은 도서를 읽어보며 이해하게 되었다. 일단 형식적인 둘의 차이는 다음과 같다.

오버로딩(overloading) : 기존에 없는 새로운 메서드를 정의하는 것(new) 오버라이딩(overriding) : 상속받은 메서드의 내용을 변경하는 것(change, modify)

즉 새로운 메서드를 만들면 오버로딩, 상속받은 메서드의 내용만을 바꾼다면 오버라이딩이라고 생각하면 된다.

class Parent {
    void parentMethod() {}
}

class Child extends Parent {
    void parentMEthod() {}    // 오버라이딩
        void parentMethod(int i) {} // 오버로딩

        void childMethod() {}
        void childMethod(int i) {} // 오버로딩
}

super

super는 자손 클래스에서 조상클래스로부터 상속받은 멤버를 참조하는데 사용되는 참조변수이다. 멤버변수와 지역변수의 이름이 같을 떄 this를 붙여서 구별했듯이 상속받은 멤버와 자신의 멤버와 이름이 같을 때는 super를 붙여서 구별할 수 있다.

class SuperTest
{
    public static void main(String args[]){
        Child c = new Child();
        c.method();
    }
}

class Parent
{
   int x = 10;
}

class Child extends Parent {
   void method() {
    System.out.println("x = " + x);
        System.out.println("this.x = " + this.x);
        System.out.println("super.x = " + super.x);
    }
}

실행결과 x = 10 this.x = 10 super.x = 10

이 경우에는 x, this.x, super.x 모두 같은 변수를 의미하여 모두 같은 값이 출력되었다.

class SuperTest
{
    public static void main(String args[]){
        Child c = new Child();
        c.method();
    }
}

class Parent
{
   int x = 10;
}

class Child extends Parent {
   int x = 20;
   void method() {
    System.out.println("x = " + x);
        System.out.println("this.x = " + this.x);
        System.out.println("super.x = " + super.x);
    }
}

실행결과 x = 20 this.x = 20 super.x = 10

super.x는 조상 클래스(Parent)로부터 상속받은 멤버변수 x를 뜻하며, this.x는 자손 클래스(Child)에 선언된 멤버변수를 뜻한다.

super() - 조상 클래스의 생성자

super() 또한 this()와 같이 생성자이다. this()는 같은 클래스의 다른 생성자를 호출하는 데 사용되지만, super()는 조상 클래스의 생성자를 호출하는데 사용된다.

class PointTest {
    public static void main(String[] args) {
        Point3D p3 = new Point3D();

        System.out.println("p3.x = " + p3.x);
        System.out.println("p3.y = " + p3.y);
        System.out.println("p3.z = " + p3.z);
    }
}

class Point {
    int x = 10;
    int y = 20;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

class Point3D extends Point{
    int z = 30;

    Point3D()
    {
        this(100, 200, 300);    // Point3D(int x, int y, int z)를 호출한다.
    }

    Point3D(int x, int y, int z)
    {
        super(x, y);    //  Point(int x, int y)를 호출한다.
        this.z = z;
    }
}

위의 코드를 보면 어떤 클래스의 인스턴스를 생성하면, 클래스 상속관계의 최고조상인 Object클래스까지 거슬러 올라가면서 모든 조상클래스의 생성자가 순서대로 호출된다는 것을 알 수 있다.

참고 자바의 정석 p327 ~ p335

상속의 정의

기존의 클래스를 재사용하여 새로운 클래스를 작성하는 것이다. 상속을 통해서 클래스를 작성하면 보다 적은 양의 코드로 새로운 클래스를 작성할 수 있고, 코드를 공통적으로 관리할 수 있기 때문에 코드의 추가 및 변경이 매우 용이하다.

상속을 구현하는 방법

class Parent{}
class Child extends Parent{
    // ...
}

조상 클래스 : 부모(parent)클래스, 상위(super)클래스 자손 클래스 : 자식(child)클래스, 하위(sub)클래스

상속의 예시

class Tv {
    boolean power; // 전원 상태(on/off)
    int channel;    // 채널

    void power() {
        power = !power;}
    void channelUp() {
        ++channel;
    }
    void channelDown(){
        --channel;
    }
}

class CaptionTv extends Tv{
    boolean caption;    // 캡션 상태(on/off)
    void displayCaption(String text) {
        if(caption){ // 캡션 상태가 on(true)일 때만 text를 보여준다.
            System.out.println(text);
        }
    }
}

class CaptionTvTest {
    public static void main(String[] args) {
        CaptionTv ctv = new CaptionTv();
        ctv.channel = 10;
        ctv.channelUp();
        System.out.println(ctv.channel);
        ctv.displayCaption("Hello World!");
        ctv.caption = true;
        ctv.displayCaption("Hello World!");
    }
}

실행결과 11 Hello World!

상속에 대해서 알 수 있는 것들

1. 부모와 자식 관계에서 클래스의 멤버변수와 메서드를 상속 받았을 때, 자식은 부모클래스의 멤버변수와 메서드를 사용할 수 있다.
2. 상속을 통해서 하나의 클래스에 다양한 기능을 넣어서 편한 코드작성이 가능하다.

포함관계

상속이외에도 클래스를 재사용하는 또 다른 방법이 있다. 그것은 클래스간에 '포함(Composite)'관계를 맺어 주는 것이다. 클래스 간의 포함관계를 맺어 주는 것은 한 클래스의 멤버변수로 다른 클래스 타입의 참조변수를 선언하는 것을 뜻한다.

class Circle {
    int x;    // 원점의 x좌표
    int y;    // 원점의 y좌표
    int z;    // 반지름(radius)
}

class Point {
    int x;    // x좌표
    int y;    // y좌표
}

이때 포함관계를 활용해서 Circle클래스를 다음과 같이 작성할 수 있다.

class Circle{
    Point c = new Point();    // 원점
    int r;
}

원(Circle)은 점(Point)이다. - Circle is a Point. 원(Circle)은 점(Point)를 가지고 있다. - Circle has a Point.

상속관계 : '은 ~이다.(is-a)' 포함관계 : '은 ~을 가지고 있다.(has-a)'

상속과 포함관계의 예시

class DrawShape {
    public static void main(String[] args) {
        Point [] p = { new Point(100, 100), new Point(140, 50), new Point(200, 100)};
        Triangle t = new Triangle(p);
        Circle c = new Circle(new Point(150, 150), 50);

        t.draw();   // 삼각형을 그린다.
        c.draw();   // 원을 그린다.
    }
}

class Shape {
    String color = "black";
    void draw(){
        System.out.printf("[color=%s]%n", color);
    }
}

class Point {
    int x;
    int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    Point() {
        this(0,0);
    }

    String getXY() {
        return"(" + x + ", " + y + ")";     // x와 y의 값을 문자열로 반환
    }
}

class Circle extends Shape {
    Point center;   //  원의 원점좌표
    int r;      // 반지름

    Circle() {
        this(new Point(0,0), 100); // Circle(Point center, int r)를 호출
    }

    Circle(Point center, int r){
        this.center = center;
        this.r = r;
    }

    void draw() {
        System.out.printf("[center = (%d, %d), r = %d, color = %s]%n", center.x, center.y, r, color);
    }
}

class Triangle extends Shape{
    Point [] p = new Point[3];

    Triangle(Point[] p){
        this.p = p;
    }

    void draw() {
        System.out.printf("[p1 = %s, p2 = %s, p3 = %s, color = %s]%n", p[0].getXY(), p[1].getXY(), p[2].getXY(), color);
    }
}

실행결과 [p1 = (100, 100), p2 = (140, 50), p3 = (200, 100), color = black]
[center = (150, 150), r = 50, color = black]

class Circle extends Shape {    //  Circle과 Shape는 상속관계
    Point center;           //  Circle과 Point는 포함관계
    int r;              // 반지름

위와 같이 상속과 포함의 관계를 구분할 수 있다면 클래스의 함수를 보다 유기적으로 활용할 수가 있다.

class Shape {
    String color = "black";
    void draw(){    
        System.out.printf("[color=%s]%n", color);
    }
}

Circle클래스는 Shape클래스로부터 모든 멤버를 상속받았으므로, Shape클래스에 정의된 color이나 draw()를 사용할 수 있다.

class Circle extends Shape {
      ...
    void draw() {    // 원을 그리는 대신에 원의 정보를 출력하도록 했다.
        System.out.printf("[center = (%d, %d), r = %d, color = %s]%n", center.x, center.y, r, color);
    }
}

Circle클래스에도 Shape클래스에 있는 draw()메서드가 정의되어 있는 것을 알 수가 있다. 이때 draw()를 호출할 경우 Circle클래스에 정의된 draw()가 호출된다. 이를 오버라이딩(overriding)이라고 부른다.

참고 자바의 정석 p310 ~ p321

하나의 클래스 내에서 같은 이름의 메서드를 여러 개 정의하는 것을 '메서드 오버로딩(method overloading)' 또는 간단히 '오버로딩(overloading)'이라고 한다.

오버로딩의 조건

1. 메서드 이름이 같아야 한다.
2. 매개변수의 개수 또는 타입이 달라야 한다.

오버로딩의 예

class OverloadingTest {
    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) 결과 : 600

위와 같은 결과가 나오기 위해서 오버로딩을 사용한 것이 보여진다. Mymath3클래스의 add메서드들을 오버로딩해줌으로써 각각 메서드가 받는 매개변수에 따라 그에 따른 반환값과 출력문이 나오도록 했다. 이렇게 오버로딩을 함으로써 하나의 메서드로 여러개의 메서드를 정의할 수 있게 되어 복잡하지 않은 코딩을 할 수 있게 되었다.

생성자란

생성자는 인스턴스가 생성될 때 호출되는 '인스턴스 초기화 메서드' 즉, 메서드명이 클래스명과 동일하며 리턴자료형이 존재하지 않는 메서드라고 생각하면 된다.

생성자의 조건

1. 생성자의 이름은 클래스의 이름과 같아야 한다.
2. 생성자는 리턴 값이 없다.

생성자의 정의

클래스이름(타입 변수명, 타입 변수명, ... ) {
    // 인스턴스 생성 시 수행될 코드,
        // 주로 인스턴스 변수의 초기화 코드를 적는다.
}

class Card{
    Card(){        // 매개변수가 없는 생성자
           ...
        }

        Card(String k, int num){    // 매개변수가 있는 생성자
           ...
        }
        ...
}

여기서 주의할 점은 연산자 new가 인스턴스를 생성하는 것이지 생성자가 인스턴스를 생성하는 것이 아니다라는 것을 알고 가야한다.

Card c = new Card();

1. 연산자 new에 의해서 메모리(heap)에 Card클래스의 인스턴스가 생성된다.
2. 생성자 Card()가 호출되어 수행된다.
3. 연산자 new의 결과로, 생성된 Card인스턴스의 주소가 반환되어 참조변수 c에 저장된다.

생성자의 예시

class Car {
    String color;   // 색상
    String gearType; // 변속기 종류 - auto(자동), manual(수동)
    int door;   // 문의 개수

    Car() {}
    Car(String c, String g, int d){
        color = c;
        gearType = g;
        door = d;
    }
}

class CarTest {
    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);
    }
}

생성자에서 다른 생성자 호출 - this, this()

같은 클래스의 멤버들 간에 서로 호출할 수 있는 것처럼 생성자간에도 서로 호출이 가능하다.

1. 생성자의 이름으로 클래스이름 대신 this를 사용한다.
2. 한 생성자에서 다른 생성자를 호출할 때는 반드시 첫 줄에서만 호출이 가능하다.

이때 생성자를 작성할 때 첫 줄에서만 호출해야 되는 이유는 생성자 내에서 초기화 작업 도중에 다른 생성자를 호출하게 되면, 호출된 다른 생성자 내에서도 멤버변수들의 값을 초기화를 할 것이므로 다른 생성자를 호출하기 이전의 초기화 작업이 무의미해질 수 있기 때문이다.

생성자 예시

class Car {
    String color;   // 색상
    String gearType;    // 변속기 종류 - auto (자동), manual (수동)
    int door;   // 문의 개수

    Car(String color, String gearType, int door){
        this.color = color;
        this.gearType = gearType;
        this.door = door;
    }

    Car() {
        this("White", "auto", 4);
    }

    Car(String color) {
        this(color, "auto", 4);
    }

}

class CarTest2 {
    public static void main(String[] args) {
        Car c1 = new Car();
        Car c2 = new Car("Blue");

        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=4

나는 생성자를 쉽게 생각하여 손님들이 받는 상세하게 무슨 재료가 들어간 수프인지 적혀있는 메뉴판으로 생각하며 생성자를 이해하고 있다. 위의 코드를 예로 들어, 제일 첫번째 생성자 Car(String color, String gearType, int door)에서는 색깔과 기어타입, 문의 개수를 미리 주문자의 오더에 따라 바뀔 수가 있지만, 두번째 세번째 생성자 Car에서는 오더가 없거나, 3개중의 1개를 설정하면 나머지에 대해서는 미리 정해져 있는 값을 반환한다. 즉, 생성자를 통해서 변수를 설정하는 것에 대해서 간략하게 변경할 수 있게 된다는 것을 이해해야한다.

this : 인스턴스 자신을 가리키는 참조변수, 인스턴스의 주소가 저장되어 있다. 모든 인스턴스메서드에 지역변수로 숨겨진 채로 존재한다. this(), this(매개변수) : 생성자, 같은 클래스의 다른 생성자를 호출할 때 사용한다.

생성자를 이용한 인스턴스의 복사

class Car {
    String color;   // 색상
    String gearType;    // 변속기 종류 - auto (자동), manual (수동)
    int door;   // 문의 개수

    Car(String color, String gearType, int door){
        this.color = color;
        this.gearType = gearType;
        this.door = door;
    }

    Car() {
        this("White", "auto", 4);
    }

    Car(Car c) { // 인스턴스의 복사를 위한 생성자
        color = c.color;
        gearType = c.gearType;
        door = c.door;
    } // this(c.color, c.gearType, c.door);

}

class CarTest3 {
    public static void main(String[] args) {
        Car c1 = new Car();
        Car c2 = new Car(c1); // c1의 복사본 c2를 생성한다.

        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.door = 100;
        System.out.println("c1.door=100; 수행 후");

        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=4 c1.door=100; 수행 후 c1의 color=White, gearType=auto, door=100 c2의 color=White, gearType=auto, door=4

인스턴스 c2는 c1을 복사하여 생성된 것이므로 서로 같은 상태를 갖지만, 서로 독립적으로 메모리공간에 존재하는 별도의 인스턴스이므로 c1의 값들이 변경되어도 c2는 영향을 받지 않는다.

참고 자바의 정석 p283 ~ 299

클래스 메서드의 특징

1. 클래스를 설계할 때 멤버변수 중 모든 인스턴스에 공통으로 사용하는 것에 static을 붙인다.

생성된 각 인스턴스는 서로 독립적이기 때문에 각 인스턴스의 변수는 서로 다른 값을 유지한다. 그러나 모든 인스턴스에서 같은 값이 유지되어야 하는 변수는 static을 붙여서 클래스변수로 정의해야 한다.

2. 클래스 변수(static 변수)는 인스턴스를 생성하지 않아도 사용할 수 있다.

static이 붙은 변수(클래스변수)는 클래스가 메모리에 올라갈 때 이미 자동적으로 생성되기 때문이다.

3. 클래스 메서드(static 메서드)는 인스턴스 변수를 사용할 수 없다.

인스턴스 메서드에서는 static이 붙은 변수를 사용하는 것이 언제든 가능하지만, 클래스 메서드(static 메서드)에서는 인스턴스 생성 없이 호출이 가능하여, 클래스 메서드가 호출되었을 때 인스턴스가 존재하지 않을 수도 있기 때문에 클래스 메서드에서는 인스턴스변수의 사용을 금지한다.

4. 메서드 내에서 인스턴스 변수를 사용하지 않는다면, static을 붙이는 것을 고려한다.

인스턴스 변수를 필요로 하지 않는 상황에서 static을 붙임으로써 메서드 호출시간이 짧아져 성능이 향상된다.

클래스메서드 예제

class MyMath2 {
    long a, b;

    // 인스턴스변수 a, b만을 이용해서 작업하므로 매개변수가 필요없다.
    long add() { return a + b; } // a, b는 인스턴스변수
    long subtract() { return a - b; }
    long multiply() { return a * b; }
    double divide() { return a / b; }

    // 인스턴스변수와 관계없이 매개변수만으로 작업이 가능하다.
    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(double a, double b) { return a / b; }
}

class MyMathTest2 {
    public static void main(String[] args) {
        // 클래스메서드 호출. 인스턴스 생성없이 호출가능
        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(200.0, 100.0));

        MyMath2 mm = new MyMath2(); // 인스턴스를 생성
        mm.a = 200L;
        mm.b = 100L;
        // 인스턴스메서드는 객체생성 후에만 호출이 가능함.
        System.out.println(mm.add());
        System.out.println(mm.subtract());
        System.out.println(mm.multiply());
        System.out.println(mm.divide());
    }
}

예제코드를 보면 클래스메서드와 인스턴스메서드의 차이에 대해서 알 수 있다.

클래스메서드는 객체생성없이 바로 호출이 가능했고, 인스턴스메서드는 MyMath2클래스의 인스턴스를 생성한 후 호출이 가능했다.

멤버간의 참조와 호출

같은 클래스에 속한 멤버들 같에는 별도의 인스턴스를 생성하지 않고도 서로 참조 또는 호출이 가능하다. 단, 클래스멤버가 인스턴스 멤버를 참조 또는 호출하고자 하는 경우에는 인스턴스를 생성해야 한다.

인스턴스 멤버(인스턴스 변수와 메서드)가 존재하는 시점에 클래스 멤버는 항상 존재하지만, 클래스멤버가 존재하는 시점에 인스턴스 멤버가 존재하지 않을 수도 있기 때문이다.

class TestClass{
    void instanceMethod() {}    // 인스턴스메서드
        static void staticMethod() {} // static메서드

        void instanceMethod2() { // 인스턴스메서드
            instanceMethod(); // 다른 인스턴스메서드를 호출
            staticMethod(); // static메서드를 호출
        }

        static void staticMethod2() { // static메서드
            instanceMethod();    // 에러! 인스턴스메서드를 호출할 수 없다.
            staticMethod();        // static메서드는 호출
        }
} // end of class

위의 코드는 같은 클래스 내의 인스턴스 메서드와 static메서드 간의 호출에 대해서 설명하고 있다.

같은 클래스 내의 메서드는 서로 객체의 생성이나 참조변수 없이 직접 호출이 가능하지만, static메서는 인스턴스 메서드를 호출할 수 없다.

참고 자바의 정석 p277 ~ p282

자바에서는 메서드를 호출할 때 매개변수로 지정한 값을 메서드의 매개변수에 복사해서 넘겨준다. 메서드의 매개변수를 기본형으로 선언하면 단순히 저장된 값만 얻지만, 참조형으로 선언하면 값이 저장된 곳의 주소를 알 수 있기 때문에 값을 읽어 오는 것은 물론 값을 변경하는 것도 가능하다.

기본형 매개변수 : 변수의 값을 읽기만 할 수 있다. (read only) 참조형 매개변수 : 변수의 값을 읽고 변경할 수 있다. (read & write)

기본형 매개변수

class Data { int x; }

class PrimitiveParamEx {
    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

기본형 매개변수의 설명

위의 코드에서 기본형 매개변수를 받아 호출하는 change를 보면 기본형 매개변수 int x를 썼다. 이때 int x는 change 메서드에서 1000으로 바뀌었음에도 d.x는 10으로 나온다. 그 이유는 'd.x'의 값이 변경된 것이 아니라, change메서듸 매개변수 x의 값이 변경된 것이기 때문에 원본에는 아무런 영향을 미치지 못한다.

기본형 매개변수는 변수에 저장된 값만 읽을 수만 있을 뿐 변경할 수 없기 때문에 d.x의 값에는 변화가 없다.

참조형 매개변수

class Data { int x; }

class ReferenceParamEx {
    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(Data d) { //  기본형 매개변수
        d.x = 1000;
        System.out.println("change() : x = " + d.x);
    }
}

실행결과 main() : x = 10 change() : x = 1000 After change(d.x) main() : x = 1000

참조형 매개변수의 설명

기본형 매개변수의 코드와는 달리 change 메서드를 호출한 후에 d.x의 값이 변경되었다. change메서드의 매개변수가 참조형이기 때문에 '값이 저장된 주소'를 change 메서드에게 넘겨주었기 때문에 값을 읽어오는 것뿐만이 아닌 변경하는 것도 가능하기 위와 같은 결과가 나왔다.

참조형 매개변수는 값이 저장된 주소를 사용하기 때문에 변수의 값을 읽거나 변경할 수 있다.

참조형 반환타입

매개변수뿐만 아니라 반환타입도 참조형이 될 수 있다. 모든 참조형 타입의 값은 '객체의 주소'이므로 그저 정수값이 반환되는 것일 뿐 특별할 것이 없다.

class Data { int x; }

class ReferenceReturnEx {
    public static void main(String[] args) {
        Data d = new Data();
        d.x = 10;

        Data d2 = copy(d);
        System.out.println("d.x =" + d.x);
        System.out.println("d2.x =" + d2.x);
    }

    static Data copy(Data d){
        Data tmp = new Data();
        tmp.x = d.x;

        return tmp;
    }
}

실행결과 d.x = 10 d2.x = 10

위의 코드에서 주의깊게 봐야할 것은 copy메서드이다.

static Data copy(Data d){ 
        Data tmp = new Data(); // 새로운 객체 tmp를 생성
        tmp.x = d.x; // d.x의 값을 tmp.x에 복사

        return tmp; // 복사한 객체의 주소를 반환
    }

copy메서드의 반환타입은 'Data'이며, 호출결과를 저장하는 변수의 타입 역시 'Data'타입의 참조변수이다. 위의 copy메서드는 반환값 tmp를 가지며, tmp는 d.x의 값을 복사했다. copy메서드가 복사한 객체의 주소 d.x를 가진 tmp를 d2.x로 반환했기 때문에 실행결과에서 d2.x가 10이 나온것이다.

"반환타입이 '참조형'이라는 것은 메서드가 '객체의 주소'를 반환한다는 것을 의미한다."

참조 자바의 정석 p264 ~ p269

class Variables
{
    int iv;        // 인스턴스 변수
    static int cv;  // 클래스 변수(static 변수, 공유변수)

    void method()
    {
        int lv = 0;    // 지역변수
    }
}

1. 인스턴스변수(instance variable)

클래스의 인스턴스를 생성할 때 만들어진다. 인스턴스는 독립적인 저장공간을 가지므로 서로 다른 값을 가질 수 있으며, 인스턴스마다 고유한 상태를 유지해야하는 속성의 경우, 인스턴스로 선언한다.

2. 클래스변수(class variable)

클래스 변수를 선언하는 방법은 인스턴수변수 앞에 static을 붙이기만 하면 된다.

3. 지역변수(local variable)

메서드 내에 선언되어 메서드 내에서만 사용 가능하며, 메서드가 종료되면 소멸되어 사용 할 수 없게 된다.

class CardTest{
    public static void main(String args[]){
    System.out.println("Card.width = " + Card.width);
    System.out.println("Card.height = " + Card.height);

    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{
    String kind;
        int number;
        static int width = 100;
        static int height = 250;
}

인스턴스변수는 인스턴스가 생성될 때마다 생성되므로 인스턴스마다 각기 다른 값을 유지할 수 있지만, 클래스 변수는 모든 인스턴스가 하나의 저장공간을 공유하므로, 항상 공통된 값을 갖는다.

메서드

'메서드(method)'는 특정작업을 수행하는 일련의 문장들을 하나로 묶은 것이며, 기본적으로 수학의 함수와 유사하다.

메서드를 사용하는 이유

1. 높은 재사용성(reusability)

   한번 만들어 놓은 메서드는 몇 번이고 호출 할 수 있으며, 다른 프로그램에서도 사용이 가능하다.

2. 중복된 코드의 제거

   반복되는 문장들을 묶어서 하나의 메서드로 작성해 놓으면, 메서드를 호출하는 한 문장으로 대체할 수 있다.

3. 프로그램의 구조화

   큰 규모의 프로그램에서 문장들을 작업단위로 나눠서 여러 개의 메서드에 담아 프로그램의 구조를 단순화시킴으로써 프로그램의 전체 흐름이 한눈에 들어올 수 있어 나중에 프로그램에 문제가 발생해도 쉽게 찾아서 해결할 수 있다.

public static void main(String args[]){
    int[] numArr = new int[10];

    initArr(numArr);    // 1. 배열을 초기화
    printArr(numArr);    // 2. 배열을 출력
    sortArr(numArr);     // 3. 배열을 정렬
    printArr(numArr);    // 4. 배열을 출력
}

위의 코드처럼 각 메서드의 역할과 기능들을 구조화함으로써 전체의 흐름을 쉽게 파악할 수 있고, 오류발생 메서드의 위치를 찾아서 빠르게 수정이 가능하다.

메서드의 선언과 구현

메서드는 크게 '선언부(header, 머리)'와 '구현부(body, 몸통)'로 이루어져 있다.

int add(int a, int b) // => 선언부
{
    int result = a + b;
        return result; // 호출한 메서드로 결과를 반환한다.
} // => 구현부

메서드 선언부는 '메서드의 이름'과 '매개변수 선언', 그리고 '반환타입'으로 구성되어 있으며, 메서드가 작업을 수행하기 위해 어떤 값들을 필요로 하고 작업의 결과로 어떤 타입의 값을 반환하는지에 대한 정보를 제공한다.

메서드 구현부는 메서드 선언부 다음에 오는 괄호{}를 뜻하며, 여기에 메서드를 호출했을 때 수행될 문장들을 넣는다.

int add(int a, int b) { int result = a + b; return result; }

위에 정의 된 메서드 add에 선언된 변수 x,y,result는 메서드 내에 선언된 변수로 '지역변수(local variable)'라고 한다.

메서드의 호출

메서드이름(값1, 값2, ...) // 메서드를 호출하는 방법 print99danAll(); // void print99danAll()을 호출 int result = add(3, 5); // int add(int x, int y)를 호출하고, 결과를 result에 저장

메서드를 호출할 때 괄호()안에 지정해준 값인 '인자(argument)' 또는 '인수'의 개수 또는 순서는 호출된 메서드에 선언된 매개변수와 일치해야만 호출이 가능하다.

class MyMathTest {
    public static void main(String[] args) {
        MyMath mm = new MyMath();
        long result1 = mm.add(5L, 3L);
        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;
        // return a + b;  // 위의 두줄을 이와 같이 한 줄로 간단히 할 수 있다.
    }
    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;}
}

위의 코드를 보면 각 메서드에는 각각의 반환타입(long, double)을 가지고 있고, 타입에 따른 매개변수들 또한 가지고 있다. 그리고 메인 메서드를 통해서 호출받은 MyMath의 메서드들은 그에 맞는 타입의 수를 입력받아 다음과 같은 결과를 얻는다.

실행결과 add (5L, 3L) = 8 subtract (5L, 3L) = 2 multiply (5L, 3L) = 15 divide (5L, 3L) = 1.66666666666667

여기에서 'divide (5L, 3L) = 1.66666666666667'가 나오는 이유는
long형의 값인 5L,3L이 double형 값인 5.0, 3.0으로 자동 형변환되어 divide의 매개변수로서 저장되어 호출되었다.

참고 자바의 정석 p246 ~ p257

실제 세계는 사물(객체)로 이루어져 있으며, 발생하는 모든 사건들은 사물간의 상호작용이다.

객체지향언어가 갖는 장점

1. 코드의 재사용성이 높다. 새로운 코드를 작성할 때 기존의 코드를 이용하여 쉽게 작성할 수 있다.
2. 코드의 관리가 용이하다. 코드간의 관계를 이용해서 적은 노력으로 쉽게 코드를 변경할 수 있다.
3. 신뢰성이 높은 프로그래밍을 가능하게 한다. 제어자와 메서드를 이용해서 데이터를 보호하고 올바른 값을 유지하도록 하며, 코드의 중복을 제거하여 코드의 불일치로 인한 오동작을 방지할 수 있다.

이러한 객체지향언어의 장점은 프로그램의 개발과 유지보수에 드는 시간과 비용을 획기적으로 개선하였다.

클래스와 객체

1. 클래스의 정의와 용도

클래스의 정의 : 클래스란 객체를 정의해 놓은 것이다. 클래스의 용도 : 클래스는 객체를 생성하는데 사용된다.

2. 객체의 정의와 용도

객체의 정의 : 실제로 존재하는 것. 사물 또는 개념. 객체의 용도 : 객체가 가지고 있는 기능과 속성에 따라 다름

클래스와 객체의 관계를 우리가 살고 있는 실생활에서 예를 들면, 제품의 설계도(클래스)와 제품(객체)과의 관계라고 할 수 있다.

객체와 인스턴스

1. 인스턴스

클래스로부터 객체를 만드는 과정을 클래스의 인스턴스화(instantiate)라고 하며, 어떤 클래스로부터 만들어진 객체를 그 클래스의 인스턴스(instance)라고 한다.

2. 객체

객체는 속성과 기능, 두 종류의 구성요소로 이루어져 있다. 그리고 객체가 가지고 있는 속성과 기능을 그 객체의 멤버(구성원, member)라 한다.

속성(property) : 멤버변수, 특성, 필드, 상태 등 기능(function) : 메서드(method), 함수(function) 등

3. 인스턴스의 생성과 사용

클래스명 변수명;   //클래스의 객체를 참조하기 위한 참조변수를 선언 변수명 = new 클래스명();   // 클래스의 객체를 생성한 후, 객체의 주소를 참조변수에 저장

public class Tv {
    // Tv의 속성(멤버변수)
    String color;       // 색상
    boolean power;      // 전원상태(On/Off)
    int channel;        // 채널

    // Tv의 기능(메서드)
    void power() {
        power = !power;
    } // TV를 켜거나 끄는 기능을 하는 메서드
    void channelUp() {
        ++channel;
    } // TV의 채널을 높이는 기능을 하는 메서드
    void channelDown(){
        --channel;
    } // TV의 채널을 낮추는 기능을 하는 메서드
}

public class TvTest {
    public static void main(String[] args) {
        Tv t;          // Tv인스턴스를 참조하기 위한 변수 t를 선언
        t = new Tv();  // Tv인스턴스를 생성한다.
        t.channel = 7; // Tv인스턴스의 멤버변수 channel의 값을 7로 한다.
        t.channelDown(); // Tv인스턴스의 메서드 channelDown()을 호출한다.
        System.out.println("현재 채널은 " + t.channel + " 입니다.");
    }
}

Tv t;   // Tv클래스 타입의 참조변수 t를 선언한다. t = new Tv();   // Tv인스턴스를 생성한 후, 대입연산자(=)에 의해서 생성된 객체(Tv인스턴스)의 주소값이 t에 저장된다.

인스턴스는 참조변수를 통해서만 다룰 수 있으며, 참조변수의 타입은 인스턴스의 타입과 일치해야 한다.

이는 즉 Tv클래스의 인스턴스와 Tv클래스 타입의 참조변수가 같은 클래스 타입이어야 한다고 표현한 것이다.

객체 배열

public class Tv {
    String color;
    boolean power;
    int channel;

    void power() {
        power = !power;
    }
    void channelup() {
        ++channel;
    }
    void channelDown() {
        --channel;
    }
}

public class TvTest4 {
    public static void main(String[] args) {
        Tv [] tvArr = new Tv[3];    // 길이가 3인 Tv객체 배열

        // Tv객체를 생성해서 Tv객체 배열의 각 요소에 저장
        for(int i = 0; i < tvArr.length; i++) {
            tvArr[i] = new Tv(); /// Tv의 객체의 주소값이 배열 tvArr[i]에 저장
            tvArr[i].channel = i + 10; // tvArr[i]의 channel에 i + 10을 저장
        }

        for(int i = 0; i < tvArr.length; i++) {
            tvArr[i].channelup(); // tvArr[i]의 메서드를 호출. 채널이 1증가
            System.out.printf("tvArr[%d].channel=%d%n", i, tvArr[i].channel);
        }
    }
}

다른 언어에서 배운 배열에 대한 내용을 객체의 배열로서 쓸 수 있다. 모든 배열에서 그렇듯이 객체배열도 같은 타입의 객체만 저장할 수 있다.

참고 자바의 정석 p230 ~ p241

두 정수 left와 right가 매개변수로 주어집니다. left부터 right까지의 모든 수들 중에서, 약수의 개수가 짝수인 수는 더하고, 약수의 개수가 홀수인 수는 뺀 수를 return 하도록 solution 함수를 완성해주세요.

제한사항

1 ≤ left ≤ right ≤ 1,000

입출력

입출력의 예

다음 표는 13부터 17까지의 수들의 약수를 모두 나타낸 것입니다. 따라서, 13 + 14 + 15 - 16 + 17 = 43을 return 해야 합니다.

def solution(left, right):
    answer = 0

    for i in range(left, right + 1): # left ~ right까지를 반복한다.
        tes = 0
        for a in range(1, i + 1): # 약수의 개수를 구하는 반복문
            if i % a == 0:
                tes += 1

        if tes % 2 == 0:
            answer += i
        else:
            answer -= i

    return answer


print(solution(13, 17)) # 43
print(solution(24, 27)) # 52

풀이

해당 코드는 반복문과 조건문을 조합하였으며 첫번째 반복문은 13 ~ 17까지 반복을 하도록 하였고, 다음 반복문은 약수의 개수를 구하도록 하였다. 이후 구해지는 약수의 개수를 통해서 조건문을 이용하여 tes의 값이 짝수의 경우 더하고, 홀수의 경우 빼도록 함으로써 answer의 값이 구해진다.

어려웠던 점

해당 코드를 짜기 위해서 알아야 했던 것이 2가지가 있다. 약수의 개수를 구하는 것과 그 약수의 개수를 통해서 answer의 값을 구하는 것이다. 약수의 개수를 구하는 코드를 만들고 최종적인 answer의 값을 구하는 공식을 세우기까지 많은 시간이 걸렸다. tes = 0의 위치와 두번째 (answer의 값을 구하는)조건문의 위치를 설정하는 구간에서 많은 실수가 있었으며 이를 통해서 for문과 if문을 적절한 부문에 설정할 수 있도록 추가적인 복습이 필요하다.