반응형
- C18상속
- C1801상속_개념
- 상속_개념01_기본이론1
package C1801상속_개념;
class AAAAA{
String x;
String y;
}
class BBBBB{
AAAAA a = new AAAAA();
}
class CCCCC{
BBBBB b = new BBBBB();
}
class DDDDD{
CCCCC c =new CCCCC();
}
//-------------------------------
class EE{
int x;
int y;
}
class FF extends EE{}
class GG extends FF{}
class KK extends GG{}
public class 상속_개념01_기본이론1 {
public static void main(String[] args) {
DDDDD d =new DDDDD();
d.c.b.a.x = "10";
KK k = new KK();
k.x = 10;
}
}- 상속과 헤즈로 나눌 수 있다.
- 클래스 안에 클래스를 만드는것을 헤즈라고 한다.
- class A{
- int a ;
- }
- class B {
- int b;
- A a = new A() ;
- }
- 이것을 has관계이다.
- B b = new B ( ) ;
- b.a.a = 10;
- 점이 너무 많아서 그래서 상속이 나온것
- class C {
- int c;
- }
- class D extends C {
- int d;
- }
- D d = new D ( ) ;
- d.c = 10; //이게 가능하다.
- 점을 많이 찍냐. 적게 찍냐의 차이.
- 상속_개념02_기본이론2
- 상속은 다이아몬드 때문에
- 상속은 1개만 가능
package C1801상속_개념;
class A1{
int a;
int b;
}
class B1{
A1 A = new A1();
int c;
int d;
}
class C1 extends A1 {
int e;
int f;
}
/*
* 상속 : 자식클래스 이름옆에 extends(키워드) 부모클래스 {}
* 상속을 받게되면 마치 자기클래스안의 변수처럼 자유롭게 사용할수있다.
* 상속은 한번만 받을수있다.
*/
public class 상속_개념02_기본이론2 {
public static void main(String[] args) {
A1 A = new A1();
B1 B = new B1();
B.A.b = 10;
C1 C = new C1();
C.b = 10;
}
}- 상속_개념03_기본이론3
package C1801상속_개념;
class A {
int aa;
}
class B extends A {
int bb;
}
class C {
A a = new A();
int cc;
}
public class 상속_개념03_기본이론3 {
// 상속이란?
// B 라는 클래스 가 A 클래스를 상속받으면
// B 가 new 를 할때 A클래스도 같이 생성된다.
// - 자세한 실습은 웹에서 사용할예정
// 상속받는법
// 1) class 자식클래스 extends 부모클래스 {}
public static void main(String[] args) {
B b = new B(); // B는 A를 상속받았으므로 부모변수와 본인변수 aa , bb 둘다 사용가능하다.
b.aa = 100;
b.bb = 200;
// 상속받지않고 상속같은 관계만들기
// C는 A를 상속받지않았지만 내부에 변수를 따로 만들어서 상속받은것과 같은상황이나
// .을 2번 찍어야한다.
C c = new C();
c.cc = 100;
c.a.aa = 200; // 이와같이 . 을 2번찍어야한다.
}
}- 상속_개념04_기본이론4
package C1801상속_개념;
import java.util.Random;
class Test1 extends Random{} //랜덤을 상속 받으면
class Test2 {
Random ran = new Random();
}
public class 상속_개념04_기본이론4 {
public static void main(String[] args) {
Test1 t1 = new Test1();
int r1 = t1.nextInt(100); //ran을 안 쓰고 만들 수 있다.
System.out.println(r1);
Test2 t2 = new Test2();
int r2 = t2.ran.nextInt(100);
System.out.println(r2);
}
}- 상속_개념05_중첩상속
package C1801상속_개념;
class AA{
int aa;
}
class BB extends AA {
int bb;
}
class CC extends BB { //한번에 2개를 못 한다.
int cc;
}
public class 상속_개념05_중첩상속 {
// 클래스당 상속은 1번만 가능하다.
// 상속이 여러개 필요한경우 줄줄이 상속해야한다.
public static void main(String[] args) {
CC cc = new CC();
// 상속을 받으면 부모변수를 마치 자기변수 처럼 사용할수있다.
cc.aa = 10;
cc.bb = 20;
cc.cc = 30;
}
}- 상속_개념06_오브젝트
package C1801상속_개념;
class ExtendsTest1 extends Object {} //object 상속 받음
class ExtendsTest2 {} //object 상속 안 받음
//자바에서 기본 제공되는 기본 클래스이다. => object
class TestA /* extends Object */ {
int a;
}
//눈에는 안 보이지만. 실질적으로 클래스를 만들게 되면
//Object 을 자동으로 상속 받는다.
//------------------------------------------
public class 상속_개념06_오브젝트 {
public static void main(String[] args) {
TestA a = new TestA();
// 자바의 모든 클래스들은 자바에서 미리제공하는 Object 클래스를 내부적으로 자동으로 상속받게 되어있다.
// 변수에 .을 찍어보면 알수있다.
ExtendsTest1 t1 = new ExtendsTest1();
ExtendsTest2 t2 = new ExtendsTest2();
//t1. //부모를 자동으로 상속을 받는다. 컨트롤 스페이스 눌르면
//t2.
}
}- 상속_개념07_오버라이드
package C1801상속_개념;
class MethodOverloding {
void test(int a) {}
void test(int a , int b) {}
void test(String a) {}
}
//오버로딩은 함수 이름을 여러개 만든거다.
//함수 이름은 똑같이 쓰되.
//매개변수가 달라지면은 서로 다른함수다. 이것이 오버로딩이다.\
//하는 이유. 함수 1 2 3 4 5 ..이렇게 길게 하고 싶지 않으니까.
//-----------------------------------
class MethodOverride { //부모
void test() {
System.out.println("testParent");
}
void overridTest() //함수 이름이 같음
{
System.out.println("overridTestParent");
}
}
class Child extends MethodOverride { //자식
void overridTest() //함수 이름이 같음
{
System.out.println("overridTestChild");
}
}
//MethodOverride => 부모자식 상속에서 벌어지는것이다.
//자식이랑 부모랑 함수 이름이 같은것이 있는것
//void overridTest()
//자식의 함수를 실행을 하면 부모의 함수가 실행이 안되는것 => 자식의 함수만 실행됨
//오버라이드를 하는 이유.
//자바는 배열에 똑같은 애들만 넣을 수 있다. 똑같은 타입
//[int , int , int ] , [String, String , String]
// 코딩을 하다보면 . 클래스를 다른 애들을 넣어야 한다.
//[orc , bat , wolf] => unit이라는 부모를 상속 받게 한다.
//꼼수 / unit으로 배열을 만든다. / 그러면 다 담을 수 있다.
//부모는 껍데기이기 때문에 함수가 실행되면 안된다. 자식께 실행되어야 한다.
//자바의 배열은 type이 같아야 한다. 그래서 자식들은 오크. 박쥐. 울프로 만들고=>
//그것을 unit이라는 부모로 같이 둔다.
//-----------------------------------------------------
public class 상속_개념07_오버라이드 {
public static void main(String[] args) {
// 1)메서드 오버로딩
// 메서드 오버로딩은 함수이름을 여러개 사용하수있는 기능이다.
// 2)메서드오버라이드 (*상속 관계에서 적용) = 재정의
// 메서드 오버라이드 는 부모에 있는 메서드를
// 자식이 같은이름으로 만들어서 사용하는것이다.
Child c = new Child();
c.test(); // 당연히 부모의 메서드를 사용할수있다.
c.overridTest(); // 부모의 메서는 실행되지않고 자식의 메서드가 우선순위를 가져간다.
}
}
- 상속_개념08_toString1
package C1801상속_개념;
class Test05_1{ }
class Test05_2 /*extends Object*/ {
int a;
int b;
// 부모에 toString 이 있는지 확인하는 키워드(어노테이션)이라고한다.
// 생략가능
@Override //주석 //이거는 오버라이드. //부모에 이것이 있다. 확인용
public String toString()
{
return a + ", " + b;
}
public void print() {
System.out.println(a + " , " + b);
}
// 부모에 없는 메소드 위에 붙여보면 에러가난다.
//@Override
//void test() {}
}
//--------------------------------------------
public class 상속_개념08_toString1 {
public static void main(String[] args) {
//[오버라이드]
// 클래스 객체의 변수를 출력 하면 주소가 출력된다.
// 원형은 변수.toString() 이지만
// 변수만 쓸수있게 축약형을 제공한것이다.
// toString() 은 Object 클래스에서 제공하는 함수로,
// 주소를 출력해준다.
Test05_1 t1 = new Test05_1();
//t1 => toString이라는 부모가 있다.
System.out.println(t1);//축약형
System.out.println(t1.toString()); //이게 원본 //메모리 주소
System.out.println("--------------------");
// 부모 Object 클래스에 있는 toString() 메서드를
// 자식이 재활용해서 사용할수있다.
Test05_2 t2 = new Test05_2();
System.out.println(t2);
System.out.println(t2.toString());
}
}- 상속_개념08_toString2
package C1801상속_개념;
//class Object{
// public String toString() {
//
// return "주소";
// }
//}
class TestAA /* extends Object */{
@Override
public String toString() // 선언부
{
// 구현부
return "재정의";
}
//@Override //부모에 없는 함수를 시키면 에러가 난다.
//public void test() {}
}
public class 상속_개념08_toString2 {
public static void main(String[] args) {
// 메서드 오버로드(overload)
// 메서드 오버라이드(override)
TestAA a = new TestAA();
System.out.println(a.toString()); // 메모리주소출력
System.out.println(a); // toString() 은 생략가능
}
}- 상속_개념09_super1
package C1801상속_개념;
//자식에서 부모의 변수를 쓰고 싶을 수 있다.
class Super1{
int s;
}
class Child1 extends Super1{
int a;
void test(int a, int s) {
this.a = 10; //자기 자신은 this로 알 수 있다.
a = 10;
s = 10;
super.s = 20; //부모는 super //부모의 변수
//this.s = s; //둘다 된다.
}
}
public class 상속_개념09_super1 {
public static void main(String[] args) {
}
}- 상속_개념09_super2
package C1801상속_개념;
// [super]
// -상속받은 자식클래스에서 부모의 자원을 사용할때 사용함.
class Test06{
void test1() {
System.out.println("여기는 부모 test1()");
//부모의 함수는. 껌데기 함수이다.
//굳이 부모의 함수를 실행 하고 싶다.
}
}
class Test06Child extends Test06{
void test1() {
System.out.println("여기는 자식 test1()");
//자식의 함수가 메인으로 실행되는게 맞다.
}
void play() {
//아래 test1(); 은 자식의 메서드를 실행함.
test1();
//this.test1(); // 원형이나 this생략가능.
//-----------------------------------
super.test1();
// 부모의 test1() 을 실행함.
// super는 부모를 뜻함.
//부모의 함수를 실행하고 싶으면 super을 붙이는 수 밖에 없다.
}
}
//-------------------------------------------
public class 상속_개념09_super2 {
public static void main(String[] args) {
Test06Child t6 = new Test06Child();
t6.play();
}
}- 상속_개념09_super3
package C1801상속_개념;
// [super]
// -상속받은 자식클래스에서 부모의 자원을 사용할때 사용함.
class Test07{
int num;
String name;
Test07(int num, String name){
//생성자 //생성자를 실행시키고 싶을떄 super을 하면 된다.
this.num = num;
this.name = name;
}
}
class Test07Child extends Test07{
int score;
Test07Child(int num , String name , int score){
super(num , name); // 부모의 생성자호출하는법 ()만붙여주면된다.
//부모의 생성자를 실행하고 싶으면 super을 붙이면 된다.
//부모로 넘김
this.score = score;
}
@Override
public String toString() {
return num + " : " + name + " : " + score;
}
}
class Super {
public Super() {
System.out.println("부모");
}
}
class Sub extends Super {
public Sub() {
//super(); // 생략가능(부모 생성자 호출)
System.out.println("자식");
}
}
public class 상속_개념09_super3 {
public static void main(String[] args) {
Sub s = new Sub();
Test07Child t7 = new Test07Child(1001, "이만수" , 23);
//자식에 정보 3개를 넣음
System.out.println(t7/* .toString() */);
}
}반응형