1. API

import java.lang.*;
System.out.println(1);

• System: 클래스
• out: 클래스의 필드(변수), 객체 (필드가 메소드 가짐), static (System을 인스턴스화한적이 없음에도 불구하고 필드 out에 접근할 수 있음
• println: 메소드
• java.lang: 자바 프로그래밍을 하기 위해서 필수적인 클래스들을 모아둔 패키지 (자동으로 로딩)

==> 자바 에플리케이션을 만든다는 것은 결과적으로 자바에서 제공하는 패키지들을 부품으로 조립해서 사용자 정의 로직을 만드는 과정

---

• API: 시스템을 제어하기 위해서 자바에서 제공하는 명령어들을 의미 (패키지 java.lang.*의 클래스들도 자바에서 제공하는 API 중의 하나)
  • java.lang
    자바 프로그래밍을 위한 가장 기본적인 패키지와 클래스를 포함하고 있다.
  • java.util
    프로그램을 제어하기 위한 클래스와 데이터를 효율적으로 저장하기 위한 클래스들을 담고 있다.
  • java.io
    키보드, 모니터, 프린터, 파일등을 제어할 수 있는 클래스들의 모음
  • java.net
    통신을 위한 기능들을 담고 있다.

2. 접근 제어자

• 클래스의 맴버(변수와 메소드)들의 접근 권한을 지정

class A {
    public String y(){
        return "public void y()";
    }
    private String z(){
        return "public void z()";
    }
    public String x(){
        return z();
    }
}
public class AccessDemo1 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.y());
        // 아래 코드는 오류가 발생한다.
        //System.out.println(a.z());
        System.out.println(a.x());	// public -> private 가능
    }
}

• public 클래스가 포함된 소소코드는 public 클래스의 클래스 명과 소스코드의 파일명이 같아야 함 (PublicNameDemo.java -> public class PublicNameDemo{})
  => 하나의 소스 코드에는 하나의 public 클래스가 존재
• 접근 제어자가 public인 클래스는 다른 패키지의 클래스에서도 사용할 수 있고, default인 경우는 같은 패키지에서만 사용 가능

package org.opentutorials.javatutorials.accessmodifier.inner;
public class PublicClass {}
class DefaultClass {}

package org.opentutorials.javatutorials.accessmodifier.outter;
import org.opentutorials.javatutorials.accessmodifier.inner.*;
public class ClassAccessModifierOuterPackage {
    PublicClass publicClass = new PublicClass();
    //DefaultClass defaultClass = new DefaultClass();	// 다른 패키지이므로 사용 불가
}

3. abstract (추상화)

• abstract 클래스나 메소드를 사용하기 위해서는 반드시 상속해서 사용하도록 강제하는 것 (규제)
• 추상 메소드: 메소드의 시그니처만이 정의된 비어있는 메소드
• 추상 메소드를 하나라도 포함하고 있는 클래스는 추상 클래스가 됨 (클래스의 이름 앞에 abstract 붙음)

abstract class A{
    public abstract int b();
    //본체가 있는 메소드는 abstract 키워드를 가질 수 없다.
    //public abstract int c(){System.out.println("Hello")}	// 오류 발생
    //추상 클래스 내에는 추상 메소드가 아닌 메소드가 존재 할 수 있다. 
    public void d(){
        System.out.println("world");
    }
}
public class AbstractDemo {
    public static void main(String[] args) {
        A obj = new A();	// 추상 클래스 A를 인스턴스화하면 오류가 발생 (추상 클래스는 구체적인 메소드의 내용이 존재하지 않기 때문)
    }
}

• 추상 클래스의 상속: 클래스 A를 상속한 하위 클래스를 만들고 추상 메소드를 오버라이드해서 내용있는 메소드를 만들어야 함

abstract class A{
    public abstract int b();
    public void d(){
        System.out.println("world");
    }
}
class B extends A{
    public int b(){return 1;}
}
public class AbstractDemo {
    public static void main(String[] args) {
        B obj = new B();
        System.out.println(obj.b());
    }
}

• 상황에 따라서 동작 방법이 달라지는 메소드(sum, avg)는 추상 메소드로 만들어서 하위 클래스에서 구현하도록 하고 모든 클래스의 공통분모(setOprands, run)의 경우에는 상위 클래스에 두어서 코드의 중복, 유지보수의 편의성 등을 꾀할 수 있다
• 디자인 패턴: 자주 사용하는 템플릿 모양 모아둔 것 (반복되는 패턴 정리한 것)
  • 좋은 설계를 단기간에 학습
  • 소통에 도움

4. final

• 상속/변경 금지
• final 필드: 한번 값이 정해진 이후에는 변수 내의 값이 바뀌지 않도록하는 규제

class Calculator {
    static final double PI = 3.14;	// final 선언
    int left, right;
 
    public void setOprands(int left, int right) {
        this.left = left;
        this.right = right;
        //Calculator.PI = 6;	// 변경 안됨
    }
}
 
public class CalculatorDemo1 {
 
    public static void main(String[] args) {
 
        Calculator c1 = new Calculator();
        System.out.println(c1.PI);
        //Calculator.PI = 10;	// 변경 안됨
    }
 
}

• final 메소드: 사용 빈도가 높지는 않음

class A{
    final void b(){}
}
class B extends A{
    void b(){}		// 상속 안됨
}

• final 클래스

final class C{
    final void b(){}
}
class D extends C{}	// 상속 안됨

5. 인터페이스

• 어떤 객체가 특정한 인터페이스를 사용한다면 그 객체는 반드시 인터페이스의 메소드들을 구현해야함.
• 클래스 뒤에 implements는 인터페이스를 구현하고 있다는 의미
• 상속이 상위 클래스의 기능을 하위 클래스가 물려 받는 것이라면, 인터페이스는 하위 클래스에 특정한 메소드가 반드시 존재하도록 강제하는 것
• 클래스를 선언 할 때는 class를 사용하지만 인터페이스는 interface를 사용

interface I{
    public void z();
}
 
class A implements I{
    public void z(){}	// 반드시 존재해야함
}

• 인터페이스를 이용해서 서로가 동일한 메소드를 만들도록 규약을 만들어서 공유하고, 그 결과 각자가 상대의 일정이나 구현하는 방식에 덜 영향을 받으면서 에플리케이션을 구축함

package org.opentutorials.javatutorials.interfaces.example2;
 
public interface Calculatable {
    public void setOprands(int first, int second, int third) ;
    public int sum(); 
    public int avg();
}

package org.opentutorials.javatutorials.interfaces.example2;
class CalculatorDummy implements Calculatable{
    public void setOprands(int first, int second, int third){
    }
    public int sum(){
        return 60;
    }
    public int avg(){
        return 20;
    }
}
public class CalculatorConsumer {
    public static void main(String[] args) {
        CalculatorDummy c = new CalculatorDummy();
        c.setOprands(10, 20, 30);
        System.out.println(c.sum()+c.avg());
    }
}

• 하나의 클래스가 여러개의 인터페이스를 구현 가능
• 인터페이스도 상속 가능
• 인터페이스의 맴버는 반드시 public (생략해도 public)
• 인터페이스: 클래스가 아닌 인터페이스라는 고유한 형태를 가짐, 구체적인 로직이나 상태 없음
  추상클래스: 일반적인 클래스, 구체적인 로직이나 상태를 가지고 있을 수 있음