[자바] 8일차 - 클래스 상속, 오버라이딩, super VS this, 추상클래스, 비정형인자, 래퍼클래스, final 키워드

8일차

 

클래스 상속
     - 클래스간의 멤버 상속(부모의 모든 멤버를 자식이 사용가능)
     - 멤버를 상속하는 클래스 : 부모클래스, 슈퍼클래스, 기본클래스
     - 멤버를 상속받는 클래스 : 자식클래스, 서브클래스, 파생클래스
     - 상속(Inheritance), 파생(Derive), 확장(Extend)
 
         1. 부모의 public멤버는 자식의 public멤버
         2. 부모의 protected멤버는 자식의 protected멤버
         3. 부모의 private멤버는 자식에서도 접근 불가!!

 

public class Ex81_Inheriance 
{
	public static void main(String[] args)
	{
		//Ex81_Inheriance.java
		Parent p = new Parent();
		p.a = 10;
		//p.b = 20;
		p.checkData();

		Child c = new Child();
		c.a = 30;
		//c.b = 40;
		c.checkData();
		//c.checkC();
		c.d = 100;
	}

}

//부모클래스
class Parent
{
	public int a;
	private int b;

	//외부(패키지)에서 접근불가(private), 상속된 자식에게만 접근 허용
	protected int d;

	public void checkData() {
		System.out.println(a + ", " + b);
	}
}

//자식클래스
class Child extends Parent	//상속
{
	//멤버 선언
	public int c;

	public void checkC() 
	{
		//System.out.println(a+","+b+","+c);
		//this.		: child의 멤버와 부모의 private이 아닌 멤버에 접근 가능
		//super.	: parent의 멤버에만 접근 가능
	}
}

 

*** 해시코드
객체를 구별하기위한 식별 코드 : 객체 식별자

 

메서드 오버라이딩, Method Overriding

 

public class Ex82_Overriding 
{
	public static void main(String[] args)
	{
		//Ex82_Overriding.java
		//재정의 (메서드에 한함)
		//상속관계에서 부모의 메서드명과 자식의 메서드명이 일치할 떄 발생

		Printer p = new Printer("P100","홍길동");
		p.checkInfo();
		p.print();

		HP640 hp = new HP640();
		hp.print();	//***

		HP640 hp1 = new HP640();
		hp1.setInfo("P200","강감찬");
		hp1.checkInfo();

	}//end main
}


class Printer
{
	private String model;	//모델명
	private String owner;	//소유자

	public Printer() {
		this.model="";
		this.owner="";
	}

	public Printer(String model, String owner) {
		setInfo(model,owner);
	}

	public void setInfo(String model, String owner) {
		this.model=model;
		this.owner=owner;
	}

	public void checkInfo() {
		System.out.printf("모델 : %s. 소유주 : %s%n",this.model,this.owner);
	}

	public void print() {
		System.out.println("Print클래스가 출력중..");
	}
}

class HP640 extends Printer
{
	private String color = "빨강";

	public void print() {
		System.out.println("HP640의 컬러 출력중..");
		System.out.printf("color는 %s입니다.%n",color);
	}
}
////////////////////////////////////////////////////////////////////////////////////////
class Ex83_Overriding 
{
	public static void main(String[] args)
	{
		//Ex83_Overriding.java
		Test t = new Test();
		System.out.println(t.toString());//자료형@해시코드

		Test t2 = new Test(100);
		System.out.println(t2.getN());
		System.out.println(t2.toString());
		System.out.println(t2);		//t2.toString을 호출함

		int n = 200;
		String str = Integer.toString(n);	//n+"";
	}//end main
}//end Ex83

class Test
{
	private int n;

	public Test() {
		this.n = 0;
	}

	public Test(int n) {
		this.n = n;
	}

	public void setN(int n) {
		this.n = n;
	}

	public int getN() {
		return n;
	}

	//Object클래스의 toString() 재정의
	public String toString() {
		//현재 객체가 소유하고 있는 데이터를 반환
		//숫자(int) -> 문자열(String)
//		return this.n+"";
		return this.n+"";
	}
}
///////////////////////////////////////////////////////////////////////////////////////////
import java.util.*;

public class Ex84_Overriding_Random
{
	public static void main(String[] args)
	{
		//Ex84_Overriding_Random.java
		//임의의 난수를 발생시켜라!!
		//조건] 5~10사이의 정수

		Random rnd = new Random();

		for(int i=0; i<10; i++) {
			System.out.println(rnd.nextInt(6)+5);	//0~5
		}

		MyRandom rnd2 = new MyRandom();

		for(int i=0; i<10; i++) {
			System.out.println(rnd2.nextUser());	//훨씬 편하다
		}

	}//end main
}

// 난수생성기
// Random -> 5~10 난수 발생 기능 X
class MyRandom extends Random
{
	public int nextUser() {
		Random rnd = new Random();
		return rnd.nextInt(6) + 5;	//5~10
	}
}

 

super VS this

 

public class Ex85_Inheritance_super 
{
	public static void main(String[] args)
	{
		//Ex85_Inheritance_super.java
		Child c1 = new Child();
		c1.test();
		System.out.println(c1.b);
		c1.check();
		c1.check2();

		Child c2 = new Child();
	}
}

class Parent 
{
	public int parentA=10;
	public int b=20;

	public void check() {
		System.out.println(this.parentA + " : " + this.b);
	}
	
	public void test() {
		System.out.println("부모클래스");
	}
}

class Child extends Parent
{
	public int childC = 30;
	public int b = 40;	// 이렇게 변수 재정의는 하지 않는게 원칙이다.

	public void check2() {
		System.out.println(this.childC + " : " + this.b + ", " + super.b);
		super.test();
		this.test();
	}

	//오버라이딩
	public void test() {
		System.out.println("자식클래스");
	}
}

 

추상클래스, Abstract Class
 - 일반클래스
      : 객체의 설계도, 틀 -> 멤버변수 & 멤버메서드 -> 객체생성
 - 추상클래스
      : 겍체의 부모역할 -> 객체 사용법의 규칙 생성
 - 인터페이스
      : 클래스의 부모역할 -> 클래스 사용법의 규칙 생성

 

 특징 :
      가. 추상클래스를 상속받는 자식클래스는 
           반드시 추상클래스가 가지는 추상메서드를 오버라이딩해야한다!!
      나. 추상클래스는 객체 생성을 하지 못한다.

 

public class Ex87_Abstract 
{
	public static void main(String[] args)
	{
		//Ex87_Abstract.java
		
		ChildA a = new ChildA("자식A");
		ChildB b = new ChildB("자식B");

		//자식들 모두 인사~
		a.hello();
		b.hello();
		//Hong의 자식들은 모두 hello()라고 인사한다!

//		Hong hong = new Hong("홍");	: 추상클래스는 객체 생성을 하지 못한다.
	}
}

//부모
//추상클래스(추상메서드를 갖는다)
abstract class Hong
{
	public String name;
	
	public Hong(String name) {
		this.name = name;
	}

	//추상메서드(구현이 되지 않은 메서드)
	//추상클래스를 상속받는 자식클래스는 
	//반드시 추상클래스가 가지는 추상메서드를 오버라이딩해야한다!!
	public abstract void hello();	// 추상메서드는 블럭이 없다.

}//end Hong

//자식
class ChildA extends Hong
{
	public ChildA(String name) {
		super(name);
	}

	public void hello() {
		System.out.println("하이~");
	}
}

class ChildB extends Hong
{
	public ChildB(String name) {
		super(name);
	}

	public void hello() {
		System.out.println("hi~");
	}
}
///////////////////////////////////////////////////////////////////////////////////////
public class Ex88_abstract 
{
	public static void main(String[] args)
	{
		//Ex88_abstract.java
		//도형 클래스

		Circle c = new Circle();
		c.draw();
		c.erase();

		Rectangle r = new Rectangle();
		r.draw();
		r.erase();
	}//end main
}

//추상 클래스
//	- 도형을 그리는 방법
//	- 도형을 지우는 방법
//	- 방법을 통일 -> 메서드 이름을 똑같게 강제로 지정
abstract class Shape
{
	//추상메서드
	public abstract void draw();
	public abstract void erase();
}

class Circle extends Shape
{
	public void draw() {
		System.out.println("원을 그립니다.");
	}
	public void erase() {
		System.out.println("원을 지웁니다.");
	}
}

class Rectangle extends Shape
{
	public void draw() {
		System.out.println("네모를 그립니다.");
	}
	public void erase() {
		System.out.println("네모를 지웁니다.");
	}
}

 

비정형인자
     - 매개변수의 갯수가 고정이 아닌 경우

 

class Ex90_args 
{
	public static void main(String[] args)
	{
		//비정형 인자
		//	- 매개변수의 갯수가 고정이 아닌 경우
		System.out.println(add(10,20));
		System.out.println(add(10,20,30));
		System.out.println(add(10,20,30,40));

		//인자의 갯수를 계속 늘리고 싶다!!



	}
/*
	public static int add(int a, int b) { return a + b; }
	public static int add(int a, int b, int c) { return a + b + c; }
	public static int add(int a, int b, int c, int d) { return a+b+c+d; }
*/

	//가변인수(비정형인자)를 이용한 메서드
	public static int add(int... list) {
		//System.out.println(list.length);

		int sum = 0;

		for(int i=0; i< list.length; i++) 
			sum += list[i];

		return sum;
	}
}

 

래퍼클래스
     - 원래의 클래스를 좀 더 개량해서 기능을 추가한 클래스

 

class Ex91_Wrapper 
{
	public static void main(String[] args)
	{
		//Ex91_Wrapper.java
		//래퍼 클래스 -> 유틸 클래스
		
		//Integer : int 값형을 좀 더 개량해서 기능을 추가한 클래스

		//숫자 10
		int n1 = 10;
		Integer n2 = new Integer(10);

		System.out.println(n1);
		System.out.println(n2);	//n2.toString()

		Object o;
//		o = new Object();
//		o = new Random();
		o = new Integer(100);
		o = 200;	// 참조형 - Boxing 작업이 행해짐( = new Integer(200))

		int m = (int)o;	// 값형과 주소값형 사이에는 Boxing-UnBoxing작업 없인 불가
 		System.out.println(m);
	}
}

 

final 키워드
 1. 지역변수앞에 final 적용
      - 값을 초기화한 뒤 변경이 불가능한 상수
      - 상수는 대문자로만 표기한다

 2. final을 메서드에서 선언
      - 재정의가 불가능한 메서드로 선언
 
 3. final을 클래스에 적용
      - 상속이 불가능한 클래스를 만든다.(안정성)
      - 최종클래스, 봉인클래스, 말단클래스

 M/p>

public class Ex92_final 
{
	public static void main(String[] args)
	{
		//Ex92_final.java
		//final 키워드

		//1. 지역변수앞에 final 적용
		//	- 값을 초기화한 뒤 변경이 불가능한 상수
		//	- 상수는 대문자로만 표기한다
		final int n = 10;
		System.out.println(n);

//		n = 20;	- error: cannot assign a value to final variable n
		System.out.println(n);

		//파이(pi)
		//double pi = 3.14;
		//pi = 3.15;

		final double PI = 3.14;

	}//end main
}

//부모
class Parent
{
	public int m = 10;

	//2. final을 메서드에서 선언
	//	- 재정의가 불가능한 메서드로 선언
	public final void test() {
		System.out.println(this.m);
	}
}

//자식
class Child extends Parent
{
	//메서드 오버라이딩(재정의)
	public void test() {
		System.out.println("재정의");
	}
}


//3. final을 클래스에 적용
//	- 상속이 불가능한 클래스를 만든다.(안정성)
//	- 최종클래스, 봉인클래스, 말단클래스
final class Test 
{
	public int t;
}
// error: cannot inherit from final Test
//class Temp extends Test
//{
//}