[JAVA] 교육 3일차

티스토리 뷰

프로그래밍 언어/JAVA

[JAVA] 교육 3일차

miiingo 2018. 1. 4. 17:42

강사 : 김호진 강사님

생성자

메소드 오버로딩(중복정의) : 매개변수의 개수나 타입이 다를 경우, 메소드 이름의 중복 정의가 가능
메소드 오버라이딩(재정의) : 원래 있던 메소드의 내용을 다시 정의(상속에서 등장. 이전의 내용으로 돌아갈 수 없음)

생성자도 메소드 오버로딩이 가능함

생성자 내부에서 다른 생성자를 호출할 수 있다. 단, 생성자 내부에서 가장 먼저 실행되어야 한다.

생성자 내에서 동일한 이름의 생성자를 부를 때에는 생성자 이름이 아닌 'this'라는 키워드로 대체해서 사용

this : 가장 가까운 클래스의 이름으로 치환

클래스가 컴파일되는 과정에서 사용자 정의 생성자가 존재하지 않을 경우에는 자동으로 생성자를 삽입(디폴트 생성자)

디폴트 생성자의 접근제어 지시자는 해당 클래스의 접근제어 지시자를 따름

접근제어 지시자와 정보은닉, 그리고 캡슐화

접근제어 지시자

정보를 제한하기 위해 사용

지시자	클래스 내부	동일 패키지	상속받은 클래스	이외의 영역
private	O	X	X	X
default	O	O	X	X
protected	O	O	O	X
public	O	O	O	O

※ public > protected > default > private

※ default와 protected를 헷갈리지 말자!

정보은닉(Information Hideing)

어떤 클래스를 public으로 선언해야 할까?

하나의 java 파일에 여러 개의 클래스를 선언할 경우 이 중에 하나만 public으로 설정하고, 파일명과 동일한 이름의 클래스명으로 선언해야 한다.

캡슐화(Encapsulation)

같은 업무를 수행하는 것들을 하나로 합침

객체지향과의 균형을 맞추는 것이 중요

프로그래밍 시 주의사항

외부에서 인스턴스 생성을 할 때 생성자의 접근제어 지시자도 확인을 해줘야함
클래스 내에서는 변수 대입이 불가능('{}(초기화 블럭, Initialized Block)'로 묶어주면 가능)
우선 순위가 높다는 것은 가장 나중에 실행된다는 얘기(그래야 변경한 내용이 적용되니까)
모든 클래스는 'Object'라는 이름의 클래스를 상속받음(Object는 'java.lang' 패키지에 속해있음. 모든 클래스의 조상 클래스)
자바는 다중 상속을 허용하지 않음(단일 상속만 허용!)
인터페이스가 인터페이스를 상속받을 때에는 다중 상속이 허용됨

실습

Test05: 생성자(Constructor)

/*========================================
 * ■■■  생성자(Constructor)  ■■■ 
 * 
 ========================================*/

package com.test;

public class Test05
{

	int x;
	
	// 생성자
	//-- 생성자의 이름은 항상 클래스의 이름과 동일해야 하며
	//   필요한 경우 인수를 받아들이거나 중복정의가 가능하지만
	//   리턴 값을 가질 수 없다.
	//   생성자는 일반 다른 메소드들처럼 호출될 수 없고
	//   new 연산자를 이용하여 객체를 생성하기 위해 호출되며,
	//   각 클래스의 인스턴스인 객체를 생성한 후에
	//   생성된 객체의 멤버를 초기화시키는 작업을 수행한다.
	Test05()
	{
		// 생성자 내부에서 다른 생성자를 호출할 수 있다.
		// 단, 생성자 내부에서 가장 먼저 실행되어야 한다.
		this(20);
		
		System.out.println("인자가 없는 생성자...");
		x = 10;
		
		//this(20);
		
		System.out.println("x : " + x);
		
		//this(20);
	}
	
	Test05(int x)
	{
		System.out.println("인자가 하나인 생성자...");
		this.x = x;
	}
	
	public static void main(String[] args)
	{
		Test05 ob1 = new Test05();
		System.out.println("ob1.x : " + ob1.x);
		
		Test05 ob2 = new Test05(100);
		System.out.println("ob2.x : " + ob2.x);
	}
}

Test06: default 생성자

package com.test;

public class Test06
{
	public static void main(String[] args)
	{
		Temp06 ob = new Temp06();
		
		ob.print();
	}
}


class Temp06
{
	// 사용자 정의 생성자가 정의되어 있지 않을 때
	// 자동으로 (기본으로) 삽입되는 default 생성자
	Temp06()	// 매개변수 없음
	{
		// 텅 비어있음
	}
	
	int x = 10;
	int y = 20;
	
	void print()
	{
		System.out.println("x : " + x);
		System.out.println("y : " + y);
	}
}

Test07: 클래스와 인스턴스 - 생성자와 초기화 블럭

/*==========================================================
 * ■■■  클래스와 인스턴스  ■■■ 
 * - 생성자(Constructor)와 초기화 블럭(Initialized Block)
 ==========================================================*/

package com.test;

public class Test07
{
	int n;
	int m;
	
	// 초기화 블럭(ini...)
	{
		n = 7;
		m = 10;
		System.out.println("초기화 블럭");
	}
	
	// 생성자
	Test07(int n, int m)
	{
		this.n = n;
		this.m = m;
		System.out.println("인자 있는 생성자");
	}
	
	Test07()
	{
		System.out.println("인자 없는 생성자");
	}
	
	void write()
	{
		System.out.printf("n : %d, m : %d\n" , n, m);
	}
	
	public static void main(String[] args)
	{
		Test07 ob1 = new Test07();

		Test07 ob2 = new Test07(10, 100);
		ob2.write();
	}
}

Test08: 클래스 고급 - 상속

/*=================================
 * ■■■  클래스 고급  ■■■ 
 * - 상속(Inheritance)
 ==================================*/

/*
 ○ 상속의 개요

    클래스를 재사용할 수 있도록 파생시키는 방법.
    ※ 파생의 사전적 의미 : 사물이 어떤 근원으로부터 갈려 나와 생김.
                            단, 우리는 상속을 코드의 재사용(재활용)의 관점으로만
                            이해하려 하지 말자.
                            
 ○ 상속의 특징
 
     - 상속은 자식 클래스가 부모 클래스를 선택하는 과정이다.
     - 부모 클래스는 누가 자신을 부모로 지정했는지 알 수가 없다.
     - 상속을 지정하면 부모 클래스의 멤버를 자식 클래스가 상속받음으로
       공유(public, protected 멤버)하게 된다.
     - 자식 클래스는 부모 클래스의 멤버와 무관하게 자기만의 멤버를 추가할 수 있다.
     - 자식 클래스에서 부모 클래스의 멤버를 재정의(오버라이딩 : Overriding)할 수 있다.
     - 『extends 상위클래스명』 표기를 클래스 설계할 때 추가하면 된다.
     - 자바의 모든 클래스는 Object 클래스를 자동 상속받도록 되어 있다.
     - 부모 클래스는 자기 자신 또는 자기의 멤버를 부모로 지정하지 못하도록
       막을 수 있다. (final 키워드)
     - 생성자와 초기화 블럭은 상속 대상에서 제외된다. 
     
     
 ○ 형식 및 구조
 
    public class 클래스명 extends 상위클래스명
    {
    	// 상위 클래스의 멤버들을 하위 클래스가 공유하게 된다.
    	// 또한 자기만의 고유한 멤버들을 추가할 수 있다.
    }
 */

package com.test;

public class Test08
{
	public static void main(String[] args)
	{
		Test08 ob = new Test08();
		
		System.out.println(ob.toString());
		
		// ※ main() 메소드를 제외하고 아무런 멤버가 없는 상태의
		//    클래스를 설계한 상태이다.
		//    하지만, 기본 멤버가 이미 존재하는 상태이다.
		//    (Object 클래스가 가지고 있는 멤버)
		//    모~~~~~든 클래스는 Object 클래스를 자동으로 상속받게 된다.
		//    즉, Object 클래스의 멤버를 하위 클래스에서
		//    사용하는 것이 가능하다는 의미이다.
		
	}
}

Test09: 클래스 고급 - 상속

/*=================================
 * ■■■  클래스 고급  ■■■ 
 * - 상속(Inheritance)
 ==================================*/

/*
※ Override : 상위 클래스에 정의된 메소드를 재정의(다형성 문법의 토대)
   - 메소드의 원형, 이름, 인자의 갯수 및 자료형이 모두 동일해야 한다.
   - 접근제어 지시자는 클 수는 있어도 작을 수는 없다.
   - 인자의 갯수나 자료형이 다른 경우가 되어버리면
     Overloading이 된다.
   
『@Override』 : annotation(JDK1.5) → 프로그램의 metadata
컴파일러나 외부 틀에서 프로그램에 대한 부가적인 설명을 제공하기 위해
사용되며 다른 주석은 컴파일 과정에서 제거되지만
어노테이션은 제거되지 않는다.
(오버라이드를 했다는 표시)
 */

package com.test;

// 부모클래스, 상위클래스, 슈퍼클래스
class SuperTest09
{
	private int a=5;
	protected int b=10;
	public int c=20;
	
	public void write()
	{
		System.out.println("Super write() 메소드 : "+ a + ", " + b + ", " + c);
	}
}

// 자식클래스, 하위클래스, 서브클래스
class SubTest09 extends SuperTest09
{
	/*
	protected int b=10;
	public int c=20;
	
	public void write()
	{
		System.out.println("Super write() 메소드 : "+ a + ", " + b + ", " + c);
	}
	*/
	
	int b=100;
	
//	public void write()
//	{
//		System.out.println("Super write() 메소드 : "+ a + ", " + b + ", " + c);
//	}
	
	@Override
	public void write()
	{
		System.out.println("재정의된 메소드");
		
		// a는 private이기 때문에 상속받지 못함(사용 불가능)
		// b는 SubTest에서 재정의한 변수로 적용
		System.out.println("SubTest write() 메소드 : " + b + ", " + c);
	}
	
	public void print()
	{
		System.out.println("Sub print() 메소드 : ");
	}
}

// main() 메소드를 포함하는 외부 클래스
public class Test09
{
	public static void main(String[] args)
	{
		SubTest09 ob = new SubTest09();
		
		ob.write();
		ob.print();
	}
}

Test10: 추상 클래스(abstract)

/*========================================
 * ■■■  추상 클래스(abstract)  ■■■ 
 =========================================*/

/*
○ 추상 클래스(abstract) 개요

   - 메모리의 낭비 없이
     메소드를 재정의해서 사용하도록 설계된 클래스.
     
   - 클래스 내부에 추상 메소드가 존재하면
     이 클래스는 추상 클래스가 되며
     반드시 class 앞에 『abstract』를 명시해야 한다.
     
   - 추상 클래스는 추상 메소드를 포함할 수 있으나
     반드시 포함해야 하는 것은 아니며,
     이 경우에도 『abstract』 키워드를 포함한 클래스는
     추상 클래스로 간주한다.
  
  - 『abstract』 키워드는 클래스와 메소드에서만 사용할 수 있으며
    멤버 변수에서는 사용할 수 없다.
  
  - 『abstract』 키워드는 『final』, 『static』과 함께 사용할 수 없다.
  
  - 추상 클래스는 객체를 생성할 수 없다.
  
  - 추상 클래스를 상속받은 하위(자식) 클래스는
    추상 클래스가 가지고 있는 추상 메소드를 오버라이딩(Overriding) 해야 하며,
    이 의무를 다하지 않을 경우
    그 클래스마저 추상 클래스가 된다.
    
*/

package com.test;

// 추상 클래스
abstract class AbstractTest10
{
	// int 배열 변수 선언 → private화 → 정보 은닉
	private int[] value;
	
	// 매개변수로 넘겨받은 int 배열로 멤버를 초기화 한 후
	// 정렬 구현 메소드를 호출하는 기능을 가진 메소드
	public void sort(int[] value)
	{
		this.value = value;
		sorting();
	}
	
	// 정렬을 구현하는 기능을 가진 메소드
	// -- 정의하지 않고... 필요하다는 사실로 인해 선언만 해둔 상태.
	// -- 즉, 추상 메소드~!!!
	protected abstract void sorting();
	
	// 배열의 길이를 확인하는 기능을 가진 메소드
	protected int length()
	{
		if(value == null)
		{
			return 0;
		}
		return value.length;
	}
	
	// 크기를 비교하는 기능을 가진 메소드
	protected int compare(int i, int j)
	{
		if(value[i] == value[j])
		{
			return 0;
		}
		else if(value[i] > value[j])
		{
			return 1;
		}
		else
		{
			return -1;
		}
	}
	
	// 자리 바꿈 기능을 가진 메소드
	protected void swap(int i, int j)
	{
		int temp;
		temp = value[i];
		value[i] = value[j];
		value[j] = temp;
	}
	
	// 결과 출력을 위해 만들어놓은 출력 기능을 가진 메소드
	public void print()
	{
		if(value == null)
		{
			return;
		}
		
		for(int n: value)
		{
			System.out.printf("%5d", n);
		}
		System.out.println();
	}
}

// ① 추상 클래스를 상속받은 추상 클래스...
// ② 추상 클래스가 소유하고 있는 추상 메소드(sorting())를
//    재정의함으로써 일반 클래스의 형태로 변화
//abstract class SortTest10 extends AbstractTest10
class SortTest10 extends AbstractTest10
{	
	// 이 추상 클래스가...(SortTest10)
	// 추상 클래스라는 꼬리표를 떼기 위해서는...
	// 『sorting()』 메소드를 → 추상 메소드... 를 오버라이딩(Overriding) 해서
	// 완성된 형태로 기능하는 메소드로 구성해야 한다.
	@Override
	protected void sorting()
	{
		// 선택 정렬(Selection Sort)
		for(int i=0 ; i<length()-1 ; i++)		//-- 비교 기준 값
		{
			for(int j=i ; j<length(); j++)	//-- 비교 대상 값
			{
				// 비교
				if(compare(i, j) == 1)		//-- 앞의 수가 뒤의 수보다 크면...
				{
					// 자리 바꿈
					swap(i, j);
				}
			}
		}
	}
}

public class Test10
{
	public static void main(String[] args)
	{
		int[] data = {50, 42, 51, 12, 47};
		
		SortTest10 ob = new SortTest10();
		
		//AbstractTest10 ob2 = new AbstractTest10();
		//-- 하위클래스에서 추상 메소드에 대한 재정의를 마쳤다고 해서
		//   추상클래스였던 상위 클래스가 일반클래스로써의 지위를 갖게 되는 것은 아니다.
		
		ob.sort(data);
		ob.print();
	}
}

Test11: 클래스 고급 - 인터페이스

/*===============================
 * ■■■  클래스 고급  ■■■
 * - 인터페이스(Interface) 
 ==============================*/

/*
○ 인터페이스(Interface) 개요

    - 인터페이스란 완전히 미완성된 채로 남겨진 즉, 인터페이스 안에 존재하는 어떤 메소드도
      몸체(body)가 존재하지 않아 실행 부분이 없다.
      
    - 클래스를 위한 템플릿으로써의 역할을 수행하는 추상 클래스의 일종이라 볼 수 있지만...
      추상화 정도가 심하다.
      
    - 인터페이스를 구현하기 위해서는 『implements』 키워드를 사용한다.
    
    - 하나 이상의 인터페이스를 『implements』 할 수 있다.
    
    - 인터페이스를 『implements』한 클래스는 인터페이스 안에 있는
      모든 메소드들(추상 메소드)을 Override 해야 한다.
      
    - 인터페이스가 다른 인터페이스를 상속받을 수 있으며
      이 때, 클래스와 마찬가지로 『extends』 키워드를 사용한다.
      
    - 클래스와는 달리 인터페이스는 다중 상속을 허용한다.
      (기존의 C++ 언어 등에서 지원되는 다중 상속이 많은 문제점을 지니기 때문에
       자바에서는 다중 상속의 개념을 사용하지 않았지만 인터페이스라는 개념으로 변형하여
       인터페이스를 통해 다중 상속을 구현하는 방법을 지원하게 된 것이다.)
       
    - 인터페이스는 상수(상수화된 변수 포함)와 추상 메소드만 가질 수 있으며
      인터페이스 안의 메소드들은 접근제어 지시자를 명시하지 않아도
      public으로 설정되어 클래스에서 implements 함으로써 바로 접근이 가능하도록 지원한다.
      
※ 인터페이스에서 『@Override』는 JDK1.6부터 제공

 */

package com.test;

interface Fruit11
{
	String WON = "원";	// public static final String WON = "원";
	int getPrice();		// public abstract int gerPrice();
	public String getName();	// public abstract String getName();
}

abstract class Fruit11Impl implements Fruit11
{
	@Override
	int getPrice()
	{
		// 시간상 구현 생략
	}
	
	@Override
	String getName()
	{
		// 시간상 구현 생략
	}
}

public class Test11
{
	
}

저작자표시 비영리 동일조건

'프로그래밍 언어 > JAVA' 카테고리의 다른 글

[JAVA] 교육 3일차 과제 - Work04: 정렬 (0)	2018.01.04
[JAVA] 교육 3일차 과제 - Work03: 2의 배수? 3의 배수? (0)	2018.01.04
[JAVA] 교육 2일차 과제 - Work02: 무슨 요일? (0)	2018.01.04
[JAVA] 교육 2일차 과제 - Work01: 윤년? 평년? (0)	2018.01.04
[JAVA] 교육 2일차 (0)	2018.01.04

공지사항

최근에 올라온 글

최근에 달린 댓글

Total

Today

Yesterday

링크

TAG more

« 2024/05 »
일	월	화	수	목	금	토
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

글 보관함

miiingo riiingo

티스토리 뷰