SW 심화과정 교육 3일차

제주 SW 심화과정 (제주창조경제혁신센터)

# Java 클래스의 특성

 

class Apple2 { int data = 0; int add(int i, int j){ return 100; } } // 멤버변수(property), 멤버 함수(method) // 클래스로 할 수 있는 것 : 참조형 변수 선언, 인스턴스 생성 // 인스턴스와 클래스 관계, 참조형 변수와 인스턴스 관계 public class Test026{ public static void main(String args[]){ Apple2 t = new Apple2(); int i = t.add(10,20); } }

 

# 객체지향 언어의 3대 속성

1. 상속성 : 클래스를 상속해서 클래스를 만들 수 있다.

2. 은닉성 : 감추고 싶은건 감출 수 있다.

3. 다형성 : 하나의 심볼(이름)이 여러 실체에 매핑될 수 있다.

 

# 상속성

 

class A{ int apple = 10; } // 클래스 B는 클래스 A를 상속하여 만들어졌음을 명시함 // A에서 선언한 멤버변수, 멤버함수를 내려받겠다.(물려받겠다) class B extends A{ int add(int i, int j){ return 100; } } /* 멤버변수(property), 멤버 함수(method) */ public class Test027{ public static void main(String args[]){ B t = new B(); System.out.println(t.apple); } }

 

- 에러가 안나는 이유

  → 참조형 변수를 선언하여, 클래스 B 인스턴스를 생성했다. 이때 B가 A를 상속받음으로

      A의 멤버 변수 및 멤버 함수를 사용 가능하다.

      따라서 메인 클래스에서 출력함수일 때, B 인스턴스를 통해서 A의 멤버변수를 출력할 수 있다.

 

- 클래스가 할 수 있는 기능

   1) 참조형 변수를 선언

   2) 인스턴스 생성

   3) 상속받아 클래스를 선언

 

- this

class Apple{ int data = 0; void print(){ System.out.println(this.data); } } // return 문장이 없는 함수 : 서브 루틴. 리턴타입을 void로 선언한다. // 멤버함수 안에서 자신이 소속된 인스턴스에 대한 포인터를 사용가능 : this // 두 개 이상의 인스턴스가 하나의 함수를 호출할 때, 구분하는 방법? // this를 사용 // 함수 하나의 길이가 크다고 해서 인스턴스를 많이 생성하면 메모리에 부담가나? No public class Test028{ public static void main(String args[]){ Apple t = new Apple(); t.data = 10; t.print(); Apple l = new Apple(); l.data = 20; l.print(); } }

 

→ this는 인스턴스를 생성하는 참조형 변수를 가리킨다.

→ 즉, t 인스턴스와 l 인스턴스를 구분하여 상이한 값을 출력한다. 

 

 

- Node

 

class Node{ int data = 0; Node Next = null; Node(int i, Node n){ this.data = i; this.next = n; } } // 생성자는 매개변수를 이용하여 멤버변수를 초기화한다. public class Test029{ public static void main(String args[]){ Node head = new Node(0, null); Node tail = head; } }

 

 

 

- 이 코드가 추가 될 때

 

tail.next = new Node(10, null); tail = tail.next; tail.next = new Node(20, null); tail = tail.next;

 

 

for(Node t = head.next; t !=null; t= t.next){ System.out.println(t.data); // 10, 20 }

 

→ 즉, t.next의 값이 가리키는 대상이 있는 2번째, 3번째 공간의 data를 출력한다.

    가리키는 대상이 없을 때는 초기값인 null이 적용되어 있다.

 

 

# 자바 연결리스트

 

class Node{ int data = 0; Node next = null; Node(int i, Node n){ this.data = i; this.next = n; } } // 생성자는 매개변수를 이용하여 멤버변수를 초기화한다. class LinkedList{ Node head = null; Node tail = null; LinkedList(){ this.head = new Node(0, null); this.tail = this.head; } void add(int i){ tail.next = new Node(i, null); tail = tail.next; } void print(){ for(Node t = head.next; t != null; t = t.next){ System.out.println(t.data); } } } public class Test030{ public static void main(String args[]){ LinkedList l = new LinkedList(); l.add(10); l.add(20); l.print(); } }

 

- LinkedList 생성자를 호출해 Node 인스턴스를 생성해 구조체의 형식을 만든다.

- 생성자에서 멤버변수가 어떤 인스턴스를 가리킬지 정의해준다.

  (head는 새로운 Node 인스턴스를 가리키고, tail이 그 인스턴스를 가리키게 함)

- add함수는 data 매개변수를 갖는 새로운 Node 를 생성하고,

  멤버함수의 tail.next가 생성된 인스턴스를 가리키게 하는 함수

- print 함수는 각각의 data를 출력한다. (data값을 갖는 인스턴스만)

 

 

# 자바 상속

 

class A{ A(){System.out.println("A constructor");} } class B extends A{ B(){System.out.println("B constructor");} } public class Test030{ public static void main(String args[]){ B t = new B(); //t.B(); 오류발생 } }

 

- 상속관계가 존재할 때 (조상클래스, 자손클래스) 
- 자손의 인스턴스를 생성하면 조상의 생성자가 먼저 호출되고, 자손의 생성자가 호출된다.
- 생성자는 상속되지 않는다. 다만 호출될 뿐이다. 멤버함수도 아니다.
   (참조형 변수로도 호출할 수 없다.)
- 생성자는 단지 호출될 뿐임으로, 조상클래스의 인스턴스가 생성되는 것은 아니다.

- B의 인스턴스를 생성하면, 조상의 생성자부터 호출된다.
  A → B 생성자 호출

 

# 상속 오버라이딩

 

class A{ class A{ int i = 100; void print(){System.out.println("A print");} } class B extends A{ int i = 200; void print2(){ System.out.println("B print2"); void print(){System.out.println("B print");} super.print(); // 물려받은 자손쪽에서 물려받은 함수를 호출하고 싶을 때 super를 이용한다. } } // 조상클래스와 부모클래스의 함수 이름이 겹처도 오류가 발생하지 않는다. public class Test032{ public static void main(String args[]){ A t = new B(); // B의 인스턴스를 만든 것, t.print(); // t.print2(); 실행 X, B 클래스의 함수 호출 못함 System.out.println(t.i); // 출력 100 // 함수는 오버라이딩 된 것이 나오고, 멤버 변수는 오버라이딩 개념이 없어 조상 것이 나옴 } }

 

- 조상타입의 변수로 자손의 인스턴스를 가리킬 수 있다.
- 조상에서 선언된 멤버함수 멤버변수만 호출이 가능하다. 
   (인스턴스 안의 멤버변수 함수는 존재하나 호출 못함)
- 만일 오버라이딩 된 함수를 호출한다면 이때는 오버라이딩 된 것이 호출된다.

- 멤버변수에는 오버라이딩 개념이 없어서, 자손클래스에서 재정의해도 부모클래스 멤버변수가 호출된다.

 

 

# 접근지정자

1) 상속 X, 외부 노출 X, 내가 쓸 수는 있어야 함.  : private

2) 상속 O, 외부 노출 X, 내가 쓸 수는 있어야 함. : protected

3) 상속 O, 외부 노출 O, 내가 쓸 수는 있어야 함. : public

 

- 클래스 안의 멤버 변수와 멤버 함수 앞에 붙여준다. → private, 은닉성

- java의 protected : 같은 패키지에서 접근 가능하나 다른 패키지에서는 접근 불가

- (앞에 아무것도 선언 X) friendly : 같은 패키지에서는 public 동작하고, 다른 패키지에서는 private 동작

 

class A{ private int mayak = 0; protected int monarisa = 0; public int house2 = 0; } class B extends A { void print(){ //System.out.println(mayak); 불가 System.out.println(monarisa); } } public class Test033{ public static void main(String args[]){ A look = new A(); System.out.println(look.monarisa); // 자바에서만 된다. 같은 패키지 안에서는 가능하다. C++은 안된다. System.out.println(look.house2); } }

 

- private 은 자손에서도 접근 못하고, 참조형 변수에서도 접근 못한다.
  protected 는 같은 팀의 다른 클래스에게는 알려지지만, 다른 팀에 소속된 클래스는 접근 불가해야 한다.
  후배에게 물려줄 때에는 당연히 접근 가능해야 한다.

 

→ 그러므로, get 함수를 사용하여 혼동을 방지한다.

 

class A{ private int data = 100; public int getData(){ return data; } } class B extends A { private int data = 200; public int getData(){ return data; } // 오버라이딩 된 것이 호출됨. } public class Test034{ public static void main(String args[]){ A t= new B(); System.out.println(t.getData()); } }

- 멤버변수는 무조건 private 하게 선언한다.
- 값을 읽고자 할 때는 getter 함수를 이용하여 접근한다.
- A t = new B()에서 t.i 는 조상의 멤버변수가 나오고, t.print() 는 오버라이딩 된게 나옴
  이런 일이 벌어지지 않게 되더라.
  상속받는 자손에서는 부모 클래스의 멤버변수 이름을 사용하지 않는다. (혼란방지)

 

# abstract

 

abstract class A{ abstract public void print(); } abstract class B{} class C extends B{} public class Test035{ public static void main(String args[]){ A t = null; } }

 

- 위의 print 함수는 선언되었지만 정의되지 않았다. 반드시 abstract 붙여준다.
- abstract 메소드를 하나라도 가진 클래스는 반드시 abstract 클래스라고 정의해야 한다.
- abstract 클래스는 인스턴스를 만들 수 없다. 변수 선언, 상속은 가능하다.

 

 

abstract class A{ abstract public void print(); } class B extends A{ public void print(){ System.out.println(100); } } // 상속받은 메소드를 오버라이딩 해서 메소드의 형태를 갖추면 abstrac가 B클래스 // 앞에 안 붙어도 된다. public class Test036{ public static void main(String args[]){ A t = new B(); // 참조형 변수 선언 가능 // B 인스턴스 생성 가능 -> abstract 메소드를 재정의해서 형태를 갖춤 // B와 A의 상속관계가 형성되어 t가 자손의 인스턴스를 가리킬 수 있다. t.print(); // 자손에서 메소드가 오버라이딩 됐기 때문에 출력 가능 } }

 

- 위의 print 함수는 선언되었지만 정의되지 않았다. 반드시 abstract 붙여준다.
- abstract 메소드를 하나라도 가진 클래스는 반드시 abstract 클래스라고 정의해야 한다.
- abstract 클래스는 인스턴스를 만들 수 없다. 변수 선언, 상속은 가능하다.
- 조상의 t는 자손의 인스턴스를 가리킬 수 있다. 

 

 

# abstract 동작 원리

- 생성자가 호출됬을 때 부모부터 자손까지 생성자가 차례로 호출된다.

- 이때 포인터 동작

- 이후 자손 클래스에서 부모 멤버함수를 오버라이딩 햇을 때

- 원래 A의 포인터를 B의 인스턴스로 위치 옮김

- abstract 는 부모의 포인터가 null 값인 채로 있다가 오버라이딩 된 인스턴스로 포인터 이동

---

 

- 조상의 포인터로 자손의 인스턴스를 가리킬 수 있다. (자손이 더 크니까)

- 자손 안에 있는 조상의 영역까지만 가리킨다.

- 조상의 참조형 변수를 이용해서 조상의 멤버변수, 멤버함수만 호출 가능

- 오버라이딩 되면 조상의 포인터가 자손의 인스턴스를 가리키게 이동된다.

 

- abstract의 멤버함수를 오버라이딩해서 메소드 형태를 갖추면 일반 클래스를 만들 수 있다.

- abstract를 상속받았을 때는 처음 null값이었지만, 자손의 인스턴스를 가리킬 수 있음으로

  인스턴스를 생성할 수 있다.

- 함수 포인터가 비어있는 채로 인스턴스를 생성할 수 없다. (가리키는 대상이 null 이면 안된다.)

  이때에는 abstract로 분류하여 인스턴스를 생성하지 못하게 해야 한다.

 

---

 

# abstract의 활용

 

abstract class Bank{ abstract double calc(double money, int years, double rate); public void print(){ double r = calc(100.0, 100, 0.066); System.out.println(r); } } class BokriBank extends Bank{ public double calc( double money, int years, double rate){ return 59665.1234; } } class DanriBank extends Bank { public double calc( double money, int years, double rate){ return 7600000; } private int subCalc(){return 0;} } public class Test037{ public static void main(String args[]){ Bank vk = new DanriBank(); vk.print(); } private int money() {return 100;} }

 

- 자주 안 변하는 부분은 abstract로 만든다.
- c에서 구조체와 비슷하지만 java에서는 클래스 단위로 재활용되기 때문에 사용
- c에서 함수포인터를 바꿨을 때 함수 안의 모든 메소드를 활용해야 하지만
  java 에서는 클래스의 인스턴스만 바꿔주면 선택적으로 메소드를 선택할 수 있다.

 

---

 

# interface의 특징

 

interface ICalc{ public void print(); } interface IUnKnown{} class Apple(){ } class Calc extends Apple implements ICalc, UnKnown{ public void print(){ System.out.println("A"); } } public class Test038{ public static void main(String args[]){ ICalc ic = new Calc(); ic.print(); } }

 

- 인터페이스에 선언된 method는 몽땅 abstract 해야 한다.
- 인터페이스를 상속해서 클래스를 선언할때는 implements를 이용해야 한다.
- 상속받은 클래스는 인터페이스에 선언된 메소드를 모두 오버라이딩 해야 한다.
- 인터페이스는 일종의 abstract 클래스이며 참조형 변수를 선언할 수 있고, 상속 당할 수 있다.
- 2개 이상의 인터페이스를 상속 받는 것 문제 없다.
- 동시에 클래스를 상속 받고, 인터페이스를 상속 받는 것도 가능하다.

 

 

# interface의 활용 - 객체화

 

 

interface IGreet{ public String greet(); } class MerciGreet implements IGreet{ public String greet(){ return "Merci"; } } class HelloGreet implements IGreet{ public String greet(){ return "Hello"; } } abstract class GreetDeco implements IGreet{ protected IGreet ig = null; GreetDeco( IGreet i ){ ig = i; } } // 자손의 생성자에서 조상의 생성자 중 매개변수 있는 생성자를 호출을 원하면 // super 함수를 이용해서 지정해줘야 한다. class SharpDeco extends GreetDeco{ SharpDeco ( IGreet i ){ super(i); } public String greet(){ return "#" + ig.greet() + "#";} } class StarDeco extends GreetDeco{ StarDeco ( IGreet i ){ super(i); } public String greet(){ return "*" + ig.greet() + "*";} } public class Test039{ public static void main(String args[]){ IGreet ig = new SharpDeco (new StarDeco(new StarDeco(new HelloGreet()))); System.out.println(ig.greet()); } }

 

 

- 오늘 과제

1) 나눠준 temp04.c 파일을 분석해서 java 와 비교해서 리포트 작성