반응형

# 크기에 상관없이 객체를 저장(List)

## ArrayList

  • ArrayList 는 Java util에 이미 만들어져 있는 API
  • ArrayList 이용 책(BookDTO) 3권을 저장하고 출력하기.
List list = new ArrayList();

// add 동작 (UpCasting)
list.add(new BookDTO("갓바1", 20000, "가출판사", 300));
list.add(new BookDTO("갓바2", 25000, "나출판사", 600));
list.add(new BookDTO("갓바3", 30000, "다출판사", 400));

// get 동작 (DownCasting)
BookDTO a = (BookDTO)list.get(0);
BookDTO a = (BookDTO)list.get(1);
BookDTO a = (BookDTO)list.get(2);

## ArrayList (실습)

import java.util.ArrayList;
import java.util.List;

import kr.tpc.BookDTO;

public class TPC38 {
	public static void main(String[] args) {
		
		// ArrayList list = new ArrayList(); 
		// 아래와 같이 ArrayList 의 부모 타입인 list로 받을 수 있음.
		List<BookDTO> list = new ArrayList(1);	// <> : 버킷, 제네릭 사용하여 사용가능한 타입 제한. Object[] -> BookDTO[]
		list.add(new BookDTO("갓바책1", 35000, "가출판사", 200));
		list.add(new BookDTO("갓바책2", 5000, "나출판사", 400));
		list.add(new BookDTO("갓바책3", 15000, "다출판사", 250));
		
		for (int i = 0; i < list.size(); i++) {
			// Object 배열인 경우.
			//Object o = list.get(i);
			//BookDTO book = (BookDTO)o;
			
			// 제네릭 사용한 경우 <BookDTO>
			BookDTO book = list.get(i);
			System.out.println(book.title + "\t" + book.price + "\t" + book.company + "\t" + book.page);
		}
		
	}
}

 

# Wrapper 클래스

  • 기본자료형(클래스 아님)을 객체 자료형으로 사용할 수 있도록 만들어 놓은 자료형 (=포장 클래스)
기본자료형 객체자료형 사용 예
int Integer 1, new Integer(1)
float Float 23.4f, new Float(23.4f)
char Character 'B', new Character('B')
boolean Boolean true, new Boolean(true)
  • 변수에 1을 저장하는 방법은 아래와 같이 2가지 존재.
방법1.
int a = 1;

방법2.
Integer b = new Integer(1);
int v = b.intValue();	// intValue() or toString() or parseInt() 등 포장을 벗기는 함수 존재.
  • 기본자료형을 Object에 저장할 경우?
Object[] obj = new Object[3];

obj[0] = 1;
obj[1] = 2;
obj[2] = 3;
=> 틀린표현 이지만, 컴파일러가 자동으로 Boxing 하여 에러 발생 하지않고 사용 가능.


obj[0] = new Integer(1);
obj[1] = new Integer(2);
obj[2] = new Integer(3);
=> 맞는 표현. (정석)
  • Boxing / Unboxing : 컴파일러가 자동으로 해준다.
// Boxing
Integer a = 1;
=> 위 표현식에서 1을 컴파일러가 자동으로 new Integer(1); 로 포장해줌 (boxing)


// Unboxing
int b = new Integer(10);

## Wrapper 클래스 (실습)

public class TPC39 {
	public static void main(String[] args) {
		
		int a = 1;
		
		// Integer : java.lang 에 존재하는 API
		Integer b = new Integer(1);		// 정석 표현.
		// Integer b = 1;	// boxing -> 컴파일러가 1을 내부적으로 boxing.
		
		System.out.println(b.intValue());	// 정수형태 1
		System.out.println(b.toString());	// 문자열형태 "1"
		
		Object[] obj = new Object[3];
		/*
		obj[0] = new Integer(1);	// 정석 표현.
		obj[1] = new Integer(2);
		obj[2] = new Integer(3);
		*/
		obj[0] = 1;	// boxing 
		obj[1] = 2;
		obj[2] = 3;
		
		System.out.println(obj[0].toString());
		System.out.println(obj[1].toString());
		System.out.println(obj[2].toString());
	
		// 문제.
		// "100" + "100" = 200 -> 문자열 합산.
		String x = "100";
		String y = "100";
		System.out.println(x + y);	// "100100"
		
		int value1 = Integer.parseInt(x);
		int value2 = Integer.parseInt(y);
		System.out.println(value1 + value2);	// 200
		
		// 100 + 100 = "200"
		String k1 = String.valueOf(value1);
		String k2 = String.valueOf(value2);
		System.out.println(k1 + k2);		// "100100"
		
	}
}
반응형
반응형

# 문자열

## String 클래스

  • 자바에서 문자열은 쌍따옴표(" ")로 감싸면 된다.
  • 자바에서 문자열을 저장하는 기본 자료형(Data Type)은 없다.
  • 문자열은 여러가지 조작을 할 수 있기 때문에 별도의 클래스로 자료형(java.lang.String)을 만들어 두었다. 그래서 자바에서 문자열은 객체로 취급된다.

## 문자열 생성방법

1. new 를 이용하여 생성.

  • new로 객체를 생성하면 Heap Area에 생성 됨.
String str1 = new String("갓바의정석");

String str2 = new String("햄버거");
  • Heap Area : 객체가 생성되는 메모리 영역.
  • 위에서 str1 와 생성된 객체 String("갓바의정석"), str2 와 생성된 객체 String("햄버거") 는 서로 다른 번지를 가르킨다. 

2. 문자열 상수로 생성

String str3 = "버거킹";

String str4 = "피자나라치킨공주";
  • Literal Pool : 문자열 상수(객체)가 생성되는 메모리 영역(재활용 가능!!)
  • str3 와 "버거킹", str4 와 "피자나라치킨공주"는 서로 같은 번지를 가르킨다.

## String 클래스 (실습)

public class TPC35 {
	public static void main(String[] args) {
		// 문자열 객체 생성
		// 1. new 이용
		String str1 = new String("갓바의정석");
		String str2 = new String("갓바의정석");
		
		// new 할 경우 heap area에 새롭게 객체가 생성되어 번지가 다름.
		if(str1==str2) {
			System.out.println("같음.");
		} else {
			System.out.println("다름.");
		}
		
		// 문자열 비교를 위해서는 equals를 활용!!
		if(str1.equals(str2)) {
			System.out.println("같아용.");
		} else {
			System.out.println("달라용.");
		}
		
		// 2. 문자열 상수 이용
		String str3 = "햄버거";
		String str4 = "햄버거";
		
		// 문자열 상수를 이용할 경우 Literal Area에 생성 동일한 번지를 가리킴.
		if(str3==str4) {
			System.out.println("같음.");
		} else {
			System.out.println("다름.");
		}
		
		// 문자열은 equals로 비교!
		if(str3.equals(str4)) {
			System.out.println("같아용.");
		} else {
			System.out.println("달라용.");
		}

	}
}

 

# API 생성하기

## 배열처럼 동작하는 클래스 만들기 (IntArray) (실습)

  • 아래의 경우 배열의 기본 동작을 모두 이해해야 활용 가능.
public class TPC36 {
	public static void main(String[] args) {
		// 배열 기본 동작 이해
		// 1. 배열 생성 동작.
		int[] a = new int[3];
		
		// 2. 추가 동작.
		a[0] = 10;
		a[1] = 20;
		a[2] = 30;
		
		// 3. 얻는 동작
		int temp = a[0];
		
		// 4. 배열 크기
		int len = a.length;
		
		for (int i =0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}
}
  • 클래스(API) 생성.
package kr.inflearn;

public class IntArray {
	private int count;
	private int[] arr;
	
	public IntArray() {
		this(10);
	}
	
	public IntArray(int init) {
		arr = new int[init];
	}
	
	public void add(int data) {
		arr[count++] = data;
	}
	
	public int get(int index) {
		return arr[index];
	}
	
	public int size() {
		return count;
	}
}
import kr.inflearn.IntArray;

public class TPC36 {
	public static void main(String[] args) {
		/*
		 * 배열 기본 동작 이해.
		 * */
		// 1. 배열 생성 동작.
		int[] a = new int[3];
		
		// 2. 추가 동작.
		a[0] = 10;
		a[1] = 20;
		a[2] = 30;
		
		// 3. 얻는 동작
		int temp = a[0];
		
		// 4. 배열 크기
		int len = a.length;
		
		for (int i =0; i < a.length; i++) {
			System.out.println(a[i]);
		}
		
		/*
		 * IntArray API 사용.
		 * */
		IntArray arr = new IntArray(5);
		arr.add(10);
		arr.add(20);
		arr.add(30);
		
		for (int i = 0; i < arr.size(); i++) {
			System.out.println(arr.get(i));
		}
	}
}

 

# ArrayList 흉내내기 (Object[])

## 배열처럼 동작하는 클래스 만들기 (ObjectArray)

  • 아래와 같이 직접 ObjectArray를 만들면 고정길이 배열로만 생성가능. -> 자바에서 제공해주는 API (ArrayList)와 비교하면 10%밖에 사용 못함.
public class ObjectArray {
	private int count;
	private Object[] arr;
	
	public ObjectArray() {
		this(10);
	}
	
	public ObjectArray(int init) {
		arr = new Object[init];
	}
	
	public void add(Object data) {
		arr[count++] = data;
	}
	
	public Object get(int index) {
		return arr[index];
	}
	
	public int size() {
		return count;
	}
}
  • 자바에서 제공해주는 API (ArrayList) -> 위에서 직접 만든것에 비해 100% 기능 제공. (길이 제한 없음)
import java.util.ArrayList;

import kr.inflearn.ObjectArray;
import kr.tpc.A;
import kr.tpc.B;

public class TPC37 {
	public static void main(String[] args) {
		System.out.println("============ 직접만든 ObjectArray ===========");
		// 1. 직접 만든 ObjectArray 클래스(API)
		// 단점 : 고정길이 배열이므로, 추가 생성은 불가능..
		ObjectArray arr1 = new ObjectArray(5);
		arr1.add(new A());
		arr1.add(new B());
		arr1.add(new A());
		arr1.add(new B());
		
		for (int i = 0; i < arr1.size(); i++) {
			Object ob = arr1.get(i);
			
			if (ob instanceof A) {
				((A)ob).go();
			} else {
				((B)ob).go();
			}
		}
		
		System.out.println("============ Java ArrayList ===========");
		// 2. 자바에서 제공해주는 ArrayList 
		// 장점 : 배열 길이에 제약이 없음.
		ArrayList arr2 = new ArrayList();
		arr2.add(new A());
		arr2.add(new B());
		arr2.add(new A());
		arr2.add(new B());
		arr2.add(new A());
		arr2.add(new B());
		arr2.add(new A());
		
		for (int i = 0; i < arr2.size(); i++) {
			Object ob = arr2.get(i);
			
			if (ob instanceof A) {
				((A)ob).go();
			} else {
				((B)ob).go();
			}
		}
	}
}

 

반응형
반응형

# 패키지 (package)

  • 기능이 비슷한 클래스를 모아서 관리하기 쉽게 하기 위해 묶은 것. (package 외부에서 접근하는 것을 막을 때도 사용하긴 하지만 이런식으로 자주 사용하지 않음)

## package 외부에서 접근하는 방법

  • src > TPC31 (class) 생성. / src > kr (package) > tpc (package) > MyClass 생성. 했을 때, TPC31에서 MyClass를 접근하기 위해서는 먼저 아래의 사항을 알아야 한다.
1. class의 full name을 알아야 한다. (kr.tpc.MyClass)
	클래스 명은 아래와 같이 2가지 이다. (예 : 위에서 생성한 MyClass)
	- 기본 이름 : MyClass
	- 패키지를 포함한 이름 (class full name) : kr.tpc.MyClass

2. 접근 권한을 알아야 한다. (public)
	- package 내부에 있는 클래스의 접근권한이 생략된 경우 기본적으로 default 권한을 갖는다.
	(접근 권한을 생략했다고 해서 public 접근권한이 아님)
	- default 접근권한 : package 내부에 있는 클래스에게는 public / 외부에 있는 클래스에게는 private 접근권한.
    
3. import 구문을 이해해야 한다.

 

## package (실습)

package kr.inflearn;

public class MyClass {	// public 생략 시 -> default 접근권한.
	public int sum(int a, int b) {
		int result = 0;
		
		for (int i = a; i <= b; i++) {
			result += i;
		}
		
		return result;
	}
}
import kr.inflearn.MyClass;

public class TPC33 {
	public static void main(String[] args) {
		
		// 방법1. class full name 으로 접근. -> 이 경우 상단에 별도로 import 하지 않아도 된다.
		// 	kr.inflearn.MyClass my = new kr.inflearn.MyClass();
		
		// 방법2. 이 경우 import 필요.
		MyClass my = new MyClass();
		int result = my.sum(1, 10);
		
		System.out.println(result);
				
	}
}

 

# 자바에서 제공하는 API 접근 및 활용

## Java API 접근하기 (Java API : 2단계 package 로 구성 됨)

  • API는 여러개의 클래스 파일을 묶어 놓는 것으로, 대부분 패키지로 되어있다.
  • 자바에서 기본적으로 제공해주는 API의 경우 jrt-fs.jar 처럼 .jar 파일로 묶여 배포가 된다. 해당 파일의 구조를 보면 2단계 구조로 java 밑에 lang, util, io, sql, net 등이 존재함.

## Java API 중 String 클래스를 접근하는 방법

  • String 클래스의 이름은 2가지이다.
1. 기본 이름 : String

2. 패키지를 포함한 이름 (class full name) : java.lang.String
  • java.lang 패키지는 디폴트 패키지로 클래스를 만들면 자동으로 import 된다. 
import java.lang.*;

## Java API 접근하기 (실습)

// import java.lang.*; 생략되어 있음.

public class TPC34 {
	public static void main(String[] args) {
		// String
		// java.lang.String str = new java.lang.String("APPLE");
		
		String str = new String("APPLE");
		String temp = str.toLowerCase();
		System.out.println(temp);	// apple
		System.out.println(str.charAt(3));	// L
		System.out.println(str.length());	// 5
		System.out.println(str.indexOf("PL"));	// 2
		System.out.println(str.indexOf("PX"));	// 실패 -1 반환.
		System.out.println(str.replaceAll("P", "X"));	// AXXLE
	}
}
반응형
반응형

# 객체지향 프로그래밍의 3대 특징

  • 정보은닉 (Information Hiding) : vo, dto 설계 시 정보은닉하여 상태정보 설계
  • 상속 (Inheritance) : 다형성 기법을 사용하기 위해 필연적으로 필요. 
  • 다형성 (polymorphism)

# message polymorphism (다형성)

  • 상속관계에 있는 클래스에서 상위클래스가 동일한 메시지로 하위클래스들을 서로 다르게 동작시키는 객체지향 원리.

# 다형성 이론의 전제조건

  • 상속관계가 되어야 함.
  • 객체생성을 UpCasting으로 할 것 (상위클래스가 하위 클래스에게 메시지를 보내야 하므로)
  • UpCasting이 되면 DownCasting을 할 수 있다.
  • 하위클래스가 반드시 재정의(Override)해야 함. (다형성이 보장되기 위함)
  • 동적 바인딩을 통해 실현된다. (동적 바인딩이란 실행시점에서 사용될 메서드가 결정되는 바인딩으로, 프로그램의 속도를 떨어뜨리는 원인이 된다.)

# 추상 클래스와 인터페이스의 공통점

  • 다형성을 보장하기 위해 등장
  • 객체를 생성할 수 없다. (new 불가)
  • 하위 클래스에 의해 구현되어야 한다. (Override : 재정의 필수)
  • 부모(상위 클래스)의 역할로 사용 함. (UpCasting으로 객체를 생성)
  • 추상 메서드를 갖는다.

 

반응형

+ Recent posts