728x90

JOIN

  • JOIN 이란 - 하나 이상의 테이블로부터 연관된 데이터를 검색해 오는 방법

Cartesian Join

  • Join에 대한 조건이 생략되거나 잘못 기술되어 한 테이블에 있는 모든 행들이 다른 테이블에 있는 모든 행들과 Join이 되어서 얻어진 경우를 Cartesian Product라 한다.
  • 두 테이블의 합집합이라 생각하면 된다.
  • select * from employees, departments;
  • Cartesian Product를 얻지 않기 위해서 반드시 WHERE 절을 써 준다.
  • (JOIN 하는 테이블의 수 - 1) 개의 JOIN 조건이 필요하다.

Simple Join

SELECT t1.col1, t1.col2, t2.col1 ... FROM Table1 t1, Table2 t2
WHERE t1.col3 = t2.col3
  • FROM 절에 필요로 하는 테이블을 모두 적는다.
    • 컬럼 이름의 모호성을 피하기 위해 테이블 이름으로 직접 지칭 가능 (어느 테이블에 속하는지 알 수 없는 경우가 있을 수 있으므로 Table 이름에 Alias 사용)
    • 적절한 Join 조건을 Where 절에 부여 (일반적으로 테이블 개수 -1 개의 조인 조건이 필요)
    • 일반적으로 PK와 FK간의 = 조건 이 붙는 경우가 많다.

Join 종류

종류 설명

Cross Join (Cartesian Product) 모든 가능한 쌍이 나타남
Inner Join 조건을 만족하는 튜플만 나타남
Outer Join Join 조건을 만족하지 않는 튜플 (짝이 없는 튜플)도 null과 함께 나타남
Theta Join 조건(theta) 에 의한 조인 / (FK가 아닌 다른걸 이용 ?)
Equi-Join Theta Join & 조건이 Equal (=)
Natural Join Equi-Join & 동일한 Column 명 합쳐짐
Self Join 자기 자신과 조인

EQUI-JOIN

  • 컬럼에 있는 값이 정확하게 일치하는 경우에 = 연산자를 사용하여 JOIN
SELECT 테이블명.컬럼명, 테이블명.컬럼명. …
FROM 테이블1, 테이블2
WHERE 테이블1.컬럼1 = 테이블2.컬럼2
  • 테이블명.컬럼명 - 검색해올 데이터가 어디에서 오는지 테이블과 컬럼을 밝혀둔다.
  • 테이블1.칼럼1 = 테이블2.컬럼2 - 두 테이블 간에 논리적으로 값을 연결시키는 칼럼 간의 조건을 기술한다.

EQUI-JOIN의 문형

  • 컬럼에 있는 값들이 정확히 일치하는 경우에 = 연산자를 사용해서 조인
  • 일반적으로 PK-FK 관계에 의하여 JOIN이 성립
  • WHERE절 or ON절을 이용
  • 액세스 효율을 향상시키고 좀 더 명확히 하기 위해 칼럼이름 앞에 테이블 이름을 밝힌다.
  • 같은 이름의 칼럼이 조인대상 테이블에 존재하면 반드시 테이블 이름을 밝혀줄 것 !
  • JOIN을 위한 테이블이 N개라 하면, JOIN을 위한 최소한의 = 조건은 N-1 이다.
# 사원 이름과 부서명을 출력하라.
select emp.ename, dept.dname from emp, dept;
select e.ename, d.dname from emp e, dept d;
select ename, dname from emp e, dept d;

# 중복되는 컬럼명 앞에는 반드시 테이블을 명시해야함
select ename, dname, e.deptno from emp e, dept d;

select e.ename, d.dname from emp e, dept d
where e.deptno = d.deptno;

# 모든 사원의 사번, first_name, email, department_name을 조회하라
select e.employee_id, e.first_name, e.email, d.department_name
from employees e, departments d
where e.department_id = d.department_id;

추가적인 조건 기술

  • WHERE 절에 JOIN 조건 이외의 추가적인 조건을 가질 수 있다.
  • 조인을 만족하는 데이터 중 특정 행만 선택하여 결과를 얻고 싶을 때 추가조건을 AND로 연결한다.
  • 사원의 이름과 부서명을 출력하라. 단, location_id 가 1800인 경우만 출력하라.
  • select concat(e.first_name, ' ', e.last_name) as 이름, d.department_name, l.city from employees e, departments d, locations l where e.department_id = d.department_id and d.location_id = l.location_id and l.location_id = 1800;

조건(theta) Join

  • 임의의 조건을 Join 조건으로 사용가능
  • Non-Equi Join 이라고도 한다.
  • # 이름, 급여, 등급을 조회하라 select e.ename, e.sal, s.grade from emp e, SALGRADE s where e.sal BETWEEN s.LOSAL AND s.HISAL;

Natural Join

  • 두 테이블에 공통 칼럼이 있는 경우 별다른 조인 조건없이 공통 칼럼처럼 묵시적으로 조인이 되는 유형
  • ANSI / ISO SQL1999를 따르는 ANSI JOIN 문법
select e.ename, d.dname
from emp e natural join dept d;

문제점

  • 조인하고자 하는 두 테이블에 같은 이름의 칼럼이 많을 때, 위와 같을 시 특정한 칼럼으로만 조인하고 싶다면 USING 절을 사용해서 기술한다.
  • select e.ename, d.dname from emp e join dept d using(deptno);

INNER JOIN - JOIN ~ ON

  • 공통된 이름의 칼럼이 없는 경우 가장 보편적으로 사용할 수 있는 유형이다.
  • WHERE 절에 일반조건만 쓸 수 있게하고, 조인 조건은 ON에 두어 보다 의미를 명확히 하고 알아보기도 쉽다.
  • ON 부분을 WHERE 절에서 작성 가능하다.
  • select e.ename, d.dname from emp e join dept d on (e.deptno = d.deptno) where d.deptno = 20 ;

Outer Join

  • Join 조건을 만족하지 않는(짝이 없는) 튜플의 경우 Null을 포함하여 결과를 생성
  • 모든 행이 결과 테이블에 참여

종류

  • Left Outer Join - 왼쪽의 모든 튜플은 결과 테이블에 나타남
  • Right Outer Join - 오른쪽의 모든 튜플은 “”
  • Full Outer Join - 양쪽 모두 결과 테이블에 참여

→ 왼쪽 테이블의 Null 값을 포함하는 튜플도 모두 보고 싶어요 : Left Outer Join

  • 오라클의 경우, NULL이 올 수 있는 쪽 조건에 + 를 붙여준다.
select e.ename, d.dname
from emp e left outer join dept d using(deptno); # 왼쪽의 모든 튜플

select e.ename, d.dname
from emp e right outer join dept d using(deptno); # 오른쪽의 모든 튜플

select e.ename, d.dname
from emp e left outer join dept d using(deptno)
union
select e.ename, d.dname
from emp e right outer join dept d using(deptno); # 양쪽 모든 튜플
  • MySQL의 경우, FULL OUTER JOIN이 아닌 UNION 연산을 통해 가능하다.

JOIN 문법 정리

SELECT table1.column, table2.column
FROM table1

[CROSS JOIN table2] |

[NATURAL JOIN table2] |

[JOIN table2 USING (column_name)] |

[JOIN table2
ON(table1.column_name = table2.column_name)] | [LEFT|RIGHT|FULL OUTER JOIN table2
ON (table1.column_name = table2.column_name)];
  • left outer → left / right outer → right 로 축약해서 사용가능

SELF JOIN

  • 하나의 테이블을 서로 다른 테이블로 생각하여 JOIN 하는 것
# 사원이름과 매니저 이름을 출력하라.
select e.ename 사원명, m.ename 매니저이름
from emp e, emp m
where e.mgr = m.empno;

# 사원이름, 매니저 이름을 출력하세요. 단, 매니저가 없는 사원도 출력하시오.
select e.ename 사원명, m.ename 매니저이름
from emp e
left outer join emp m
on e.mgr = m.empno;

🔎 SubQuery

  • 하나의 SQL 질의문 속에 다른 SQL 질의문이 포함되어 있는 형태
  • 쿼리 하나로는 원하는 결과를 얻어내지 못하는 경우에 사용
# SMITH가 속한 부서의 급여 평균을 알고 싶다.
# 1. 스미스의 부서 번호는?
# 2. 해당 부서 번호의 급여 평균

select avg(sal)
from emp
where deptno = (select deptno from emp where ename = 'SMITH');
  • ✔ 서브쿼리 짜는 것을 익히기 위해선 각 조건들을 작은 단위로 (쿼리 하나씩) 뽑아내는 연습을 하는 것이 좋겠다.

Single-Row Subquery

  • Subquery의 결과가 한 개의 ROW인 경우
  • Single-Row Operator 를 사용해야 함 - = , > , >= , < , <= , <>
# 사원의 평균 급여보다 작은 급여를 받는 사원의 이름과 급여를 출력
select ename, sal
from emp
where sal < (select avg(sal)
             from emp);

# 부서이름이 SALES인 부서의 사원 이름과 부서 번호를 출력
select ename, deptno
from emp
where deptno = (select deptno
                from dept
                where dname = 'SALES');

Multi-Row SubQuery (Feat. IN, ANY, ALL)

  • Subquery의 결과가 둘 이상의 ROW
  • Multi-Row에 대한 연산을 사용해야 함 - ANY , ALL , IN , EXIST …
# 아래의 경우는 오류가 발생한다.
SELECT *
FROM emp
WHERE ename = (SELECT MIN(ename)
               FROM emp GROUP BY deptno);

# 아래와 같이 in 연산을 사용하여 그룹 내에 있는지
# 확인하는 식으로 사용해야 한다.
SELECT *
FROM emp
WHERE ename in ('KANG', 'CLARK', 'ADAMS', 'ALLEN');

# 따라서 다음과 같이 해결할 수 있다.
SELECT *
FROM emp
WHERE ename in (SELECT MIN(ename)
               FROM emp GROUP BY deptno);

ANY

  • 다수의 비교값 중 한개라도 만족하면 true
  • IN 과 다른 점은 비교 연산자를 사용한다는 점
  • SELECT ename, sal, deptno FROM emp WHERE ename = ANY (SELECT MIN(ename) FROM emp GROUP BY deptno); # 아래 쿼리는 sal > 950 과 같은 결과이다. SELECT * FROM emp WHERE sal > ANY(950, 3000, 1250)

ALL

  • 전체 값을 비교해서 모두 만족해야만 true
  • Oracle은 오류가 발생하지 않지만, MySQL은 Subquery에서만 사용 가능하다.
  • # 아래의 쿼리는 결과가 없다. 모두를 만족할 수는 없기 때문 # MySQL에서는 값에 대해서는 ALL을 사용할 수 없다. 여기선 단지 예제일뿐 ! SELECT * FROM emp WHERE sal = ALL(950, 3000, 1250) # 결국 아래와 같이 사용된다. select * from emp where sal < all (select sal from emp where deptno in (30, 10));

Correlated Query

  • Outer Query와 Inner Query가 서로 연관되어 있다.
  • 해석방법
    • Outer query의 한 Row를 얻는다.
    • 해당 Row를 가지고 Inner Query를 계산한다.
    • 계산 결과를 이용, Outer query의 WHERE 절을 evaluate
    • 결과가 참이면 해당 Row를 결과에 포함시킨다.
# 사원의 이름, 급여, 부서 번호를 출력하시오. 단 사원의 급여가
# 그 사원이 속한 부서의 평균 급여보다 큰 경우만 출력하시오.
SELECT o.ename, o.sal, o.deptno
FROM emp o
WHERE o.sal > (SELECT AVG(i.sal)
               FROM emp i
               WHERE i.deptno = o.deptno);

# 각 부서별로 최고 급여를 받는 사원을 출력하라.
# 1
select deptno, empno, ename, sal
from emp
where (deptno, sal) in (select deptno, max(sal)
                        from emp
                        group by deptno);

# 2
select a.deptno, a.empno, a.ename, a.sal
from emp a,
     (select b.deptno, max(b.sal) msal
      from emp b
      group by deptno) c
where a.deptno = c.deptno
  and a.sal = c.msal;

# 3
SELECT deptno, empno, ename, sal
FROM emp e
WHERE e.sal = (SELECT max(sal)
               FROM emp WHERE deptno = e.deptno);

Set Operator

  • 두 질의의 결과를 가지고 집합 연산
  • UNION , UNION ALL , INTERSECT , MINUS
  • 우선 임의로 테이블 생성 a : {1, 2, 3} / b : {2, 3, 4}
  • create table a ( name int ); create table b ( name int ); insert into a value ('1'); insert into a value ('2'); insert into a value ('3'); insert into b value ('2'); insert into b value ('3'); insert into b value ('4');
# UNION : 합집합 (중복 제거)
select * from a union select * from b;
# UNION ALL : 합집합 (중복 포함)
select * from a union all select * from b;
# INTERSECT : 교집합
# - MySQL에서는 지원하지 않는다.
select * from a intersect select * from b; # 불가
select a.name from a, b where a.name = b.name;
# minus : 차집합
# - MySql 에서 지원하지 않는다.
select * from a minus select * from b;
select a.name from a where a.name not in (select b.name from b);

RANK() 함수

  • 요소에 대해 순서를 매기는 함수
  • MySQL 8 이상에서 사용가능
SELECT sal, ename,
			rank() over(order by sal desc) AS ranking
FROM emp;

 

728x90
728x90

String 클래스

== 와 equals()

  • == : 비교하는 두 대상의 주소값을 비교
  • equals() : 비교하는 두 대상의 값을 비교
public class StringExam {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");
        String str4 = new String("hello");

        System.out.println(str1 == str2);      // true
        System.out.println(str1.equals(str2)); // true

        System.out.println(str2 == str3);      // false
        System.out.println(str2.equals(str3)); // true

        System.out.println(str3 == str4);      // false
        System.out.println(str3.equals(str4)); // true
    }
}

추상 클래스

  • abstract 키워드를 사용하여 클래스를 정의한다.
  • 확장 만을 위한 용도로 정의되는 클래스
  • 추상 클래스는 인스턴스가 될 수 없다.
  • 추상 클래스를 상속받는 자손이 인스턴스가 된다.
  • 추상 클래스는 보통 1개 이상의 추상 메소드를 가진다. (없어도 오류 발생은 X)
public abstract class 클래스명 { ... }

추상 메소드

  • 추상 메소드는 메소드에 대한 구현을 가지지 않는다.
  • 추상 클래스의 자식 클래스가 해당 메소드를 구현 하도록 강요하기 위해 존재
  • 추상 메소드는 추상 클래스에만 조재할 수 있다.

✔ 추상 클래스를 사용하는 이유

  1. 공통된 필드와 메서드를 통일할 목적
    • 필드와 메서드 이름을 통일하여 유지보수성을 높이고 통일성을 유지할 수 있다.
  2. 실체 클래스 구현시, 시간절약
    • 강제로 주어지는 필드와 메서드를 가지고 실체 클래스의 성격대로 구현만 하면 된다.
    • 설계 시간이 절약되며, 구현하는데만 집중할 수 있다.
  3. 규격에 맞는 실체 클래스 구현
    • 공통된 속성은 규격에 맞게 구현할 수 있다는 의미
    • → 추상 클래스를 상속받은 실체 클래스들은 반드시 추상 메서드를 재정의해서 실행 내용을 작성해야 하기 때문
    • 그 외의 것은 자유롭게 구현이 가능하다.

중요한 것은, 소스 수정시 다른 소스의 영향도를 적게 가져가면서 변화에는 유연하게 만들기 위해 추상클래스를 사용한다는 점 !

추상클래스의 상속

  • 추상 클래스의 상속에도 extends 키워드 사용
  • 추상 클래스를 상속하는 클래스는 반드시 추상 클래스의 추상 메소드를 구현해야 함
  • 추상 클래스간의 상속에서는 추상클래스를 구현하지 않아도 됨
  • 추상 클래스의 추상 메소드를 상속받아 정의하는 예시
abstract class Shape {
    public abstract double calculateArea();
}

class Triangle extends Shape {
    private double x;
    private double y;

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

    public double calculateArea() {
        return this.x * this.y / 2;
    }
}

class Rectangle extends Shape {
    private double x;
    private double y;

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

    public double calculateArea() {
        return this.x * this.y;
    }
}

public class ShapeDemo {
    public static void main(String[] args) {
        Shape triangle = new Triangle(10, 5);
        System.out.println("삼각형의 너비: " + triangle.calculateArea());

        Shape rectangle = new Rectangle(10, 20);
        System.out.println("사각형의 너비: " + rectangle.calculateArea());
    }
}
  • 추상 클래스의 연속 상속
abstract class Aclass {
	public abstract void Amethod();  // 추상 메소드
}
abstract class Bclass extends Aclass { // 추상 클래스를 상속받은 추상 클래스
	public abstract void Bmethod();
}

public class Cclass extends Bclass {
	public void Amethod() { ... } // 반드시 구현해야 함
	public void Amethod() { ... } // 반드시 구현해야 함
**}**

템플릿 메소드 패턴(Template Method Pattern)

  • 디자인 패턴 중 하나로, 알고리즘의 구조를 메소드에 정의하고,
  • 알고리즘의 일부 단계를 서브클래스에서 구현하도록 하여 알고리즘의 일부 변경을 허용하는 패턴이다.
  • → 공통의 알고리즘 과정이 있지만, 그 과정 중 일부가 클래스마다 다를 때 유용하다.
  • 추상 클래스를 사용하여 템플릿 메소드를 정의하고, 구체적인 작업은 서브클래스에서 오버라이드하여 구현

구조

  • 추상 클래스(Abstract Class)
    • 알고리즘의 단계를 정의하는 템플릿 메소드와 알고리즘의 일부를 구현하는 하나 이상의 추상 메소드로 구성
  • 구체 클래스(Concrete Class)
    • 추상 클래스를 상속받아 추상 메소드를 구현한다. (알고리즘의 일부 단계를 구체화)
abstract class BeverageRecipe {
    public **final** void prepareRecipe() {  // 템플릿 메소드
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    abstract void brew(); // 추상 메소드

    abstract void addCondiments(); // 추상 메소드

    public void boilWater() {
        System.out.println("물을 끓입니다.");
    }

    public void pourInCup() {
        System.out.println("컵에 따릅니다.");
    }
}

class Coffee extends BeverageRecipe {
    @Override
    void brew() {
        System.out.println("필터를 통해 커피를 우려냅니다.");
    }

    @Override
    void addCondiments() {
        System.out.println("설탕과 우유를 추가합니다.");
    }
}

class Tea extends BeverageRecipe {
    @Override
    void brew() {
        System.out.println("차를 우려냅니다.");
    }

    @Override
    void addCondiments() {
        System.out.println("레몬을 추가합니다.");
    }
}

public class TemplateMethodPatternDemo {
    public static void main(String[] args) {
        BeverageRecipe tea = new Tea();
        tea.prepareRecipe();

        BeverageRecipe coffee = new Coffee();
        coffee.prepareRecipe();
    }
}

Java Interface

개념

  • 서로 관계가 없는 물체들이 상호 작용을 하기 위해서 사용하는 장치나 시스템
  • 클래스 구조상의 관계와 상관 없이 클래스들에 의해 구현되어질 수 있는 규약

목적

  • 클래스들 사이의 유사한 특성을 부자연스러운 상속 관계를 설정하지 않고 얻어냄

활용

  • 하나 또는 그 이상의 클래스들에서 똑같이 구현되어질 법한 메소드를 선언하는 경우
  • 클래스 자체를 드러내지 않고 객체의 프로그래밍 인터페이스를 제공하는 경우

클래스 vs 인터페이스

  • 완결한 메소드(Concrete method)
    • 메소드의 구현을 포함한 일반적인 메소드를 concrete method라 함
    • 추상 메소드(Abstract Method)의 반대 개념

✔ 인터페이스의 상속

  • 인터페이스는 다중 상속을 지원하지 않는 자바에서 다중 상속의 장점을 활용하기 위해 도입
  • 한 클래스는 하나의 부모 클래스를 가지며 하나 이상의 인터페이스를 구현할 수 있다.
  • 인터페이스 사이에서는 다중 상속이 가능하다.
  • interface 키워드로 선언하고 implements 키워드로 사용
  • 인터페이스를 구현한 클래스에서 추상 메소드를 반드시 정의해야 함
interface Ainter {
    public void aMethod();
    public void same();
}
interface Binter extends Ainter{
    public void bMethod();
}
interface Cinter{
    public void cMethod();
    public void same();
}
interface Dinter extends Cinter, Binter{
    // 인터페이스들 간에는 다중 상속이 가능하다.
    public void dMethod();
}
class DImpl implements Dinter{
    @Override
    public void aMethod() {
        System.out.println("aMethod 구현");
    }
    @Override
    public void bMethod() {

    }
    @Override
    public void same() {

    }
    @Override
    public void cMethod() {
        System.out.println("aMethod 구현");
    }
    @Override
    public void dMethod() {
        System.out.println("aMethod 구현");
    }
}

public class InterfaceDemo{
    public static void main(String[] args) {
        // 인터페이스도 타입이다.
        Ainter ainter = new DImpl();
        Cinter cInter = new DImpl();

        // 자기가 정의한 것만 사용 가능
        ainter.aMethod();
        cInter.cMethod();

        Binter binter = new DImpl();
        Dinter dinter = new DImpl();

        binter.aMethod();
        binter.bMethod();
        binter.same();

        /* 타입이 아는 것 까지만 쓸 수 있고,
         * 외의 것을 쓰고 싶다면 형변환이 필요 */
        ((DImpl)ainter).say();
    }
}

default 메소드

  • 인터페이스가 default 키워드로 선언되면 메소드가 구현될 수 있다.
  • 또한 이를 구현하는 클래스는 default 메소드를 오버라이딩 할 수 있다.
  • 인터페이스가 변경이 되면, 인터페이스를 구현하는 모든 클래스들이 해당 메소드를 구현해야 하는 문제가 있다.
  • → 이런 문제를 해결하기 위하여 인터페이스에 메소드를 구현해 놓을 수 있도록 함
interface Calculator {
    public int plus(int i, int j);

    public int multiple(int i, int j);

    default int exec(int i, int j) {  // default로 선언함으로 메소드를 구현할 수 있다.
        return i + j;
    }
}

class MyCalculator implements Calculator {
    @Override
    public int plus(int i, int j) {
        return i + j;
    }

    @Override
    public int multiple(int i, int j) {
        return i * j;
    }
}

public class CalculatorDemo {
    public static void main(String[] args) {
        Calculator cal = new MyCalculator();

        System.out.println(cal.plus(5, 10));
        System.out.println(cal.multiple(5, 10));
        
        int value = cal.exec(5, 10);
        System.out.println(value);
    }
}

인터페이스의 static

변수

  • 인터페이스에서 int a = 10; 과 같이 멤버 변수를 선언하게 되면 static final 로서 선언된다. (생략 가능, 생략 하더라도 static final 로서 선언됨)
  • 즉, 인터페이스에서 변수를 선언하게 되면, 그 변수는 상수가 된다.
  • → 상수로서 변수와 구분을 위해 대문자로 선언하는 것이 관례이다.

static 메소드

  • 인터페이스에 static 메소드를 정의하는 것은, 클래스에 static 을 정의하는 것과 동일하다.
  • 인터페이스에서 메소드 구현이 가능하다.
  • 반드시 클래스 명으로 메소드를 호출해야 한다.
728x90
728x90

3월 25일 월요일 학습 내용


객체지향

  • 객체들의 모임으로 파악하고자 하는 것
  • 각각의 객체는 메시지를 주고받고, 데이터를 처리할 수 있음
  • 객체지향 관점에서의 서점
    • 책을 관리하는 것은? <책장>
    • 손님을 관리하는 것은? <방명록>
    • 돈을 관리하는 것은? <금고>


객체 지향 프로그래밍

  • 객체 지향 프로그래밍은 컴퓨터 프로그래밍의 패러다임 중 하나이다.  
  • “객체”들의 모임으로 파악하고자 하는 것
    → 각각의 객체는 메시지를 주고받고, 데이터를 처리할 수 있다.
  • 클래스 class
  • 오브젝트 object
  • 인스턴스 instance
  • 참조형 변수 reference variable
  • 핵심 : 메시징 => 객체가 어떻게 해야 하는가가 아니라 무엇을 해야하는가를 설명한다는 것 (메소드)


final 키워드

  • 변수(variable), 메서드(method), 또는 클래스(class)에 사용 가능
  • 변수에 final을 붙이면 이 변수는 수정할 수 없다는 의미
  • 메서드에 final을 붙이면 override를 제한
  • final 키워드를 클래스에 붙이면 상속 불가능 클래스


접근제한자

  • public, protected, package, private가 있다.
    • public : 외부 클래스가 자유롭게 사용할 수 있도록 한다.
    • protected : 같은 패키지 또는 자식 클래스에서 사용할 수 있도록 한다.
    • default**(**package) : 같은 패키지에서 사용할 수 있도록 한다.
    • private : 외부 클래스에서 사용할 수 없도록 한다.접근제한자

  • package안의 하위 package가 있더라고 다른 package로 보기 때문에 사용하고자하는 package를 import 해줘야한다.

 

<예시 코드>

  • com.example.util 패키지 안에 있는 Calculator 클래스
package com.example.util;

public class Calculator {
    public int plus(int a, int b){
        return a+b;
    }
    public int minus(int a, int b){
        return a-b;
    }
}
  • com.example.main 패키지 안에 있는 CalculatorTest 클래스
package com.example.main;

// util 패키지에 있는 클래스를 사용하기 위해 import
import com.example.util.Calculator; 

public class CalculatorTest {
    public static void main(String[] args) {
        Calculator cal = new Calculator();
        System.out.println(cal.plus(1,5));
        System.out.println(cal.minus(5,2));
    }
}

클래스

    • 자바에서 클래스는 설계도라고 본다.
    • 클래스는 필드(속성, Field)와 메소드(행위, 기능, Method)를 가진다.
    • 클래스에는 객체를 생성하기 위한 필드와 메소드가 정의되어 있어야한다.
    • 클래스로부터 객체를 만드는 과정을 인스턴스화라고 한다.
    • 하나의 클래스로부터 여러 객체를 만들 수 있음
    • 클래스로부터 만들어진 객체를 해당 클래스의 인스턴스라고 함
    • main 메소드가 없는 클래스는 실행되지 않음

 

필드(field)

  • 클래스가 가지는 속성
  • 다른 언어의 경우 멤버변수라고 하는 경우도 있다.
  • static 키워드가 함께 사용되는 필드를 클래스 필드, 함께 사용되지 않는 필드를 인스턴스 필드라고 한다.

필드 선언 방법

[접근제한자] [static] [final] 타입 필드명 [=초기값];

String name;
String address = "경기도 수원시";
public int age = 50;
protected boolean flag;​

 

  • 대괄호 안에 있는 내용은 생략가능하다는 뜻
  • 필드의 첫번째 글자는 소문자로 시작하는 것이 관례이며, 자바의 경우 흔히 카멜 케이스로 작성
  • 타입(type)은 기본형(boolean, byte, …)과 참조타입(class, 인터페이스, 배열) 등 사용가능
  • 초기값이 없는 경우
    • 참조형일 경우 null / boolean형일 경우 false / 나머지 기본형은 모두 0 으로 초기화된다.

 

클래스 선언

클래스 선언 방법

public class 클래스명 {

}
  • Dice 클래스와 클래스의 필드 및 메소드 선언
package com.example.util;

public class Dice {

    private int face;
    private int eye;

    public void roll(){
        eye = (int)(Math.random()*face) + 1;
    }
    public int getEye(){
        return eye;
    }
    public void setFace(int face) {
        this.face = face;
    }
}

 

객체 선언

객체 선언 방법

   클래스명 객체명 = new 클래스명();
// 참조타입 참조변수 new연산자 생성자
  • 메모리
    • new 연산자를 사용할 때마다 메모리에 인스턴스가 생성.
    • 인스턴스는 더 이상 참조되는 것이 없을 때, 보통 메모리 부족시 가비지 컬렉션(Garbage Collection)에 저장
    • static한 필드는 클래스가 로딩될 때 딱 한번 메모리에 올라가고 초기화
    • 인스턴스 메소드(static이 안붙은 메소드)는 인스턴스를 생성하고나서 레퍼런스 변 수를 이용해 사용
    • 클래스 메소드는 클래스명.메소드명() 으로 사용가능
    • 메소드 안에 선언된 변수들은 메소드가 실행될 때 메모리에 생성되었다가, 메소드가 종료될 때 사라짐
  • DiceTest 클래스에서 Dice 클래스 객체 생성
package com.example.main;

import com.example.util.Dice;

public class DiceTest {
    public static void main(String[] args) {
        Dice dice = new Dice();
        dice.setFace(6);
        dice.roll();
        int eye = dice.getEye();
        System.out.println(eye);
    }
}

 

메소드 선언

  • 객체지향의 핵심은 “메시징”이다.
  • 자율적인 객체는 스스로 정한 원칙에 따라 판단하고 스스로의 의지를 기반으로 행동하는 객체이다.
  • 객체가 어떤 행동을 하는 이유는 다른 객체로부터 요청을 수신했기 때문이다.

메소드 선언 방법

[접근제한자][static]리턴type 메소드이름([매개변수,...]) {
실행문..
}
    • 메소드 이름은 소문자로 시작하는 것이 관례이다.
    • 클래스의 메소드를 호출하려면
      • 클래스에 대한 인스턴스를 생성하거나
      • 래퍼런스 변수를 이용하여 메시지를 전송한다. (메소드 호출)
      • static 메소드는 인스턴스를 생성하지 않아도 호출할 수 있다.
  • 전달인자 : 메소드를 호출할 때 전달하는 실제 값
  • 매개변수 : 메소드 정의 부분에 나열되어있는 변수
728x90

+ Recent posts