memory

//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을 붙여야만 호출이 가능하다

상속이란 extends란 키워드를 사용해

기존클래스를 재사용해서 

새로운 클래스를 작성하는것으로 
두 클래스를 부모(super class)와

자손(sub class)의 관계를 맺어주고
자손은 부모의 모든 멤버를 상속받는다
상속받을수있는 클래스는 단하나이다.
상속관계(is-a), 포함관계(has-a)

//class Human
String name;
int age;

public Human() {
this("haha",123) 

} //본인클래스에서 다른 인자를 호출하기위해선 this method를이용한다

//super class에 인자생성자를 만들경우

//기본생성자가 자동으로 생성되지않기때문에

//super class에 기본생성자를 직접 만듬으로써 

//Sub class에 생성자를 만들지않아도 문제가없다.

public Human(String name, int age) { //인자생성자 생성
this.name = name; //name 과 age를 매개변수를통해 받아온다
this.age = age; //자식클래스에서는 부모생성자를 super를 이용해 만들어야한다
}

public void getInfo() {
System.out.println(name+age);

}

//super : 부모클래스의 객체를 의미, 부모클래스의 변수를 접근
//this : 자신의 객체를 의미, 자신클래스의 변수를 접근
//super() method: super class의 생성자를 호출하기위한 method
//this() method: 자신의 생성자를 호출하기위한 method

//super() method는 생성자 안에서만 호출할수있다. 
//항상 생성자의 첫줄에 와야한다 
//static method안에서는 사용할수 없다. 
//유저가 생성자를 작성하지 않는경우 하위클래스 생성자에서 자동으로 호출한다 

//class Employee extends Human

//Human class를 extends 키워드를 이용하여 상속받는다
super();
int salary;

public Employee() {
super(); //super method를 이용해 super class의 기본생성자를 호출한다
} //생성자를 만들지않아도 기본생성자가 생성되면서 super method가 만들어진다
  //super class에서 인자생성자를 만들경우 super class에 기본생성자가 없어지므로
  //super class에 따로 기본생성자를 만들어주거나 
  //Sub class에 super method를 포함한 생성자를 만들어줘야한다

public Employee(String name, int age, int salary) {
super(name, age); //부모클래스의 생성자를 불러오기위해 super method를 이용한다
this.salary = salary; //salary를 추가해준다
}

public void getInfo() {  
System.out.println(name+age+salary);
} //부모클래스에서 int salary를 추가해 확장시켜준다

//super class에 기본생성자에 다른 인자를 가져와

//name, age인자를 초기화시켰으므로

//haha, 123, default 값 0이 출력된다

//super class에 getInfo() method를 overriding한것으로

//super class에 method를 subclass에서 재정의한것이다

//호출하고자하는 method 는 super class에 존재해야하고

//접근 제어자는 super class보다 넓거나 같다야 한다.

//반환 타입, method명, 매개변수와 type이 같아야하고

//수행할 명령은 달라야 한다.

//class Student extends Human

//public class Inheritance
//main

Employee em = new Employee("hoho",123,999);
em.getInfo();

//Employee는 Human으로부터 상속을 받았기때문에 작동된다

//super method를 이용해 Sub class 에 

//생성자를 overriding 했기때문에 
//hoho,123,999가 출력된다

Student stu = new Student();
stu.getInfo();

//Student는 Human으로부터 상속을 받았기때문에 작동된다

//본인 class에서 overridng된 생성자가

//getInfo method를통해 먼저 호출한다

캡슐화는 data를 외부에서 접근하지 못하도록 제한하는것을말한다
자기클래스에서만 접근할수있는 private 접근제어자를 붙인다

public void setNumber(int n) {
number = n;
}
public void getNumber() {
return number;
}

멤버변수에 값을 설정하고 불러올수있는

set, get method를 만든다 

//public class Student
private String name;
private int id;
private int age; 

//private를 이용할경우 같은 클래스 내에서만 접근가능하다

public void setName(String name) {
this.name = name;
}

public void setId(int id) {
this.id = id;
}

public void setAge(int age) {
this.age = age;
} 

public String getName() {
return name;
} 

public int getId() {
return id;
}

public int getAge() {
return age;
//다른클래스에서 접근할수 있또록 set,get method를 만든다
   
public void showInfo() {
  System.out.println(getName());
  System.out.println(getId());
  System.out.println(getAge());
} //한번에 불러올수있도록 method를 만들어줄수도 있다

//main
Student stu = new Student();
stu.name = "jusung"; 

System.out.println(stu.name);

//같은 클래스이므로 접근가능하다
---------
//public class School
//main
Student stu = new Student();
stu.name="jusung";
System.out.println(stu.name); //error

//다른 클래스이므로 private란 변수 name에 접근할수없다

stu.setName("jusung");
stu.setId(1234);
stu.setAge(55555);
System.out.println(stu.getName());
System.out.println(stu.getId());
System.out.println(stu.getAge());
//이와같이 private일경우 set,get method를 이용해 접근해야한다

stu.showInfo(); 

//Student 에서 만들어논 method를이용해 한번에 불러온다