반응형

# 상속관계에서 객체생성 방법

## 상속관계에서 객체 생성 방법

  • 객체 생성 : new 연산자와 생성자 메서드 활용하여 객체 생성.
  • 상속관계(부모-자식)에서 객체 생성 : 나(하위 클래스)를 기준으로 나라는 존재가 만들어지기 전에, 부모(상위 클래스)가 먼저 만들어져야 한다.
  • 간접 이용 : 상위(부모)클래스를 이용하는 방식 (하위 클래스의 동작 방식을 모를 때, class 파일(=실행파일)만 있고 java 파일(=소스파일)은 없을 때 사용). 이때 하위 클래스를 접근할 수 없음, 재정의(오버라이드)를 이용하면 가능 함.
Animal dog = new Dog();
dog.eat();

Animal cat = new Dog();
cat.eat();
cat.night();
  • 직접 이용 : 상위(부모)클래스를 이용하지 않는 방식.
Dog dog = new Dog();
dog.eat();

Cat cat = new Cat();
cat.eat();
cat.night();

##상속관계에서 객체 생성 방법 (실습)

  • 모든 클래스는 상속을 받지 않으면 기본적으로 루트 클래스인 Object 클래스(최상위 클래스)를 상속받음.
  • 다형성 : 상위(부모) 클래스가 하위(자식) 클래스에게 동일한 메시지를 보내면 하위 클래스가 서로 다르게 동작하는 것. (상속 관계에서 업캐스팅 시 적용)
public class Animal extends Object {
	public void eat() {
		System.out.println("?");	// 포괄적, 추상적.
	}
	
	public Animal() {
		super();	// new Object();
	}
}
public class Dog extends Animal {
	// 이름, 나이, 종 등 : 상태정보 존재.
	
	// 재정의(override)
	public void eat() { 
		System.out.println("멍멍이 처럼 먹는다."); 
	}	
	
	public Dog() {
		super();	// new Animal();
	}
}
public class Cat extends Animal {
	// 이름, 나이, 종 등 : 상태정보 존재.
	
	@Override
	public void eat() { 
		System.out.println("고양이 처럼 먹는다."); 
	}
	
	
	public void night() {
		System.out.println("고양이는 밤에 눈에서 빛이 난다.");
	}
	
	public Cat() {
		super();	// new Animal();
	}
}
public class TPC22 {
	public static void main(String[] args) {
		// 재정의(오버라이드) 유무에 따라 하위(자식)클래스의 메서드 구동 가능 여부가 결정됨.
		// 1. 직접 이용
		Dog dog = new Dog();
		dog.eat();
		
		Cat cat = new Cat();
		cat.eat();
		cat.night();
		
		// 2. 간접 이용	: 상속관계가 선행되어야 사용 가능.
		Animal d = new Dog();	// UpCasting (자동 형 변환)
		d.eat();
		
		Animal c = new Cat();
		c.eat();
		((Cat)c).night();	// DownCasting (강제 형 변환)
	}
}
반응형
반응형

# 수평적 구조와 수직적 구조

## 상속 (Inheritance : 키워드는 extends 임을 기억하라.) _ 클래스의 설계 (행위적인 측면)

1. 수평적 설계

멍멍이 클래스
- 이름, 나이, 종, 먹다

고양이 클래스
- 이름, 나이, 종, 먹다


=>
위 처럼 이름, 나이, 종, 먹다 등의 특징이 모든 종에 존재할 수 있음. 
아래와 같은 문제점들이 발생한다.

# 문제점
1. 코드의 중복 발생.
2. 새로운 요구사항에 대한 콛의 수정이 불가피.
3. 관리하기가 어려움 (부모와 자식의 관계)

2. 수직적 설계 (계층화 / 상속구조) : 수평 구조를 수직적 구조로 바꾸면 위의 문제점들 해결 가능.

동물 (멍멍이, 고양이의 상위 클래스)
- 해당 클래스에서 중복되는 코드(이름, 나이, 종, 먹다 등) 생성.

동물을 -> 상위 클래스, 부모 클래스

멍멍이와 고양이를 -> 하위 클래스, 자식 클래스


수직적 설계를 하게 되면...
1. 수평적 설계의 단점을 극복할 수 있음.
2. 확장을 쉽게 할 수 있음.
3. 대신 코드가 복잡해진다. (하지만 이점이 많음)
  • 상속은 자식(하위) 클래스에서 부모(상위) 클래스로 갈수록 추상화/보편화/일반화/개념화 되고,
  • 반대로 부모(상위) 클래스에서 자식(하위) 클래스로 갈수록 세분화/상세화/구체화/구상화 된다.

## 상속 (예)

1. 중복된 코드 존재.

1. 멍멍이 클래스
public class Dog {
	public void eat() {
    	System.out.println("개 처럼 먹다.");
    }
}


2. 고양이 클래스
public class Cat {
	public void eat() {
    	System.out.println("고양이 처럼 먹다.");
    }
}

2. 중복 제거

1. 동물 클래스
public class Animal extends Object {
	pulbic String name;
	public int age;
	public String part;
    
	public void eat() {
		System.out.println("?");
	}
    
	public Animal() {	// new Object
		super();
	}
}

2. 멍멍이 클래스
public class Dog extends Animal {
	public Dog() {	// new Animal
		super();
	}
}


3. 고양이 클래스
public class Cat extends Animal {
	public Cat() {	// new Animal
		super();
	}
}
  • super() : 자신의 생성자에서 부모의 생성자를 호출 함. (상속에서 부모-자식을 연결하는 방법.)
  • 상속 체이닝 기법을 이용해서 위와 같이 표현 가능.

## 상속 (실습)

객체지향에서 상속은 소유의 개념이 아님, 즉 자식이 부모에 포함되는게 아님. (부모클래스 에서 자식 클래스에 있는 기능을 물려준다면 자식 클래스 입장에서는 해당 기능을 사용할 수 있는 것. 즉, 확장되는 것)

package kr.tpc;

public class Animal {
	public void eat() {
		System.out.println("?");	// 포괄적, 추상적.
	}
}
package kr.tpc;

public class Dog extends Animal {
	// 이름, 나이, 종 등 : 상태정보 존재.
	
	/*
	 * public void eat() { System.out.println("멍멍이 처럼 먹는다."); }
	 */
}
package kr.tpc;

public class Cat extends Animal {
	// 이름, 나이, 종 등 : 상태정보 존재.
	
	// Dog, Cat의 공통.
	/*
	 * public void eat() { System.out.println("고양이 처럼 먹는다."); }
	 */
	
	public void night() {
		System.out.println("고양이는 밤에 눈에서 빛이 난다.");
	}
}
import kr.tpc.Animal;
import kr.tpc.Cat;
import kr.tpc.Dog;

public class TPC20 {
	public static void main(String[] args) {
		// Dog, Cat -> Animal
		
		Dog dog = new Dog();
		dog.eat();
		
		Cat cat = new Cat();
		cat.eat();
		cat.night();
		
		
		// 상속
		Animal ani = new Dog();
		ani.eat();
		
		ani = new Cat();
		ani.eat();

	}
}

 

# 재정의 (Override)

  • 상속 관계에서 상속받은 하위 클래스가 상위 클래스의 동작을 수정하는 것.
  • 재정의는 부모 메서드가 무시됨. 메모리에 부모와 자식 메서드가 공존하지만, 자식 메서드가 실행됨.
  • Override (재정의) :동적 바인딩(호출될 메서드가 실행시점에서 결정되는 바인딩) 프로그램의 속도가 떨어지는 원인이 되지만, 이점이 더 많아 사용 됨.
1. 동물
public class Animal {
	public void eat() {
		System.out.println("?");	// 포괄적, 추상적.
	}
}


2. 멍멍이
public class Dog extends Animal {
	// 이름, 나이, 종 등 : 상태정보 존재.
	
    // Dog, Cat의 공통. -> 재정의(오버라이드)
	public void eat() { 
		System.out.println("멍멍이 처럼 먹는다."); 
	}	
}


3. 고양이
public class Cat extends Animal {
	// 이름, 나이, 종 등 : 상태정보 존재.
	
	// Dog, Cat의 공통. -> 재정의(오버라이드)
	public void eat() { 
		System.out.println("고양이 처럼 먹는다."); 
	}
	
	
	public void night() {
		System.out.println("고양이는 밤에 눈에서 빛이 난다.");
	}
}
  • 업캐스팅 (UpCcasting) : 자동으로 형이 바뀌는 것으로, 부모와 자식간에는 아래와 같이 업캐스팅 가능.
Animal ani = new Dog();	// 부모, 자식 간 업캐스팅
  • 오버라이드 (Override) 를 통해 하위 클래스를 접근 할 수 있다.

## 재정의 (실습)

상속관계의 경우 자동 형 변환(UpCasting) 가능, 자동 형 변환이 된다면 강제 형 변환(DownCasting)도 가능 함.

public class Animal {
	public void eat() {
		System.out.println("?");	// 포괄적, 추상적.
	}
}
public class Cat extends Animal {
	// 이름, 나이, 종 등 : 상태정보 존재.
	
	@Override
	public void eat() { 
		System.out.println("고양이 처럼 먹는다."); 
	}
	
	
	public void night() {
		System.out.println("고양이는 밤에 눈에서 빛이 난다.");
	}
}
public class Dog extends Animal {
	// 이름, 나이, 종 등 : 상태정보 존재.
	
	// 재정의(override)
	public void eat() { 
		System.out.println("멍멍이 처럼 먹는다."); 
	}	
}
public class TPC21 {
	public static void main(String[] args) {
		
		// 상속 관계 -> 자식 = 부모
		
		// 부모클래스(Animal) 사용하지 않음.
		// 아래는 직접 설계하는 경우.
		Dog d = new Dog();
		d.eat();
		
		Cat c = new Cat();
		c.eat();
		c.night();
		
		// 부모클래스(Animal) 사용. (상속관계)
		Animal ani1 = new Dog();	// UpCasting(자동 형변환).
		ani1.eat();
		
		Animal ani2 = new Cat();
		ani2.eat();
		// ani2.night(); 는 Animal에 존재 하지 않으므로 아래와 같이 진행.
		((Cat)ani2).night();	// DownCating(강제 형변환)
	}
}
반응형
반응형

# 학습내용 정리.

## 클래스 (class)

  • 자료형 측면 (DataType) : 새로운 자료형을 만드는 도구(설계하는 도구 = 모델링 도구)
  • 객체지향 측면 (OOP) : 객체의 상태정보와 행위정보를 추출하여 캡슐화 하는 도구.
  • class를 Model 이라고 부른다. (역할이 정해지므로)

### 우리가 만드는 Model 의 종류. (아래와 같이 크게 3가지 종류를 만들게 됨)

1. DTO (Data Transfer Object)
- 데이터 구조, 데이터를 담는 역할, 이동하기 위해 데이터를 담는다.
- VO (Value Object) : 객체를 담아서 하나의 값(덩어리)으로 취급한다는 의미.


2. DAO (Data Access Object) 
- 데이터를 처리하는 역할(비즈니스 로직), 데이터베이스와 CRUD 하는 역할.


3. Utility (Helper Object) : 도움을 주는 기능을 제공하는 역할 (날짜, 시간, 통화, 인코딩 등)

 ## 우리가 앞으로 사용하게 될 class (API : Application Programming interface)

1. Java에서 제공해주는 class 들
- String, System, Integer, ArrayList, Map 등


2. 만들어서 사용하는 class 들
- DTO, DAO, Utility


3. 1, 2번에 해당하는 것이 아닌 다른 사람이 만들어서 제공해주는 class 들
- Gson, Jsoup, POI, iText 등

## class (실습)

  • 위 사이트에서 필요한 API 검색하여 jar 파일 다운로드 진행, 그 후 작업중인 디렉터리에 넣어서 사용하면 된다. (주로 lib 폴더에 넣어둠)
  • API 사용을 다운로드 받은 jar 파일 적용 방법 : 위해 패키지 우클릭 > Build Path > Configure Build Path > Libraries 탭에서 Classpath 선택 후 Add External JARs 클릭 하여 저장한 jar 파일 주입하여 사용.
import com.google.gson.Gson;

import kr.tpc.BookVO;
import kr.tpc.MyUtil;

//import java.lang.*;	//디폴트 패키지(생략)
public class TPC19 {
	public static void main(String[] args) {
		// 1. 자바에서 제공해주는 class들 -> API
		// 문자열 (String)
		String str = new String("APPLE");
		System.out.println(str.toLowerCase());	// 소문자로 출력하는 메서드.
		
		
		// 2. 직접 만들어서 사용하는 class 들 -> DTO/VO, DAO, Utility 등.
		MyUtil my = new MyUtil();
		System.out.println(my.hap());		
		
		
		// 3. 다른 사람(회사)에서 만들어 놓은 class 들 -> API
		// Gson -> json : https://mvnrepository.com/ 에서 다운로드 가능.
		Gson gs = new Gson();
		BookVO vo = new BookVO("갓바의 정석", 35000, "우리출판", 1500);
		String json = gs.toJson(vo);
		System.out.println(json);		// Gson 은 vo라는 객체를 문자열 형태로 바꿔주는 API
		
	}
}
반응형
반응형

# 메서드 오버로딩 (Method Overloading)

  • 같은 이름의 메서드를 여러 개 사용할 수 있는 것.
  • 메서드 오버로딩의 조건 : 매개변수의 타입과, 개수가 다르도록 해야 함. (메서드의 signature(매개변수의 타입, 개수)가 다르면 됨)
public class Test {
	public static void main(Stirng[] args) {
		OverLoad ov = new OverLoad();
		ov.hap(32.6f, 46);
		ov.hap(34, 62);
		ov.hap(74.6f, 26.6f);
	}
}

public class OverLoad {
	public void hap(int a, int b) {
		System.out.println(a+b);
	}
	public void hap(float a, int b) {
		System.out.println(a+b);
	}
	public void hap(int a, float b) {
		System.out.println(a+b);
	}
}
  • 오버로딩 (Overloading) : 정적 바인딩(컴파일 시점에서 호출될 메서드가 이미 결정되어 있는 바인딩) 으로 속도와는 관계 없음.

## 오버로딩 (실습)

package kr.tpc;

public class OverLoad {
	public void hap(int a, int b) {
		System.out.println(a + b);
	}
	public void hap(float a, int b) {
		System.out.println(a + b);
	}
	public void hap(int a, float b) {
		System.out.println(a + b);
	}
}
import kr.tpc.OverLoad;

public class TPC17 {
	public static void main(String[] args) {
		OverLoad ov = new OverLoad();
		ov.hap(10, 15);		// ov.hap_int_int(10, 15)
		ov.hap(15.2f, 10);	// ov.hap_float_int(15.f, 10)
		ov.hap(10, 13.6f);	// ov.hap_int_float(10, 13.6f)
	}
}

 

# 동일한 구조와 이질적인 구조

## 배열과 클래스의 관계

  • 데이터를 담는 바구니, 하나의 객체

### 배열

  • 정수 5개 저장 공간 생성 시 (동일한 데이터) => Array 동일한 데이터 구조.
int[] arr = new int[5];


=>
구조 이름 : int[]
arr[0], arr[1], arr[2], arr[3], arr[4]

### 클래스

  • 영화 관련 저장 공간 생성 시 (동일한 데이터 아닌 경우) => class 서로 다른(이질적인) 데이터 구조.
public class MovieVO {
	private String title;
	private int price;
	private String author;
	private int level;
	private float time;
}
MovieVO vo = new MovieVO();	

=>
구조 이름 : MovieVO[]
클래스의 경우 구조 생성 후 객체 생성을 해야 메모리에 객체가 만들어짐.

// 객체배열
MovieVO[] vo = new MovieVO[5];
vo[0] = new MovieVO();
vo[1] = new MovieVO();
vo[2] = new MovieVO();
vo[3] = new MovieVO();
vo[4] = new MovieVO();

## 배열과 클래스의 관계 (실습)

  • 배열의 경우
public class TPC18 {
	public static void main(String[] args) {
		// 1. 정수 5개 저장하는 배열
		// 생성방법 - 1.
		int[] a = new int[5];
		a[0] = 10;
		a[1] = 20;
		a[2] = 30;
		a[3] = 40;
		a[4] = 50;

		// 생성방법 - 2.
		int[] b = {10, 20, 30, 40, 50};
		
		// 생성방법 - 3.
		int[] c = new int[] {10, 20, 30, 40, 50};
		
		// 출력방법
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}		
	}
}
  • 클래스의 경우
package kr.tpc;

public class MovieVO {
	private String title;
	private int price;
	private String author;
	private int level;
	private float time;
	
	public MovieVO() {
		
	}

	public MovieVO(String title, int price, String author, int level, float time) {
		this.title = title;
		this.price = price;
		this.author = author;
		this.level = level;
		this.time = time;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		this.price = price;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

	public int getLevel() {
		return level;
	}

	public void setLevel(int level) {
		this.level = level;
	}

	public float getTime() {
		return time;
	}

	public void setTime(float time) {
		this.time = time;
	}

	@Override
	public String toString() {
		return "MovieVO [title=" + title + ", price=" + price + ", author=" + author + ", level=" + level + ", time="
				+ time + "]";
	}
}
import kr.tpc.MovieVO;

public class TPC18 {
	public static void main(String[] args) {
		// 2. 영화 데이터 저장(이질적인(서로다른)데이터 저장).
		MovieVO mv = new MovieVO("수학의 정석", 15000, "홍길동", 15, 1.3f);
		System.out.println(mv);
		
		// 영화 3편 저장
		MovieVO[] marr = new MovieVO[3];
		marr[0] = new MovieVO("과학의 정석1", 10000, "교수1", 12, 1.6f);
		marr[1] = new MovieVO("과학의 정석2", 15000, "교수2", 15, 1.1f);
		marr[2] = new MovieVO("과학의 정석3", 30000, "교수3", 5, 1.2f);
		
		System.out.println(marr[0].toString());
		System.out.println(marr[1]);
		System.out.println(marr[2]);
		
		for(int i = 0; i < marr.length; i++) {
			System.out.println(marr[i]);
		}
	}
}
반응형

+ Recent posts