memory

인터페이스
추상클래스보다 추상화정도가 더높은 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를이용해 한번에 불러온다

method overloading이란 하나의 클래스에
같은 이름의 method를 여러개 정의하는걸
오버로딩이라고 한다
overloading 조건에는 method 이름이 같아야하고
매개변수의 개수, 데이터타입 또는 순서가 달라야한다.
매개변수가 달라 함수명을 달리해야할경우

개발자 입장에서 불편하기때문에 overloading을 사용한다 

//public class MethodOverloading
public void getAdd() {
System.out.println("overloading");
} //매개변수가 없기때문에 문제없이 overloading이 된다

public int getAdd(int i, int j) {
return i+j;
}

public int getAdd(int i, int j, int k) {
return i+j+k;
}

public double getAdd(double i, int j, int k) {
return (double)(i+j+k);
}

public int getAdd(float i, int j, int k) {
return (int)(i+j+k);
}

public int getAdd(int i, float j, int k) {
return (int)(i+j+k);
} //data type의 순서가 다르기 때문에 overloading이 성립된다

public double getAdd(int i, int j, int k) {
return i+j+k;
} //return 타입은 관계가없고 갯수가 같으므로 overloading이 되지 않는다

public double getAdd(int ii, int jj) {
return ii+jj;
} //매개변수의 타입이같고 갯수가 같아서 overloading이 되지 않는다

//main
MethodOverloading mOver = new MethodOverloading(); //객체생성

mOver.getAdd();
int a = mOver.getAdd(1,2);
int b = mOver.getAdd(1,2,3);
double e = mOver.getAdd(1.3, 2, 3);
int c = mOver.getAdd(1.2F, 2, 4);
int d = mOver.getAdd(1, 1.2F,3);

System.out.println(a+b+c+d+e);
--------
//class TextBook 
String title;
String author;
int grade;

public TextBook() {
title = "kor";
author = "jusung";
} 

//생성자는 멤버변수를 초기화 할때 사용한다 

//변수앞에 String을 붙여서 초기화할시

//지역변수가되서 초기화가되지않는다

1.
public TextBook(String title) {
this.title = title;
} 

//매개변수 갯수가 달라서 오버로딩이 성립된다

2.
public TextBook(String title) {
this(title,"jusung"); //생성자가 생성자를 호출할수있다
} 

//this()는 생성자를 호출하는 method
//this()는 생성자 안에서만 사용한다
//this()는 반드시 생성자 첫줄에 써야한다

public TextBook(String title, String author) {
this.title = title;
this.author = author;
}

//자기 클래스의 instance 변수를 접근할때 this를 사용한다
//사용자가 생성자를 만들경우 기본생성자가 생성되지않는다
//매개변수를 가지는 생성자를 인자생성자라고한다
//this는 static method에서는 사용할수 없다.

public TextBook(String title, String author, int grade) {
this.title = title;
this.author = author;
this.grade = grade;
}

public void getBook() {
System.out.println(this.title);
System.out.println(author);
System.out.println(grade);
} //this를 넣나 안넣나 상관이 없다.

//public class ConstructorOverloading
//main

TextBook tb = new TextBook();
System.out.println(tb.title); //kor이 출력된다
System.out.println(tb.author); //jusung이 출력된다

//기본생성자 초기화를 kor, jusung으로 했기때문이다
         
TextBook tb = new TextBook("kor","jusung");
System.out.println(tb.title); //kor이 출력된다
System.out.println(tb.author); //jusung이 출력된다
         
TextBook tb1 = new TextBook("kor"); 
tb1.getBook(); 

//1. "kor"이 출력되고 나머지는 default값
//2. 생성자가 생성자를 호출한경우 

//"jusung"도 같이 출력되고 나머진 default값 
         
TextBook tb2 = new TextBook("kor","jusung");
tb2.getBook();

//"kor","jusung"이 출력되고 나머지는 default값
         
TextBook tb3 = new TextBook("kor","jusung",5);
tb3.getBook(); 

//"kor","jusung",5 이 출력된다

//public class Member
static int aa; //class 변수
String str; //instance 변수

public Member() {
System.out.println("Constructor");
} 

//생성자를 만들지 않아도 기본 생성자가 자동으로 생성된다.

//생성자에는 static이 없고 반환타입이 없다 

public static void yy() {
System.out.println("class method");
}

public static String yyy() {
System.out.println("반환값이 있는 class method");
return "return value";
}

public void bb() {
System.out.println("instance method");
}

public int xxx() {
System.out.println("반환값이 있는 instance method")
return 1000;
}

public void zz(String str1) {
System.out.println("매개변수가 있는 메소드"+str1);
}

//main
Member mem = new Member(); //Constructor가 출력된다

//생성자를 호출하는건 객체를 생성한다는 의미이다. 

Member.yy(); //class method 가출력된다
//같은 클래스일경우 class명 없이 yy();로 호출가능하다

mem.bb(); //class method가 출력된다

mem.zz("parameter");
//string type의 형태로 호출해줘야한다
//parameter 값을 str1에 넘겨주고 문장을 출력할때 그값을 이용해 출력한다

String str2 = yyy();
System.out.println(str2); //return value가 출력된다
//yyy method를 호출해서 반환값 return value를 str2에 돌려준다

int qq = mem.xxx();
System.out.println(qq);
//xxx method를 호출해 반환값 1000을 qq에 돌려준다