memory

Object class
최상위클래스로 모든클래스는
암시적으로 Object를 상속받고있다
-----
//public class ObjectEx extends Object

//입력하지않아도 암시적으로 extends Object 를 상속하고있다
//main
ObjectEx obj = new ObjectEx();
obj.toStringFunc(obj);
}

//toStringFunc

public void toStringFunc(ObjectEx obj) {
System.out.println(obj); 
//객체명만 들어갈경우 자동으로 toString method를 호출한다
System.out.println(toString()); 
//toString method는 해당class 객체를 문자열로 반환해주는 역할이다
//getClass().getName()+'@'+Integer.toHexString(hashCode())가 출력된다
System.out.println("hi"+this); //this는 해당class obj를 의미한다
} //객체에 문자열 +연산을하는경우 toString()method가 자동으로 호출된다

 
public String toString() {

//toString 은 복잡하게출력되므로 알기쉽게 overriding을해서 사용한다

return "this is ObjectEx class";
}
------

//public class

//main
int aa = 100;
int bb = 100;

if(aa==bb) { 
System.out.println("aa와 bb는 서로같다"); 
}else { 
System.out.println("aa와 bb는 서로 다르다"); 
} //== 비교연산자는 기본자료형을 비교하는경우 값을 비교하기때문에

//서로 같다라는 내용이 출력된다

String str1 = new String("heelo");
String str2 = ("heelo");

if(str1==str2) { 
System.out.println("str1, str2는 같다"); 
}else { 
System.out.println("str1, str2는 다르다"); 
} //== 비교연산자는 참조형(Reference Type)을 비교할경우

//주소값을 비교하기때문에 서로 다르다라는 내용이 출력된다.

//만약에 str1=str2; 를한다면 주소값이 같아지기때문에 같다가 출력된다. 

//equals는 앞의객체와 뒤의객체를 비교해 true, false값을 반환한다
if(str1.equals(str2)) { 
System.out.println("str1, str2는 같다");
}else { 
System.out.println("str1, str2는 다르다");
} //String 객체는 Object class에 있는 equals method를 

//overriding을해서 비교하기때문에 '다르다'가출력된다 

//String 객체의 Equals method는 overriding된 method여서 내용을 비교한다

value va1 = new Value(10);
value va2 = new Value(10); //서로 다른 instance를 가리킨다

if(val1.equals(var2)) {
System.out.println("va1과 va2는 서로같다");
}else { 
System.out.println("va1과 va2는 서로 다르다");
} //Value class는 overriding을 하지 않아서 서로 "다르다"가 출력된다 

//va1 = va2;를 입력할경우 "같다"가 출력된다

//Equals method가 Objet class 에 있는경우 주소값을 비교한다

//hashCode는 주소의 값을 반환해주는 method이다

System.out.println(str1.hashCode()); 
System.out.println(str2.hashCode()); //같은 값이 출력된다 
//서로다른주소의 값이 나와야하지만 내용이 같은경우 

//String 객체에서는 hashCode의 값이 같아지도록 overriding을했다  

System.out.println(va1.hashCode()); 
System.out.println(va2.hashCode()); //다른값이 출력된다

//class Value
int a;
public Value(int a) {
this.a = a;
}

// public boolean equals(Object obj){
// if(obj != null && obj instanceof Value) {
// return a == ((Value)obj).a;
// }else {
// return false;
// } //내용을 비교할경우 이와같이 overriding을 해줘야 "같다"가 출력된다.
// } //String형태도 이와같이 overriding되서 사용되고있다 

예외처리란 프로그램 실행시 발생할수있는 상황들을 미리 정해놓고

예외가 발생했을경우에 대비하여 코드를 작성하여

프로그램이 정상적으로 작동하게하기위해서다.

컴파일 에러는 컴파일할때 발생하는 에러로 문법상의 오류를 말한다

런타임 에러는 컴파일후 실행할때 발생하는 에러이다

런타임 에러는 error와 exceptiond으로 나눌수있는데

error는 코드에서 처리할수없는 심각한오류를말하고

exception은 코드에서 처리할수있는 가벼운 오류를 말한다

exception 에는 IOException, ClassNotFoundException, RuntimeException등이 있는데

IOException과 ClassNotFoundException은 사용자의 입력 실수에 의해 오류가 발생하는 경우이다

IOException과 ClassNotFondException경우 컴파일시 예외처리를 해줘야한다

RuntimeException에는 ArithmeticException, NullPointerException, IndexOutOfBoundsException

등이 있는데 개발자에의해 오류가 발생하는 경우이다

직접처리
try {
예외발생 예상코드
}cath(해당 예외 클래스 e){
예외처리 코드
}
선언처리
public void aaa() throws IOException{
int i = System.in.read();
} //aaa()를 호출하면 IOException class도 같이호출되

//입력시 발생할지도모를 오류를 해결한다 
----------

//public class

//main
int intArray[] = {1,2,3,4,5}; 
//변수를 try 안에서 선언하면 지역변수가되서 사라지게되기때문에 밖에서 선언해줘야한다

try {
System.out.println(intArray[0]);//공간이 하나이므로 1출력
System.out.println(intArray[5]);//공간이 6개이므로 에러
}catch(Exception e) {
    System.out.println("예외발생");

}finally {

    System.out.println("항상 실행되어야될 코드");
} //finally는 반드시 수행되는부분이다 

//return이 있을경우 다음 문장을 수행하지않고 blcok을 빠져나오게되는데 
//finally가 있으면 중간에 return이 있어도 반드시 수행된다 
//주로 DB접속을 끈을때 사용한다 
--------

//public class

//main
int intArray[] = {1,2,0,4,5};

try {
System.out.println(intArray[0]); //첫번째 배열 1이 출력
System.oot.println(intArray[4]/intArray[2]); 

//세번째 배열값 0으로 나눌수없으므로 error발생

System.out.println(intARray[5]); //배열이 6개가 아니므로 error발생

String str = null;  
str.toString(); 

//toString은 문자열을 출력하는 method인데 str은 null값이므로 error발생 

}catch(ArithmeticException e) {
    System.out.pintln(e.getMessage()); 

}catch(ArrayIndexOutOfBoundsException e) {
    System.out.println(e.toString()); 

//발생할수있는 예상 코드가 여러개일경우 다중 catch문을 사용한다

}catch(Exception e) {

//예상치 못한 error를 상위class의 Exception을 입력
//Exception이 상위의 class이므로 가장 마지막에 적어줘야 하위class의 error check가 실행된다.    

    e.printStackTrace(); 

}System.out.println("항상 실행되어야할 코드"); 

//e.getMessage()를하면 에러설명을볼수있다

//e.toString()을 쓰면 자세한 에러설명을해준다

//e.printStackTrace();를 입력할경우 더 자세한 에러설명을 해준다 
-----

//public class

//main
ThrowEx a = new ThrowEx();
a.throwSample(12); //10보다 크므로 error message 를 출력한다

//class ThrowEx
public void throwSample(int n) {

//예외를 발생시켰으므로 try, catch를 이용하여 처리를해야한다
try {  
if(n > 10) { 
throw new Exception("n 값이 10보다 크다");

//throw는 문자를이용해 예외를 발생시키겠다는 의미이다 
}}catch(Exception e) {
     e.printStackTrace();

}
------

//public class

//main

ThrowEx a = new ThrowEx();
try {
a.throwSample(12);
}catch(Exception e) {e.printStackTrace();}

//throws Exeption을 가진 method를

//호출했기때문에 try,catch문으로 처리를해줘야한다

//class ThrowEx
public void throwSample(int n) throws Exception{  
if(n > 10) { 
throw new Exception("n 값이 10보다 크다");
}} //throws Exeption은 예외를 호출한쪽으로 던진다는의미로 
//이 method를 호출할때 예외처리를 해줘야한다는뜻이다
------

//public class

//main

ThrowEx a = new ThrowEx();
try {
a.throwSample(12);
}catch(Exception e) {

e.printStackTrace();

}

//class ThrowEx
public void throwSample(int n) throws IllegalArgumentException,IOException{
//예외발생이 2개일때 여러개의 예외를 호출하는 쪽으로 넘겨줌으로써 처리할수있다 

//try,catch문을 중첩되게 사용해서 IOException을 처리할수도있고

//Exception을 넘겨줄때 IllegalArgumentExeption,IOException을 같이 넘겨줄수도있다

try {
int aa = System.in.read(); //입력받을땐 IOException처리를 해줘야한다
System.out.println(aa); //a를 입력할경우 아스키값 97이출력
}catch(IOException e) {
e.printStackTrace();
}//try,catch문으로 예외처리를 할수있고

//try,catch문 없이 throws로 여러개의 예외를 한번에넘겨줄수있다
if(n > 10) {
throw new IllegalArgumentException("n 값이 10보다 크다");
}}
------

//public class

//main

MyException mye = new MyException(); 

//method에서 예외처리를 하지않았으므로 여기서해줘야한다
try {
mye.IOExc();
}catch(IOException e) {
e.printStackTrack();
} //throws나 try,catch문 둘중하나를 입력해 예외처리를 해줘야한다

//class MyException
void ArithmeticExc() {
throw new ArithmeticException();
} //실행을해봐야 알수있으므로 예외처리를 하지않는다

void IOExc() {
throw new IOException();
} //컴파일시 예외처리를 하라고 강요되어진다

void IOExe1() {
try {
throw new IOException()
} cath (IOException e){
e.printStackTrace();
} //미리 IOException처리를 해주어야한다
------

//public class

//main

Divide di = new Divide(); 
di.setNumber(5, 0);
try {
di.divide(); //0으로 나누기때문에 error가 생긴다
}catch(MyException e) {
e.printStackTrace();
System.out.println(e.getMessage());
//exception!: can not divide by zero 가 출력된다
} //method에서 발생한 예외를 try,catch문을 이용해 처리한다 

//class Divide
int n1, n2;
public void setNumber(int n1, int n2) {
this.n1 = n1;
this.n2 = n2;
}
public void divide() {
if(this.n2 == 0) {
throw new MyException("exception!: can not divide by zero");
} //0일경우 Myexception을 호출해 예외를 발생시켜준다 
System.out.println(this.n1/this.n2);
}

//class MyException extends Exception
public MyException() {
super(); //부모의 기본생성자 호출
} //생성자를 만들어준다
public MyException(String msg) {
super(msg);
} //생성자를 overriding해준다

//public class 

public static void exe(Calculator cal){

//static으로 class method 생성해 각각의 instance가 method를 공유한다

//부모타입으로 매개변수를생성해 data를 가져온다

cal.setNum(100,200); 
cal.calResult(); 
} 

//main
public static void main(String[] args) {
Calculator c1 = new Sum(); //부모type의 자식 instance를 생성
Calculator c2 = new Subtractor(); 

exe(c1); //sum 의 값을 출력한다
exe(c2); //subtractor의 값을 출력한다

//부모타입으로 매개변수를 받기때문에 각각의 인스턴스는 인자값을 받아온다

//이처럼 calculator 하나의 type 으로 기능이 다른동작을수행하는걸 다형성이라고한다 

Sum sum = new Sum();
sum.setNum(100,200);
sum.calResult();

Subtractor sub = new Subtractor();
sub.setNum(100,200);
sub.calResult();

//abstract class Calculator 

//abstract는 미완성클래스로 상속을 강요하는 class이다
int n1, n2;

public void setNum(int n1, int n2) {
this.n1 = n1;
this.n2 = n2;
}
public abstract void calResult(); 

//추상method는 overriding을 해줘야한다

//class Sum extends Calculator
public calResult(){ 
System.out.println(this.n1+this.n2);
} //추상method를 overriding해준다

//class Subtractor extends Calculator
public void calResult() {
System.out.println(this.n1-this.n2;)
} //추상method를 overriding해준다
----------

Calculator c1 = new Sum(); 
Calculator c2 = new Subtractor();

Calculator ca[] = new Calculator[2]; 
ca[0] = new Sum(); 
ca[1] = new Subtractor(); 
//서로 다른 객체를 이용해서 method를 호출할수있지만

//부모가 같을경우 배열을 이용하여 두객체를 하나의 객체로 선언할수있다

-----------

static int i = 0; //carArray가 static이기때문에 변수도 static으로 바꿔준다
static Calculator calArray[] = new Calculator[3];

//static으로 배열을 생성했기때문에 객체를생성할필요가없다

//public class

public static void exe(Calculator cal){

//static으로 class method 생성해 각각의 instance가 method를 공유한다

//부모타입으로 매개변수를생성해 data를 가져온다

calArray[i++] = cal;

//carArray배열에 car객체를 입력한다

cal.setNum(100,200); 
cal.calResult(); 

} //class method

//main
Sum sum = new Sum();  
Subtractor sub = new Subtractor(); 

exe(sum); 
exe(sub); 
exe(sum); 
exeSequence(); 

//같은 class이므로 바로불러올수있다

//exeSequence
public static void exeSequence() {
for(int i=0;i<calArray.length;i++) {
String str = calArray[i].operand();

//carArray[i]에 operand method를 호출
System.outprintln(str);
} //연산의 순서를 나타내기위한 class method

//abstract class Calculator 

//abstract는 미완성클래스로 상속을 강요하는 class이다
int n1, n2;

public void setNum(int n1, int n2) { 
this.n1 = n1; 
this.n2 = n2; 
} 
public abstract void calResult(); 

//추상method는 overriding을 해줘야한다 

public abstract String operand();

//연산의 순서를 나타내기위해 추상method를 만든다

//class Sum extends Calculator
public calResult(){ 
System.out.println(this.n1+this.n2); 
} //추상method를 overriding해준다

public String operand(){

return "plust";

} //추상method를 overriding해준다

//class Subtractor extends Calculator
public void calResult() { 
System.out.println(this.n1-this.n2;) 
} //추상method를 overriding해준다

public String operand(){

return "minus";

} //추상method를 overriding해준다

다형성이란 하나의 method나 class가 다양한 방법으로 동작하는것을말한다

하나의 참조변수로 여러타입의 객체를 참조할수있는것
즉 조상타입의 참조변수로 자손타입의 객체를 다룰수있는것이 다형성이다

조상타입의 참조변수로 자손타입의 인스턴스를 참조할수있지만
자손타입의 참조변수로 조상타입의 인스턴스를 참조할수없다.

//public class
//main
Super sp = new Super(); 
System.out.println(sp.x +sp.y);
sp.ss(); //일반적인 방법

Child ch = new Child();
System.out.println(ch.z+ch.j);
ch.getClass(); //일반적인 방법

//super type으로 참조변수로 child instance생성 
Super sp1 = new Child(); 
System.out.println(sp1.x+sp1.y); //super class내에 있어서 가능
System.out.println(sp1.z+sp1.j);  //참조할수 없다
//부모타입으로 자식인스턴스를 생성할경우 자식이가진 고유한 멤버는 접근할수없다
sp1.ss(); //super class에 method가 child class 에서 overriding된게 출력된다

//overriding이 됬을경우 overriding이 된 method를 우선순위로 출력한다
Child ch1 = new Super(); //자식타입의 참조변수는 부모인스턴스를 생성할수없다

//class Super
int x=200;
int y=200;
public void ss() {
System.out.println("parents class");
}

//class Child extends Super
int z = 1000;
int j = 2000;
public void ss() {
System.out.println("child class");
} //overriding해서 super class의 method를 재정의

참조변수의 형변환
서로 상속관계에 있는 타입간의 형변환만 가능하다
자손타입에서 부모타입으로 UpCasting 인경우 형변환생략 가능
부모타입에서 자손타입으로 DownCasting 인경우 형변환 생략 불가

참조변수의 형변환은 참조변수의 타입을 변환하는것으로 인스턴스에 영향을 주는것이 아니다.
참조변수의 형변환은 참조하고 있는 인스턴스에서 사용가능한 멤버의 개수를 조절하는 것이다.

//public class
//main
Car car = null;

FireEngine fe = new FireEngine(); //객체생성
fe.water(); //method 호출
Truck tr = new Truck();
tr.sand();

fe = (FireEngine)tr; 

//상속관계가 아니기때문에 tr을 FireEngine으로 형변환을할수없다

car = (Car)fe; //자식(fe)를 부모타입(Car)로 변환하는 upCasting으로 (Car) 생략가능 
car.water(); //자식 고유의 method로 사용할수없다

fe = (FireEngine)car; //부모타입(car)를 자식(FireEngine)으로 downCasting으로 (FireEngine) 생략불가 
fe.water(); //car의 null 값에 car=(Car)fe;를 했기때문에

//fe=(FireEngine)car은 결국 자기자신을 가리키게 되므로 실행이된다

//class Car
String color;
int door;

public void accel() {
System.out.println("dirve");
}
public void break() {
System.out.println("stop");
}

//class FireEngine extends Car
void water() {
System.out.println("water");
}

//class Truck extends Car
void sand() {
System.out.println("take sands");
}

----------

//class Car
String color;
int door;

public void accel() {
System.out.println("dirve");
}
public void break() {
System.out.println("stop");
}

//class FireEngine extends Car
void water() {
System.out.println("water");
}

//class Truck extends Car 
void sand() {
System.out.println("take sands");
}

//public class
//main 
Car car = new Car(); //car instance생성
Car car2 = null;
Truck tr = null; //tr이라는 참조변수는 null값을 가진다 

car.accel(); //drive 출력

//car 참조변수는 car instance를 가리키고있고 car instance내 method에 접근가능하다 

tr = (Truck)car; //자식 참조변수는 부모의 인스턴스를 참조할수없으므로 error가 난다
tr.accel(); //error가 난다

car2 = (Car)tr; //upCasting으로 (Car)생략가능
car2.accel(); //tr값이 null이기때문에 car2가 null값을 참조한것으로 error가 생긴다

instanceOf
참조변수가 참조하고있는 인스턴스의 실제타입을 알아보는 연산자로
연산결과로 boolean값 true, false를 리턴한다.
if(a instanceOf Car) 참조변수 a가 Car타입인지를 true, false값으로 return 

//public class

//main

Truck tr = new Truck();

if(tr instanceof Truck) {  
System.out.println("it is truck");
} //true값이 출력된다

if(tr instanceof Car) {  
System.out.println("it is car");
} //car는 truck의 부모로 true값 출력

if(tr instanceof Object) { 
System.out.println("it is Object");
} //object는 모든클래스의 부모로 true값 출력 

인터페이스
추상클래스보다 추상화정도가 더높은 class로 
추상method와 상수만을 멤버로 같는다
instance를 생성할수없고 class작성에 도움을 줄목적으로 사용
미리 정해준 규칙에 맞게 구현하도록 표준을 제시하는데 사용

//interface I 

//class 대신 interface를 이용
public void aa(); //추상 method를 가진다 
//추상method는 외부에서 접근해야하기때문에 public 접근제어자를 가진다

//class InterfaceEx implements I

//상속하기위해 extends 대신 implements를 사용
public void aa() {} //추상method aa 를 overriding 해줘야한다
---------
//public class InterfaceEx1
//main

//interface Inter1
abstract public void aa(); //abstract와 public은 생략이되있다

//interface Inter2
void bb();

//class Myclass implements Inter1, Inter2
public void aa() {}
public void bb() {}
//상속을 받을경우 반드시 구현해줘야되는데 공백으로 나둬도된다.

------------

//interface Inter1 
void aa();

//interface Inter2 extends Inter1
void bb(); 
//interface끼리 상속받을때는 extends를 사용한다

//interface Inter3 extends Inter1, Inter2
void cc(); //interface는 다중상속이 가능하다 

//class Super
public void ss() {
System.out.println("hihi");
}

//class B extends Super implements Inter3
public void aa() {} //class를 상속받으면서 interface도 구현이 가능하다
public void bb() {}
public void cc() {}
//Inter3는 Inter1,2을 상속받았기때문에 모든 method를 구현해줘야한다

//public class InterfaceEx2
//main

----------
//public class InterfaceAuser
//main

//interface규격에 맞춰 잡업을 양방향에서 작업할수있다
A a = new A();
a.setNumber(10, 20, 100);
System.out.println(a.sum());
System.out.println(a.avg());

//interface를 만들었기때문에

//세부적인 내용을 몰라도 어떻게사용될지 알수있다 

//interface Ainterface
void setNumber(int n1, int n2, int n3); //abstract,public이 생략되있다
int sum(); //표준을 제공해줘서 양방향에서 동시에 개발이가능하게한다
int avg();

//class A implements Ainterface

//interface규격에 맞춰 잡업을 양방향에서 작업할수있다
int n1; //implements를 이용해 사용할수있다
int n2;
int n3;
public void setNumber(int n1, int n2, int n3) {
this.n1 = n1;
this.n2 = n2;
this.n3 = n3;

}

public int sum() {
return n1+n2+n3;
}
public int avg() {
return (n1+n2+n3)/3;
}
-----------
//interface Interface4 
void a(); //abstract method

//interface Interface5
String b();

//abstract class AbsClass
abstract void c(); 
//abstract class는 일반method와 추상method를

//사용할수있기때문에 method정의할때 abstract적어줘야한다

//interface InterfaceF extends Interface4, Interface5
void d();

//public class InterfaceEx3 extends AbsClass implements InterfacceF

//모든 abstract class와 interface를 사용한다

//모든 method를 overriding을 해줘야한다

public void c() {
System.out.println("CCCC");
}

public void a() {   
System.out.println("AAA");
}  //overriding 은 접근제어자가 같아야하는데 interface method는 public 이 생략되있다
public String b() { //String type을 return해줘야한다
return "BBBB";
}
public void d() {
System.out.println("DDDD");
}

//main
InterfaceEx3 in3 = new InterfaceEx3();
in3.c();
in3.a(); //AAA가 출력된다
System.out.println(in3.b()); //return값이 있어서 출력을해줘야한다
in3.d();

AbsClass ac = new InterfaceEx3(); 
//부모클래스의 타입으로 자식클래스 개체생성이 가능하다
ac.c(); //본인클래스에있으므로가능
ac.b(); //Absclass에 명시되있지않으므로 error가생긴다
ac.a(); //error
ac.d(); //error

InterfaceF inF = new InterfaceEx3();

//부모클래스의 타입으로 자식클래스 개체생성이 가능하다
inF.a(); //InterfaceF는 Interface 4와 5 를 상속받았기때문에가능
inF.b(); //가능
inF.c(); //c는 AbsClass 에서 만든것이므로 error가 생긴다
inF.d(); //가능

final 지정자는 클래스나 필드 method 등에 적용해 사용한다
class 에 사용될경우 상속을 할수 없게한다
method에 적용될경우 overriding을 할수없게한다
변수에 적용하면 상수형 변수를 만든다(변수값을 변경할수없다)

//final public class Super
final double PI = 3.14; //상수를 사용할땐 대문자사용
final public void method() {
System.out.println("super class")
}

-------
//class Super
public void method() {
System.out.pritnln("suepr class");
}

final public void method1() {
System.out.println("final test1");
}

//final class Sub extends Super 

//ifnal class는 다른 class를 상속받을수는있다
public void method() { //overriding을 할수있다
System.out.println("sub class");

public void method1() {
System.out.println("final test2")
} //super class 에 있는 final method는 overriding 할수 없다.

//class Subsub Extends Sub
//final 지정자가 있기때문에

//Sub class 를 상속받을수 없다
-----------
//class FinalEx

final public static int AA = 10; 

//변수앞에 final쓸경우 주로 이런식으로쓰인다
int aa = 100;

//public class FinalEx2
//main
FinalEx fe = new FinalEx();
System.out.println(fe.aa); //100이 출력된다
System.out.println(FinalEx.AA);

//class 변수이기때문에 class명을붙여서 호출한다

fe.aa = -100; //값을 변경할수있다
FinalEx.AA = 200; //final 변수 상수값은 바꿀수없다

추상메서드란 선언부만 있고 구현부가 없는 메서드를 말한다
abstract public void sub();

추상클래스를 상속받은 클래스에서는 '

추상method를 overriding해야하고 instance를 생성할수없다
다른클래스를 작성하는데 도움을 줄 목적으로 작성된다

//abstract public class Employee
//한개 이상의 추상 method가 있으면 class명 앞에 abstract를 붙여야한다
String name;

public Employee(String name) {
this.name=name;
}

abstract public int income();
//구현부가 없는 추상method로 상속을 해서 overriding 해줘야한다

public void getInfo() {
System.out.println(income());
}
--------
//public class HourWorker extends Employee

int payHour = 5000;
int workHour = 8;

public HourWorker(String name) {
super(name); 
//생성자를 만들지 않아도 기본생성자가 만들어지지만
//부모생성자가 있을경우 super method를 이용해 만들어줘야한다
}

public int income(){
return workHour * payHourly;
} //추상클래스를 상속할경우 return을 이용하여 overriding을 해줘야 한다.
-----------
public class WeeklyWorker extends Employee{

int payHour = 5000;
int workHour = 8;
int workWeek = 2;

public WeeklyWorker(String name) {
super(name);
}

public int income() {
return (payHour*workHour)*(workWeek*5);
}//추상클래스를 상속할경우 return을 이용하여 overriding을 해줘야 한다.
---------
public class MonthlyWorker extends Employee{

int payHour = 5000;
int workHour = 8;
int workMonth = 1;

public MonthlyWorker(String name) {
super(name);
}

public int income() {
return (workHour*payHour)*(workMonth*25);
} //추상클래스를 상속할경우 return을 이용하여 overriding을 해줘야 한다.
------------
//public class AbstractEx
//main
HourWorker hw = new HourWorker("jusung1");
hw.getInfo();

WeeklyWorker ww = new WeeklyWorker("jusung2");
hw.getInfo();

MonthlyWorker mw = new MonthlyWorker("jusung3");
hw.getInfo();

멤버 또는 클래스에 사용되 외부로부터 접근을 제한한다

private 같은클래스 내에서만 접근이 가능하다
default(생략형) 같은 패키지 내에서만 접근이 가능하다
protected 같은 페키지 내에서, 다른패키지의 자손클래스에서 접근이가능하다
public 접근 제한이 없다

일반적으로 protected, private는 클래스 앞에 못쓴다
inner class에서는 가능하다

//public class AccessParent
public String publicA ="public Type Variable";
protected String protectedA ="protected Type Variable";
String defaultA ="default Type Variable";
private String privateA ="private Type Variable";
----------

import aPack.*; 
//public class AccessChild extends AccessParent
public void printMethod() {
System.out.println(publicA);
System.out.println(protectedA);
System.out.println(defaultA);
System.out.println(privateA);

}

//main
AccessChild ac = new AccessChild();
ac.printMethod();

//AccessParents와 AccessChild는 다른 package이므로 

//같은 class에서만 가능한 private와

//같은 package에서만 가능한 default는

//출력되지 않고 protected 는 상속을 받았기때문에 출력이가능하다

//public의 경우는 상속을 받지않을경우 객체생성이 안되있기때문에 

//부모클래스 변수에 static을 붙여야만 호출이 가능하다