JAVA의 정석 24일차 - 추상클래스, 인터페이스

2020.07.16(목)

 

1. 클래스의 종류

 1) 일반클래스(POJO) public class A extends B 

                                      기준     변경

    재사용

    public class A {

    B b = new B(); } 포함

    수정,추가 => 확장된 클래스

 

 2) 추상클래스 => 서로 다른 여러개의 클래스 모아서 관리

      public object class A =>단일상속

               미완성된 클래스 (설계품, 

 3) 인터페이스 (추상클래스의 일종) => 서로 다른 여러개의 클래스 모아서 관리

      public interface A =>다중상속

 

 4) 내부클래스

      (1) 멤버클래스

      (2) 지역클래스

      (3) 익명의클래스 => 상속없이 오버라이딩 사용이 가능

     

            class A extends B { (속도느려짐)

                public void display() 내용 변경

 

            class B(기존클래스) {

                public void display() {

                }

             }

 

       상속없이 재정의 => 익명

             class B {

               public void display()

             }

             class A {

               B b = new B() { //포함클래스로 바꿈

                public void display() //생성자 안에 블럭을 열고 재정의

               }

             }

 

 5) 종단클래스 final

 

2. 클래스의 종류

============

 = 추상 클래스

 = 인터페이스 => 추상클래스를 확장

                         여러개의 클래스를 모아서 관리 (서로 다른 클래스 연결해서 사용)

                        *** 결합성이 낮은 프로그램

                            =====

                              = 결합성 = 클래스를 수정하면 다른 클래스 영향

                              = 응집성 = 한개의 기능 수행할 수 있는 능력 (메소드)

                        *** 주로 사용 용도

                             1. 기능이 여러개로 나눠지는 경우

                             예) 버튼

                                ==== 로그인, 취소, 퍼즐, 시작, 종료

                             2. 여러개의 클래스를 한개의 클래스로 제어할 때

                        *** 인터페이스 단점 : 기능 설정 => 추가하면 모든 클래스가 error

                           => 인터페이스, 추상클래스를 사용 => 상속

                                반드시 구현이 안된 메소드는 구현해서 사용 public void aa() => public void aa(){}

                                                                                       빈괄호가 나와도 구현이 되었다고 컴퓨터가 인식함

예)

public interface A {
	public void aaa();
   	public void bbb();
}
    
class B implements A {

}

	추상클래스	인터페이스
상속	단일 상속	다중 상속
메소드	구현이 안된 메소드 구현이 된 메소드	구현이 안된 메소드만 가지고 있다
형식	public abstract class A {    public abstract void display();    public void aaa() {  } }	public interface B {    void display(); ==> public abstract void display();    void aaa();      ==> public abstract void aaa(); }
변수	public abstract class A {    private int a; }	public interface B {     int a; ==> error     === 인터페이스가 가지고 있는 변수 => 상수형변수            int a; ==> public final static int a; => 변수값을 지정            int a=10; }

============ 같은 역할

 = 내부클래스 => 멤버클래스

 = 내부클래스 => 익명클래스

 

3. 추상 클래스

   => 미완성된 클래스

   => new를 사용해서 메모리 할당이 불가능

    class A

      => A a = new A();

    abstract class B

      => B b = new B(); ==> error

    => 항상 상속을 내려서 하위 클래스에서

         구현한 다음에 사용

    => 기본 틀이 존재

    => 제시만 한다 : 구현하는 내용이 프로그램마다 다를 수도 있다

         예) 도형 

package com.sist.abs;
abstract class 도형 {
	public abstract void draw();
	public void color() {
		System.out.println("검정색으로 그림을 그린다");
	}
}
class 삼각형 extends 도형{

	@Override
	public void draw() {
		System.out.println("삼각형을 그린다");
	}
	// 정의 변경 => 재정의

	@Override
	public void color() {
		System.out.println("빨간색으로 그림을 그린다");
	}
}
class 원 extends 도형 {

	@Override
	public void draw() {
		System.out.println("원을 그린다");
	}
}
class 사각형 extends 도형 {

	@Override
	public void draw() {
		System.out.println("사각형을 그린다");
	}
}

public class MainClass {

	public static void main(String[] args) {
		도형 g = new 삼각형(); //구현하는 애 생성자명으로 둠
			g.color();
			g.draw();
			
			g = new 사각형();
			g.color();
			g.draw();
			
			g = new 원();
			g.color();
			g.draw();
	}
}

    예) 1. 게시판을 만들어라

         2. 게시판에는 글쓰기, 내용보기, 수정, 삭제, 찾기

    예) 영화관

        =====

             영화 목록

             예매

             영화 상세보기

             이벤트

             극장 설명

        =========== CGV 메가박스 롯데시네마

 

 * 게시판 
       => 답변형게시판 => 답변하기
       => 댓글형게시판 => 댓글달기
       => 갤러리게시판 => 업로드
       => 자료실          => 업로드 , 다운로드 
     ================= 추상클래스 , 인터페이스  
     글쓰기   ===================> 선언
     내용보기 
     ================= public abstract void
     수정 
     삭제     ===================> 동일 (구현)
     찾기
     ================= public void

package com.sist.abs;
abstract class Board{
	public abstract void write();
	public abstract void content();
	public void update() {
		System.out.println("게시물 수정");
	}
	public void delete() {
		System.out.println("게시물 삭제");
	}
	public void find() {
		System.out.println("게시물 찾기");
	}
	// 다른 기능 추가가 가능하다
	// Board가 갖고 있는 기능을 재정의 가능
}

//상속
class ReplyBoard extends Board{

	@Override
	public void write() {
		System.out.println("답변형 게시판 글쓰기");	
	}

	@Override
	public void content() {
		System.out.println("내용보기");
	}
	// 다른 기능 추가가 가능하다
	// Board가 갖고 있는 기능을 재정의 가능
}

class DataBoard extends Board{

	@Override
	public void write() {
		System.out.println("글쓰기+업로드");	
	}

	@Override
	public void content() {
		System.out.println("내용보기 + 다운로드");
	}
}

class GalleryBoard extends Board{

	@Override
	public void write() {
		System.out.println("글쓰기 + 이미지업로드");	
	}

	@Override
	public void content() {
		System.out.println("내용보기 + 이미지출력 =>후기게시판");	
	}
}

class ReplyBoard2 extends Board{

	@Override
	public void write() {
		System.out.println("글쓰기");	
	}

	@Override
	public void content() {
		System.out.println("내용보기 + 댓글");	
	}
}

public class MainClass2 {

	public static void main(String[] args) {
		System.out.println("===== 답변형 게시판 =====");
		Board b = new ReplyBoard(); //하나로 제어
		b.write();
		b.content();
		
		System.out.println("===== 갤러리 게시판 =====");
		b = new GalleryBoard();
		b.write();
		b.content();
		
		System.out.println("===== 자료실 =====");
		b = new DataBoard();
		b.write();
		b.content();
		
		System.out.println("===== 댓글 게시판 =====");
		b = new ReplyBoard2();
		b.write();
		b.content();
	}
}

 

 

4. 인터페이스

  => 추상클래스의 일종(추상클래스 단점을 보완)

  => 미완성된 클래스 => 자신이 메모리 할당을 할 수 없다(구현한 클래스를 통해서 메모리 할당)

  => 추상 클래스 (단일 상속), 인터페이스(자동 상속)

  => 모든 메소드가 abstract => 선언만 가능

   *** JDK 1.8 => default 메소드를 이용해서 메소드 구현이 가능

  => 변수 (추상클래스:멤버변수, 인터페이스:상수형변수)

        int a;  ==> int a=10;

  => interface A {

         // 변수

         int a = 10; =====> JVM (public static final int a =10)

 

         // 메소드

         void aaa(); =====> JVM (public abstract void aaa();) 밑줄은 생략된것

         int bbb();

       }

 

       interface A {

          (public abstract) void aaa();

       } =>구현

       class B implements A {

           public void aaa() { //오버라이딩 축소x 확대만 가능 public => public

 

           }

       }

 

* 오버라이딩

1) 상속관계

2) 메소드명이 동일

3) 매개변수 동일

4) 리턴형이 동일

5) 접근지정어 => 확대, 축소(X)

 public > protected > default > private

 

 *** 인터페이스에 선언된 모든 메소드는 public이다

      인터페이스에 선언된 모든 변수는 public이다(상수)

interface A {
    //private int a=10; => 오류
    //protected int a=10; => 오류
    //private void aaa(); => 오류
    //protected void aaa(); => 오류
    void aaa(); //=> default써도 public이 생략된 것
    }

 

인터페이스 상속

  (1) 인터페이스 ==> 인터페이스

           extends

  (2) 인터페이스 ==> 클래스

           implements

  (3) 클래스 ==> 인터페이스

           error (상속불가)

 

interface A

   K  L

interface B extends A

   P => K  L

class C implements B

   P

   K

   L 구현한다

 

==============================

interface A

interface B

class C implements A, B ==> 다중상속

==============================

interface A

class B

class C extends B implements A

인터페이스는 모든 메소드가 구현이 안된다

package com.sist.inter;
interface 동물{
	void eat();
	// 구현된 메소드를 제작 (JDK1.8~) => default
	default void run() {
		System.out.println("네발로 걷는다");
	}
}
class 소 implements 동물{
	public void eat() {
		System.out.println("소같이 먹는다");
	}
}
class 개 implements 동물{
	public void eat() {
		System.out.println("개같이 먹는다");
	}
}
class 사람 implements 동물{
	public void eat() {
		System.out.println("수저로 먹는다");
	}
	
	@Override
	public void run() {
		System.out.println("두발로 걷는다");
	}
}
class 돼지 implements 동물{

	@Override
	public void eat() {
		System.out.println("돼지같이 먹는다");
	}
	
}
public class MainClass {

	public static void main(String[] args) {
		동물 ani = new 소();
			ani.eat();
			ani = new 개();
			ani.eat();
			ani = new 돼지();
			ani.eat();
			
	}
}

 

자바에서 지원하는 인터페이스 (blog.naver.com/rain483/220736503899)

 1. Window (javax.swing)

    ActionListener : 버튼, 메뉴, text에서 엔터

      = actionPerformed()

    MouseListner : 마우스 관련, JTable, JTree, JLabel전체 해당

      = mouseClicked() 클릭

      = mouseReleased() 

      = mousePressed() 누른상태

      = mouseEntered() 

      = mouseExited() 

    MouseMotionListener : 마우스

      = mouseMoved()

      = mouseDragged()

    KeyListener : 키보드

      = keyPressed()

      = keyReleased()

      = keyTyped()

    FocusListener

      = foucseLost()

      = focuseGained()

    ItemListener

      = ComboBox, JList

      = itemStateChanged()

====================

 2. 데이터베이스 연결

      = Connection

      = Statement

      = ResultSet

====================

 

package com.sist.inter;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MainClass2 extends JFrame implements ActionListener,MouseListener,ItemListener{
	JButton b1;
	JTextField tf;
	JLabel la;
	JComboBox box;
	
	//초기화 => 메모리에 저장 (생성자)
	public MainClass2() {
		b1 = new JButton("클릭");
		tf = new JTextField("");
		la = new JLabel(new ImageIcon("c:\\javaDev\\air.png"));
		box = new JComboBox();
		box.addItem("홍길동");
		box.addItem("박문수");
		box.addItem("이순신");
		
		// JFrame => BorderLayout
		add("West",b1);
		add("Center",la);
		add("South",tf);
		add("North",box);
		// East, North 첫글자 대문자. 직접 배치하려면 사용자 정의 setBounds
		
		// 화면 크기
		setSize(450, 500);
		setVisible(true);
		
		//이벤트 등록
		//=> b1이라는 버튼을 클릭하면 => actionPerformed() 호출
		b1.addActionListener(this); // this => 자신 (MainClass)
		tf.addActionListener(this); // 만약 MyEvent라는 클래스에 따로 뺐으면
		la.addMouseListener(this);  // this대신 new MyEvent()를 넣어야함
	}
		
	public static void main(String[] args) {
		new MainClass2();

	}

	@Override
	public void mouseClicked(MouseEvent e) {
			if(e.getSource()==la) {
				if(e.getClickCount()==2) { //더블클릭
					JOptionPane.showMessageDialog(this, "상세보기로 이동");
				}
			}
	}

	@Override
	public void mousePressed(MouseEvent e) {		
	}

	@Override
	public void mouseReleased(MouseEvent e) {		
	}

	@Override
	public void mouseEntered(MouseEvent e) {		
	}

	@Override
	public void mouseExited(MouseEvent e) {		
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if(e.getSource()==b1) {
			JOptionPane.showMessageDialog(this, "버튼 클릭!!"); //this 대신 null로 넣으면 윈도우 말고 전체화면에서 뜸
		}
		else if(e.getSource()==tf) { //Enter
			String msg = tf.getText();
			JOptionPane.showMessageDialog(this, msg); //입력값
		}
	}
	
	@Override
	public void itemStateChanged(ItemEvent e) {
		if(e.getSource()==box){
			String name=(String)box.getSelectedItem(); //Object를 String으로 형변환
			JOptionPane.showMessageDialog(this, name);
		}
	}
}

 

Container

package com.sist.inter;
import java.util.*;
//인터페이스 => 여러개 클래스를 묶어서 인터페이스로 관리(서로 다른 클래스들에게 관계를 맺어준다)
interface Connection{
	public void connection();
	default public void aaa() {} //독립적인 프로그래밍 가능
}
class 오라클 implements Connection{
	public void connection() {
		System.out.println("오라클 연결");
	}
}
class DB2 implements Connection{
	public void connection() {
		System.out.println("DB2 연결");
	}
}
class MSSQL implements Connection{
	public void connection() {
		System.out.println("MSSQL 연결");
	}
}
class MySQL implements Connection{
	public void connection() {
		System.out.println("MySQL 연결");
	}
}

// 팩토리 패턴 => 스프링
public class Container {
	Map map = new HashMap();
	public Container() {
		map.put("oracle", new 오라클());
		map.put("db2", new DB2());
		map.put("mssql", new MSSQL());
		map.put("mysql", new MySQL());
	}
	public Connection getBean(String key) {
		return (Connection)map.get(key);
	}
}

package com.sist.inter;

public class MainClass3 {

	public static void main(String[] args) {
		Container c = new Container();
		Connection conn = c.getBean("oracle");
		conn.connection();
		
		conn=c.getBean("mssql");
		conn.connection();
	}
}

 

익명의 클래스

package com.sist.inter;
interface A {
	public void display();
}
public class MainClass4 {

	public static void main(String[] args) {
		// 익명의 클래스 => 인터페이스를 이용한 다형성 => 오버라이딩
		// class => implements 없이 인터페이스 구현할 수 있다
		A a = new A() { //new로 블럭을 열어서 메모리 저장가능. => 익명의 클래스 (implements 없이도 구현 가능)
			public void display() {
				System.out.println("A:displayCall...");
			}
		};
		a.display();
	}
}

 

package com.sist.inter;
import javax.swing.*;
import java.awt.*;
import javax.swing.table.*;
import java.awt.event.*;
 
public class MainClass5 extends JFrame{
	JTable table; //모양
	DefaultTableModel model; //테이블안에 있는 데이터 제어 => MV
	public MainClass5() {
		String[] col= {"", "이름", "성별", "주소"};
		String[][] row = new String[0][4];
		
		model = new DefaultTableModel(row,col) {

			@Override
			public boolean isCellEditable(int row, int column) {
				return false; //편집안되게 막음
			}

			@Override
			public Class<?> getColumnClass(int columnIndex) {
				return getValueAt(0, columnIndex).getClass();
			}
		};
		//table에 첨부
		table = new JTable(model);
		table.setRowHeight(45);
		JScrollPane js = new JScrollPane(table);
		
		//윈도우에 추가
		add("Center",js);
		setSize(350, 450);
		
		//데이터 추가
		Object[] data= {new ImageIcon(getImage(new ImageIcon("c:\\javaDev\\a.png"),30,30)),"홍길동","남자","서울"};
    	model.addRow(data);
    	model.addRow(data);
    	model.addRow(data);
    	setVisible(true);
    	
    }
    public Image getImage(ImageIcon ii,int w,int h)
    {
			    	Image dimg = ii.getImage().getScaledInstance(w, h,
			    	        Image.SCALE_SMOOTH);
			    	return dimg;
    }
	
	public static void main(String[] args) {
		//생성자 호출
		new MainClass5();
	}
}