//상속이 필요한 예제프로그램
class A extends Object{//extends Object가 생략되어있음.
public void aaa() {
System.out.println("aaa클래스");
}
}
public class Exam01 {
public static void main (String[] ar) {
A ap=new A();
System.out.println("클래스="+ap.getClass());
System.out.println("클래스="+ap.toString());
System.out.println("클래스="+ap);
}
}
결과:
클래스=class A
클래스=A@41a4555e
클래스=A@41a4555e
//꼭 상속이 필요한 이유에 대한 프로그램예제임.
class AA{
int x=100;
}
class BB extends AA{
// AA ap = new AA();
int y=200;
}
class CC extends BB{
// BB bp=new BB();
int z=300;
}
public class Exam02 {
public static void main(String [] ar) {
// BB bp=new BB();
CC cp=new CC();
System.out.println("y="+cp.y);
System.out.println("x="+cp.x);
System.out.println("z="+cp.z);
}
}
결과:
y=200
x=100
z=300
import java.lang.*;
class AAA extends Object{//extends Object생략되어 있음.
public AAA() {
super();//상속관계에서 자기를 상속한 상위클래스를 호출하라는 개념이 생략되어 있음.
}
}
public class Exam03 {//extends Object생략되어 있음.
public static void main(String[] ar) {
AAA ap=new AAA();
System.out.println("ap="+ap);//ap.toString()생략되어 있음.
System.out.println("ap="+ap.toString());//ap.toString()
System.out.println("ap="+ap.getClass());//getClass()매소드
}
}
결과:
ap=AAA@41a4555e
ap=AAA@41a4555e
ap=class AAA
//상속에 따른 접근제한자의 내용예제임.
class D{
int a,b,c,d,e,f;
public D() {
a=100;b=200;c=300;
d=400;e=500;f=600;
}
public D(int c) {
this();//자기자신의 클래스의 또다른 생성자를 호출함.
this.c=c;
}
}
class E extends D{
int g,h,i;
public E() {
super();//자기에게 상속을 준 상위클래스의 생성자를 호출하여 줌.
// a=100;b=200;c=300;
// d=400;e=500;f=600;
g=700;h=800;i=900;
}
}
public class Exam04 {
public static void main(String[] ar) {
E ep=new E();
System.out.println("a="+ep.a);
System.out.println("i="+ep.i);
System.out.println("b="+ep.b);
}
}
결과:
a=100
i=900
b=200
//this와 super의 사용하는 개념예제프로그램.
class F{
protected int x=100;
protected int y=200;
int z=700;
}
class H extends F{
private int x=300;
private int y=400;
public void disp() {
System.out.println("x="+this.x);//가장 가까운쪽의 x를 선택함.
System.out.println("y="+super.y);//자신을 상속시킨 상위의 클래스의 변수를 선택함.
System.out.println("z="+z);
}
}
public class Exam05 {
public static void main(String[] ar) {
F fp=new F();
H hp=new H();
hp.disp();
}
}
결과:
x=300
y=200
z=700
class GG{
public void aaa() {
System.out.println("GG");
}
}
class JJ extends GG{
public void aaa() {
super.aaa();//재정의를 한것임..자기를 상속한 상위내용을 호출함.
System.out.println("JJ");
}
}
public class Exam06 {
public static void main(String [] ar) {
// GG gp = new GG();
JJ jp = new JJ();
jp.aaa();
}
}
결과:
GG
JJ
class FF{
private int x;
private int y;
public void setXY(int x) {
this.x = x;
this.y = 100;
}
public void setXY(int x, int y) {
this.x = x;
this.y = y;
}
void disp() {
System.out.println("this.x = " + this.x);
System.out.println("this.y = " + this.y);
}
}
class HH extends FF{
public void setXY(int x) {//상속관계에서 완벽하게 똑같은 내용임.
}
}
public class Exam07 {
public static void main(String[] args) {
FF fp = new FF();
fp.setXY(100);
fp.disp();
System.out.println();
fp.setXY(100,200);
fp.disp();
}
}
결과:
this.x = 100
this.y = 100
this.x = 100
this.y = 200
//오버라이딩되는 메소드를 방지하는 방법의 프로그램.
class OO{//클래스 자체를 상속하지 못하도록 막는방법임.
public /*final*/ void aaa() {//자체의 메소드를 사용하여 재정의하지 못하도록 강제로 구성하는 명령어임(final)
System.out.println("OO");
}
}
class PP extends OO{
public void aaa() {
System.out.println("PP");
}
}
public class Exam08 {
public static void main(String[] ar) {
PP pp=new PP();
pp.aaa();
}
}
결과:
PP
class TT {
protected int x=100;
}
class RR extends TT {
int y=300;
}
class WW extends TT {
int z=400;
}
public class Exam10 {
public static void main(String[]ar) {
RR rp=new RR();
System.out.println("rp.x="+rp.x);
System.out.println("rp.y="+rp.y);
WW wp=new WW();
System.out.println("wp.z="+wp.z);
}
}
결과:
rp.x=100
rp.y=300
wp.z=400
class AAAA {//extends Object가 생략되어있음.
public String toString() {
return "AAAA";
}
}
class BBBB {//extends Object가 생략되어있음.
public String toString() {
return "BBBB";
}
}
public class Exam11 {
public static void main(String[] ar) {
Object[] obj=new Object[2];//obj[0]/obj[1]이 초기화가 됨.
obj[0]=new AAAA();
obj[1]=new BBBB();
for(int i=0;i<obj.length;++i) {
System.out.println("obj["+i+"]="+obj[i]);
}
// System.out.println("a="+obj[0]);
// System.out.println("a="+obj[1]);
// System.out.println("a="+a);//a.tostring()
// System.out.println("b="+b);//b.tostring()
}
}
결과:
obj[0]=AAAA
obj[1]=BBBB
//다형성의 내용으로 자식의 객체를 부모객체로 표현하는 방법으로 그자식의 객체가 멤버필드인경우에 다형성의표현방법예제임.
//위에있는 내용을 기준으로찍어주는 형태임
class CCCC{
int x=100;
int y=200;
}
class DDDD extends CCCC {
int y=300;
int z=400;
}
public class Exam12 {
public static void main(String[] ar) {
CCCC cp=new CCCC();//x,y
DDDD dp=new DDDD();//x,y,DDD.y,z
System.out.println("dp.x="+dp.x);
System.out.println("dp.y="+dp.y);
System.out.println();
CCCC ap=new DDDD();
System.out.println("ap.x="+ap.x);
System.out.println("ap.y="+ap.y);//이것이 규칙임. 밑에있는 멤버는 사용할 수 없음.
}
}
결과:
dp.x=100
dp.y=300
ap.x=100
ap.y=200
class FFFF{
public void aaa() {
System.out.println("AAA");
}
public void bbb() {
System.out.println("BBB");
}
}
class HHHH extends FFFF {
public void bbb() {
System.out.println("CCC");
}
public void ddd() {
System.out.println("DDD");
}
}
public class Exam13 {
public static void main(String[] ar) {
FFFF fp = new FFFF();//
HHHH hp = new HHHH();//
hp.aaa();
hp.bbb();
FFFF ap = new HHHH();//
ap.aaa();
ap.bbb();//자식의 내용이 우선해서 선택되어진다.
}
}
결과:
AAA
CCC
AAA
CCC