2022-07-12

강아람·2022년 7월 13일
0

Kakao Cloud School

목록 보기
6/30
post-thumbnail

Java

overview

  1. language spec
    • variable
    • data dype
      • primitive data type (8개의 기본 data type)
      • reference data type (class data type)
    • 제어문
    • 연산자
    • 객체지향 개념이 언어에서 어떻게 표현이 되는지
    • API


JVM

  • 프로그램을 실행시켜주는 주체
  • JDK [JRE(JVM + core API) + 개발용 utility]
    • 현재 Java 버전은 version 18
    • 일반적으로 사용되는 버전은 Java8 or Java11
  • Network와 분산처리 => 가장 좋은 성능
  • Java Application : class의 집합
  • 1개 Java source code - 1개 Class
    • class 이름으로 file의 이름을 명시
    • 특히 public class의 이름은 무조건 파일명으로 사용
    • public : 해당 클래스를 다른 패키지에서도 사용할 수 있음
  • 전역 개념이 없음 (global X)
  • main() method : application의 entry point(starting point)
class Student {
    // field
    // constructors
    // methods
}


Program 실행 순서

  1. JVM 가동
  2. class loader가 해당 class를 loading
  3. class file에 대한 검사
  4. 정상적인 class임이 확인되면 main() 호출

    • public

      • class loader(자바 프로그램)와 우리 코드는 서로 다른 package

      • 다른 package인 class loader가 main() 메소드를 실행하려면 main()이 public으로 지정되어야 함

        Java의 모든 클래스는 특정 패키지에 묶여있음
클래스 로더는 자바 프로그램 중 하나임
클래스 로더가 우리 메인 메소드를 호출하려면 메인 메소드가 다른 패키지(클래스로더)에 의해 사용될 수 있는 메소드로 지정되어야 함 (public)

    • static

      • 인스턴스를 생성하지 않고 main() 메소드를 호출해야 하기 때문에 main()이 static으로 지정되어야 함

        - 메소드나 필드를 사용하려면 인스턴스가 생성되어야 함
- 인스턴스를 생성하지 않고 클래스 이름으로 메소드를 호출하려면 static으로 클래스를 선언해야 함

    • void
      - main() 메소드의 실행이 끝나면 프로그램이 종료되기 때문에 return 값이 없음
      - return type을 void로 지정



JVM의 Memory 구조

  1. Register (실행 pointer 관리)
  2. Runtime Constant Pool (상수값 사용)
  3. 🌟Method Area🌟
  4. 🌟Call Stack🌟
  5. 🌟Heap🌟

패키지 이름 packaged lecture0712으로 묶어져야 한다.
묶이지 않으면 default package로 지정됨

package lecture0712;

public class Main {

	// default constructor 존재
	
	public static void main(String[] args) {
		InstanceTest test;	// 지역변수 선언 (메서드 내에서 선언되었기 때문)
 		// 같은 패키지에 있는 클래스를 처음 사용하기 때문에 
		// 이 시점에서 딱 한 번 클래스에 대한 정보를 Method Area에 올림
		// 이때 static 변수에 대한 공간이 만들어짐 (멤버변수는 X)
		
		// test 변수는 main() 메서드에서 생성되었으므로 call stack의 main() 영역에 공간 생성됨
		System.out.println("3번");
		int k = InstanceTest.myCall("4번");
		test = new InstanceTest();
		test.printMsg("5번");
	}

}

package lecture0712;

public class InstanceTest {
	// fields
	int a = myCall("");
	static int b = myCall("2번");
	
	// constructor
	public InstanceTest() {
		
	}
	
	// methods
	public static int myCall(String msg) {
		System.out.println(msg);
		return 100;
	}
	
	public void printMsg(String msg) {
		int a = 100;
		System.out.println(msg);
	}
}

JVM이 Main 클래스의 main() 메소드를 찾아 호출
main() 메소드가 호출되면 call stack에 main() 의 영역이 잡힘
String[] args : String 배열인 파라미터(지역변수) -> 해당 메서드의 영역 내에 생성



Method Overloading

method 이름이 같아도 인자의 개수, type에 따라 다른 method로 간주


Package & import


Access Modifier

  • public
  • protected
  • package(default)
  • private

Static block

  • main()을 사용하기 전에 특수한 처리(Library loading)를 하기 위해 사용
package lecture0712;

public class MyClass {
	// fields
	int aaa;
	static int bbb = staticCall();
	
	// 생성자
	public MyClass() {
		// default 생성자의 내용이 없어도 일단 쓰는 것이 좋다.
	}
	
	// static block
	static {
		// main이 실행되기 직전에 프로그램에 필요한 
		// 다른 library를 loading할 필요가 있을 때
		System.out.println("static block");
	}
	
	// methods
	static int staticCall() {
		System.out.println("static Call 호출되었어요!");
		return 100;
	}
	
	public static void main(String[] args) {
		System.out.println("main 호출");
	}
}



Inheritance(상속)

부모 class가 가지는 내용을 확장해서 자식 class를 만드는 방식

  • ex) 학사 시스템

    • Teacher

    • Student

    • Staff

      class Student {
    String name;
    String mobile;
    String dept;
}

class Teacher {
    String name;
    String mobile;
    String subject;
}

class Staff {
    String name;
    String mobile;
    int salary;
}
  1. extends keyword로 상속 구현
    2. class Person {
	String name;
	String mobile;
}

class Student extends Person {
	String dept;
}

class Teacher extends Person {
	String subject;
}

class Staff extends Person {
	int salary;
}
  2. 단일 상속만 지원 (다중 상속 지원 X)

    • 두 개의 클래스에서 상속을 받을 때 중복된 필드나 메소드의 이름이 존재할 경우 모호성이 생김 -> 모호성 배제를 위해 단일 상속만 지원

    • 상속은 항상 좋은가?

    • 코드의 중복을 줄이고 재사용성을 높이는 데에는 Good

    • 클래스 단위로 재사용할 경우 문제가 생길 수 있음 (tightly coupled)




Constructor가 상속에서는 어떻게 동작하나요?

  • 상속되지 않는 요소

    • constructor
    • private access modifier로 지정된 field, method

  • 기본적으로

    • 기본적으로 java.lang.* 패키지가 import 되어있음
    • 기본적으로 모든 클래스는 extends Object
      • Object는 최상위 클래스 (java의 모든 클래스는 Object 클래스를 상속)
      • java의 모든 클래스는 특정 패키지에 속해 있음 -> Object class는 java.lang.Object로 패키지화되어 제공됨

  • instance 생성

    • 최상위 객체부터 생성되고, 그 객체를 둘러싸면서 객체가 만들어진다.

  • new keyword
    - 생성자를 호출해 객체 생성, 초기화

    ```
// import java.lang.*;

// class Person extends Object
class Person {	
    String name;
    String mobile;
    
//	public Person() {
//		super();
//	}
    
//	public Person(String name) {
//		this.name = name;
//  }

    public Person() {
        System.out.println("AA");
    }
}

class Student extends Person {
    String dept;
    
    // default 생성자 : 생성자를 만들지 않으면 기본적으로 만들어짐
    // public Student() {
    //		Person(); -> Student 클래스에서 직접 호출할 수 없음
    //		super();
    // }
    
    public Student() {	
        super();
        System.out.println("BB");
    }
}

public class Main {
    public static void main(String[] args) {
//		Person p =  new Person();
//		Student s = new Student();
        // is-a relationship
        // subclass is a superclass
        Person s = new Student();
    }
}
```



Method Overriding(메소드 재정의)

  • this : 현재 사용하고 있는 instance에 대한 reference
  • this() : 자신의 class가 가지고 있는 다른 생성자 호출
  • super : 현재 사용하고 있는 instance에 대한 reference이나 상위 type
  • super() : 상위 클래스의 생성자 호출
class Person {	// class Person extends Object
	String name;
	String mobile;
	
	public void printAll() {
		System.out.println("모두 출력!");
	}
}

class Student extends Person {
	String name;	// 필드 재정의 : 권장 X
	String dept;
	
    // default constructor
    public Student() {
        this("홍길동"); // 다른 생성자 호출
    }

    public student(String name) {
        this.name = name;
    }

	public void printAll() {	// 오버라이딩
		System.out.println("오버라이딩!");
	}
}

public class Main {
	public static void main(String[] args) {
		Student s = new Student();
	}
}
class Superclass {
	// static method
	static int staticCall(String msg) {
		System.out.println(msg);
		return 100;
	}
	
	// fields
	int a = staticCall("1번입니다.");
	static int b = staticCall("2번입니다.");
	
	// constructor
	public Superclass() {
		staticCall("3번입니다.");
	}
	
	public Superclass(int i) {
		this();
		staticCall("4번입니다.");
	}
	
	//	method
	public void myFunc() {
		System.out.println("5번입니다.");
	}
}

public class InheritanceTest extends Superclass {
	// fields
	int c = staticCall("6번입니다.");
	static int d = staticCall("7번입니다.");

	// constructor
	public InheritanceTest() {
		super(100);
		staticCall("8번입니다.");
		super.myFunc();
	}

	@Override
	public void myFunc() {
		System.out.println("10번입니다.");
	}
	
	public static void main(String[] args) {
		System.out.println("10번입니다.");
		Superclass obj = new InheritanceTest();
		obj.myFunc();
	}
}

결과

  • 2번입니다.

    7번입니다.

    10번입니다.

  • instance를 만든 후에 초기화를 해야하기 때문에 field에 대한 공간이 먼저 만들어져야 함

    1번입니다.

  • 상위 클래스 객체를 만들기 위해 생성자 함수 호출됨

    3번입니다.


    4번입니다.

  • instance를 생성하기 위해 field가 초기화되어야 함

    6번입니다.

  • instance 생성자 함수 호출

    8번입니다.

  • super.myFunc() 호출

    5번입니다.

  • obj.myFunc() 호출 (overriding)
    - Superclass obj(상위 클래스 타입)인데 왜 5번이 아닌 9번일까?
    - 동적 바인딩(dynamic binding) : 객체에 대한 type이 상위 타입이라 할지라도 만약 overriding된 method가 하위에 존재한다면 overriding된 method를 사용한다.
    9번입니다.



  • final
    - 변수 앞에 붙으면 상수 처리

    ```
final int K = 100;
```

- class 앞에 붙으면 상속 불가

```
final class A {
    ...
}
```

- method 앞에 붙으면 overriding(재정의) 불가

```
final void kk() {
    ...
}
```



Abstract Class (추상 클래스)

  • abstract method가 1개 이상 존재하는 class
    • abstract method : method의 선언만 존재, 정의가 없음
  • 추상 클래스로는 instance 생성 불가
  • 추상 메소드 : 이름 앞에 abstract를 붙여주어야 한다.
  • 추상 메소드가 1개 이상 존재하면 클래스 앞에도 abstract keyword를 붙여주어야 한다.
  • 하위에서 추상 클래스를 상속하고 메소드를 오버라이딩 하여 사용 (인터페이스 통일)
public abstract class UpperClass {
	// field
	String name;
	int age;
	
	// method
	public abstract void printAll();	// Abstract method
	
}

class subClass extends UpperClass {
	public void printAll() {
	}
}


추상 클래스의 매우 특별한 형태

=> Interface

  1. 클래스의 모든 메소드가 추상 메소드임
  2. 모든 field가 public static final로 선언되어 있음(어디에서나 사용할 수 있는 상수)

-> is-a relationship 성립

profile
강아람
이전 포스트

2022-07-08

다음 포스트

2022-07-13

0개의 댓글