[3주차 1일] Chapter 7 .상속과 다형성

Chapter 7. 상속과 다형성

 

▶ 학습 목표

: 상속이 무엇인지 어떠한 경우에 사용하는지 그리고 어떠한 형식으로 사용하는지 알 수 있다.

 

 

7-3. 상속과 생성자

 

- super()

 

부모 클래스를 호출하는 생성자이다.

생성자가 정의되어 있어야 사용할 수 있다.

자식 클래스를 생성할때 무조건 생성된다.

만약 부모클래스 생성자를 작성하지 않았으면 자동적으로 자식 클래스의 첫 줄에 작성된다.(자동 생성)

 

 

* 오류코드 카테고리의 생성자 호출 오류 게시글 참고

https://3h2im-story.tistory.com/manage/posts/

 

package Chapter7;

class car2
{
	int wheel;
	int speed;
	String color;
	
	car2(String color)
	{
		this.color=color;
	}
}
class sportscar extends car2
{
	int speedlimit;
	
	
	sportscar(String color, int speedlimit)
	{
		super(color); 
        //작성해줘야함. super(color) 작성 안하면 오류. 
        //super(color)아니면 car2에 기본생성자 생성해야한다. car2(){}
		
        this.color=color;
		this.speedlimit=speedlimit;
	}
}

public class superconstructor 
{

	public static void main(String[] args) 
	{
		sportscar sportscar1 = new sportscar("red",330);
		
		System.out.println(sportscar1.color);
		System.out.println(sportscar1.speedlimit);

	}

}

 

 

 

- object 클래스

 

모든 클래스의 조상인 클래스이다.

어떠한 클래스도 모두 마지막에는 object를 상속 받는다.

아무런 상속을 받지 않는 독자적인 클래스를 만들었으면 자동으로 object 클래스 상속 문장이 추가

(생략되어 있다)

 

class Tree extends Object{
	//내부 멤버
}

 

 

 

 

7-4. package와 import

 

 

 

- package

 

: 클래스를 모아놓은 집합,폴더

유지보수 및 관리를 편하게 하기 위해서 관련된 클래스끼리 묶어 분리하는 디렉터리이다.

 

 

- import

 

: 다른 클래스를 가져와서 사용하기 위해 사용한다.(코드를 가져와 객체 생성)

다양한 클래스를 참조시 경로를 생략할 수 있다. -> 코드 간편화

 

import 패키지명.클래스명;

 

 

 

 

 

7-5. 제어자

 

: 제어자는 변수와 함수에 접근하여 사용하기 위해 사용한다.

 

 

 

- 접근 제어자

외부에서 접근할 수 있는 정도와 범위를 정해준다.

 

 

* public : 접근 제한 없음

* protected : 같은 패키지 내에서 접근 가능, 자식 클래스에서 접근 가능(상속)

* default : 같은 패키지 내에서만 접근 가능

* private : 같은 클래스 내에서만 접근 가능

 

 

 

package Chapter7;

class user
{
	private String name;  //private이므로 직접 접근 불가
	private int age;
	user(String name, int age)
	{
		this.name=name; 
		this.age=age;
	}
	public String getName() 
	{ 
		return name;
	}
	public void setName(String name) 
	{
		this.name = name;
	}
	public int getAge() 
	{
		return age;
	}
	public void setAge(int age) 
	{
		this.age = age;
	}  //source -> getter setter에서 get set 설정함 -> 간접접근(안전성 확보)
	
}

public class accessmodifier1 
{

	public static void main(String[] args) 
	{
		user user1 = new user("철수",20); 
		user user2 = new user("영희",19);
		
		//user2.age=99; 에러발생, 직접적 접근 불가
		
		user2.setAge(20);
			System.out.println(user2.getName()+"의 나이는 "+user2.getAge());
	}

}

 

private는 직접 참조할 수 없다.

그렇기 때문에 get set을 설정하여 간접 접근한다.

간접접근을 하면 안정성이 확보된다.

 

 

 

package first;

public class a 
{
	private int aa=10;
	public int aaa;
	
	
	public int getAa() {
		return aa;
	}
	public void setAa(int aa) {
		this.aa = aa;
	}//직접접근하는 것보다 안전함
	
	public void aaa() {
		System.out.println("aaa");
		
	}
	void aaaa() {
		System.out.println("aaaa");
	}

}

 

 

 

 

- static 

: 접근제한이 없는 클래스 멤버를 선언함

static이 앞에 붙으면 생성하지 않아도 미리 생성되어 있기 때문에 생성하지 않아도 사용가능하다.

 

 

 

 

- final

: final 변경 및 수정이 불가하게 만드는 것이다.

 

* final 변수 : 값을 변경할 수 없는 상수

* final 메서드 : 내용을 더 이상 변경 할 수 없다. 오버라이딩 불가 

* final 클래스 : 내용을 더 이상 변경할 수 없는 클래스. 상속 불가

 

 

 

 

 

7-6. 다형성

 

 

- 다형성

: 여러 형태를 가지는 성질

객체의 자료형을 변경하기 위해 사용한다.

참조변수!

 

A obj = new A();

지금까지는 생성자와 참조변수의 클래스 타입을 동일하게 작성했다.

 

 

A obj = new B();
*B가 A를 상속할 때

부모 클래스 타입의 참조변수에 자식 클래스 타입의 객체를 참조한다.

 

 

 

 

- 참조변수와 인스턴스 간의 관계

 

부모 클래스 타입의 참조변수로 자식의 객체를 참조하는 것은 가능,

자식 클래스 타입의 참조변수로 부모의 객체를 참조하는 것은 불가능,

자식클래스 타입의 참조변수로 자식 객체 참조하는 것은 가능.

 

* 부모 클래스에 존재하지 않는 멤버는 사용할 수 없다.

 

 

package Chapter7;

class A{
	void methodA() {
		System.out.println("methodA");
	}
}

class B extends A{
	void methodB() {
		System.out.println("methodB");
	}
}

public class polymorphism1 {

	public static void main(String[] args) {
		A obj = new B(); //B를 생성해서 A에 담아라
		obj.methodA();  //A호출
		//obj.methodB();는 에러발생함 -> B는 A(부모)에 없는 메서드이기 때문에 참조할 수 없다.
		//부모에 있는것만 참조 가능함

	}

}

 

 

 

 

 

- 다형성의 활용

 

 

ex) 다형성 사용 x 메서드가 하나일 경우

 

package Chapter7;

class animal
{
	void breath() 
	{
		System.out.println("숨쉬기");
	}
}

class Lion extends animal
{
	public String toString()  //class접근시 자동 실행
	{
		return "사자";
	}
}



class zookeeper{
	void feed(Lion lion)  //Lion 클래스로부터 받은 값을 가지고 feed함수 실행
	{
		System.out.println(lion+"에게 고기 주기");
	}
}

public class polymorphism3 
{

	public static void main(String[] args) 
	{
		Lion lion1 = new Lion();  //Lion 객체 생성후 lion1 변수에 담기
		zookeeper james = new zookeeper();  //zookeeper객체 생성 후 james 변수에 담기
		james.feed(lion1); //james(zookeeper)에 있는 feed(lion1) 함수 호출

	}

}

 

 

 

 

ex) 메서드가 여러개일 경우

 

 

package Chapter7;

class animal
{
	void breath() 
	{
		System.out.println("숨쉬기");
	}
}

class Lion extends animal
{
	public String toString() 
	{
		return "사자";
	}
}

class Rabbit extends animal
{
	public String toString() 
	{
		return "토끼";
	}
}


class zookeeper{
	void feed(Lion lion)  //Lion 클래스로부터 받은 값을 가지고 feed함수 실행
	{
		System.out.println(lion+"에게 고기 주기");
	}
	void feed(Rabbit rabbit) 
	{
		System.out.println(rabbit+"에게 당근 주기");
	}
}

public class polymorphism3 
{

	public static void main(String[] args) 
	{
		Lion lion1 = new Lion();  //Lion 객체 생성후 lion1 변수에 담기
		Rabbit rabbit1 = new Rabbit();
		zookeeper james = new zookeeper();  //zookeeper객체 생성 후 james 변수에 담기
		james.feed(lion1); //james(zookeeper)에 있는 feed(lion1) 함수 호출
		james.feed(rabbit1);

	}

}

 

 

→ 메서드가 여러개이면 작성할 코드가 많아지고 복잡해진다.

사용할 코드를 줄이기 위해 다형성을 사용한다.

 

 

 

 

 

ex) 여러개일 경우 다형성 사용

 

 

package Chapter7;

class Animal
{
	void breath() 
	{
		System.out.println("숨쉬기");
	}
}

class Lion extends Animal
{
	public String toString() 
	{
		return "사자";
	}
}

class Rabbit extends Animal
{
	public String toString() 
	{
		return "토끼";
	}
}


class zookeeper{
	void feed(Animal animal) 
	{
		System.out.println(animal+"에게 먹이주기");
	}
}

public class polymorphism3 
{

	public static void main(String[] args) 
	{
		zookeeper james = new zookeeper();  //zookeeper객체 생성 후 james 변수에 담기
		Animal lion1 = new Lion();  //Animal 객체 생성후 lion1 변수에 담기
		james.feed(lion1); //james 안의 feed 함수의 lion1호출
		Animal rabbit1 = new Rabbit();  //Animal 객체 생성후 rabbit1 변수에 담기
		james.feed(rabbit1);  //james 안의 feed 함수의 rabbit1 호출

	}

}