AWT Window Event 처리 및 Anonymous 클래스 사용

/* 윈도우 창닫기 처리 방법
1> WindowListener 인터페이스를 상속받아 구현
2> WindowAdaper를 상속받아 이너클래스를 구현
3> Anonymous Class(이름없는 로컬 이너 클래스)로 구현(1회용)
   - 무명클래스, 무명안긴클래스...
*/
import java.awt.*;
import java.awt.event.*;

class  WinEvent3 extends Frame
{
		Button bt1, bt2;	
		public WinEvent3(){
			super("WinEvent3");
			setLayout(new FlowLayout());
			bt1 = new Button("Red");
			bt2 = new Button("Blue");
			add(bt1);
			add(bt2);
			// 실습문제 1) 각 버튼을 눌러 배경색이 바뀌게 이벤트 처리
			//  		단 Anonymous클래스로 이벤트 처리
			bt1.addActionListener(
				new ActionListener() {  
					public void actionPerformed(ActionEvent e) {
						setBackground(Color.red);
					}
				}
			);
			bt2.addActionListener(
				new ActionListener() {
					public void actionPerformed(ActionEvent e) {
						setBackground(Color.blue);
					}
				}	
			);

			//Anonymous Class로 이벤트 처리...
			addWindowListener(new WindowAdapter() { 
				public void windowClosing(WindowEvent e) {
					System.exit(0);
				}
			});
		}// 생성자----------
		public static void main(String[] args) 
		{
			WinEvent3 we=new WinEvent3();
			we.setSize(300,300);
			we.setVisible(true);
		}
}
/////////////////////////////////////////////////////////////////////////
interface MyInter
{
	int VAR =10;
	void print();
}//////////////////////////
public class  AnonymousTest
{
	public static void main(String[] args) 
	{
		// MyInter 객체를 생성하면서 이름없는 클래스를 구성해보자
		// print()메소드 안에서 "Hello Java"를 찍도록....
		MyInter mi = new MyInter() {
			public void print() {
				System.out.println("Hello Java");
			}
		};
		mi.print();
	}
}

■  로컬 이너 클래스는
    a) 이름있는 로컬 이너 클래스
    b) 이름없는 로컬 이너 클래스
       로 구분할 수 있는데, 로컬 클래스는 지역변수와 비슷한 성격을 가지며,
       활용범위가 정의되는 메소드 블럭 내부로 제한 된다. 
      로컬 클래스는 외부(Outer)클래스의 멤버변수와, 메소드의 final 로컬변수,
      그리고 final 매개변수 의 사용이 가능하다.
      (로컬 클래스가 메소드의  지역변수 값을 변화시키지 않기 위해서...) 

a) 이름있는 로컬 이너 클래스의 경우   
   - 우선 정의를 한 다음에만 사용할 수 있다.
   - 다른 클래스의 상속이 불가능하다.
   - 컴파일 하면 OuterClass$숫자+로컬클래스명의 클래스 파일이 생성된다.
      여기서 숫자는 인덱스를 의미하는데, 서로 다른 메소드인 경우 동일 명칭의 클래스가
      존재할 수 있기 때문에 중간에 인덱스 역할의 숫자를 붙여 구분되도록 한다. 

b) 이름없는 로컬 이너 클래스(Anonymous 클래스)   
    - 이름을 갖지 않는 이너 클래스
    - 한번만 객체 생성이 가능하다.
    - 객체를 생성하는 문장 뒤에 클래스의 블럭 을 덧붙이는 방법으로 구성
    - new 키워드 뒤 생성자의 명칭이 기존 클래스명일 경우에는
       Anonymous클래스가 자동적으로 클래스의 자식 클래스가 되며, 
       인터페이스일 경우에는 이 인터페이스를 상속하는 클래스로서, 부모 클래스가 Object이 된다.

AWT Window Event 처리 및 Adapter 사용

import java.awt.*;
import java.awt.event.*;

class WinEvent extends Frame implements WindowListener
{
	public WinEvent(){
		super("::WinEvent::");
		addWindowListener(this);
	}//생성자----------------------
	public void windowActivated(WindowEvent e) {}
	public void windowDeactivated(WindowEvent e) {}
	public void windowOpened(WindowEvent e) {}
	public void windowClosed(WindowEvent e) {}
	public void windowClosing(WindowEvent e) {
		System.exit(0);
	}
	public void windowIconified(WindowEvent e) {}  //최소화
	public void windowDeiconified(WindowEvent e){} //원래창 크기로

	public static void main(String[] args) 
	{
		WinEvent we=new WinEvent();
		we.setSize(300,300);
		we.setVisible(true);
	}
}
/////////////////////Adapter 사용시//////////////////////////////////////////////////////////////////////////////////////
import java.awt.*;
import java.awt.event.*;

class WinEvent2 extends Frame
{
	public WinEvent2(){
		super("::WinEvent2::");
		WinHandler w = new WinHandler();
		addWindowListener(w);
	}//생성자---------------
	//어댑터를 상속받으면 내가 필요한 추상메소드만 오버라이딩해서 사용하면 된다
	class WinHandler extends WindowAdapter
	{
		public void windowClosing(WindowEvent e) {
			System.exit(0);
		}

	}/////////////////////
	public static void main(String[] args) 
	{
		WinEvent2 we=new WinEvent2();
		we.setSize(300,300);
		we.setVisible(true);
	}
}///////////////////////////

AWT Popup Menu Action Event 처리

import java.awt.*;
import java.awt.event.*;
public class PopMenu extends Frame 
{
	PopupMenu pmn;
	MenuItem miOpen, miClose;

	public PopMenu() {
		super("::PopMenu::");
		pmn=new PopupMenu();
		add(pmn);  //팝업메뉴는 반드시 add()해줘야 한다
		pmn.add(miOpen=new MenuItem("열기"));
		pmn.addSeparator();
		pmn.add(miClose=new MenuItem("닫기"));


		MyHandler my = new MyHandler();
		//Frame에 마우스리스너 부착---
		addMouseListener(my);
	
	}////생성자-----------

	class MyHandler implements MouseListener
	{
		public void mouseClicked(MouseEvent e) {
			//x좌표, y좌표 타이틀에 올리기
			Point p = e.getPoint();
			// int x = p.x; int y= p.y;
			int x = e.getX();
			int y = e.getY();
			setTitle("x:" + x +"y:"+y);
			System.out.println(e.getButton());
			//if(e.getButton()==3)
			if(e.getButton()==MouseEvent.BUTTON3) {  //오른쪽 번튼이 눌렸을때만
			pmn.show(PopMenu.this,x,y);
			//show(Component origin, int x, int y)
			//팝업메뉴의 show()메소드를 호출해야 모양을 확인할 수 있다.
			}
		}
		public void mouseEntered(MouseEvent e) {
//			setBackground(Color.pink);
		}
		public void mouseExited(MouseEvent e) {
//			setBackground(Color.white);
		}
		public void mousePressed(MouseEvent e) {
//			setBackground(Color.yellow);
		}
		public void mouseReleased(MouseEvent e) {
//			setBackground(Color.cyan);
		}
	}//////////////////////////
	public static void main(String[] args) 
	{
		PopMenu pm=new PopMenu();
		pm.setSize(500,500);
		pm.setVisible(true);
	}
}

'Java > Awt_Swing' 카테고리의 다른 글

AWT Window Event 처리 및 Anonymous 클래스 사용  (0) 2011.12.01
AWT Window Event 처리 및 Adapter 사용  (0) 2011.12.01
AWT Menu Action Event 처리  (0) 2011.12.01
AWT TextField Action Event 처리(inputTest)  (0) 2011.12.01
Swing 예제  (0) 2011.11.29

AWT Menu Action Event 처리

import java.awt.*;
import java.awt.event.*;

public class MenuTest extends Frame 
{
	MenuBar mb;
	Menu file, color, sub_color;
	MenuItem miOpen, miSave, miExit, miYellow, miGray;
	Label lb;

	public MenuTest() {
		super("MenuTest");
		//1. 메뉴바 생성--------
		mb = new MenuBar();
		setMenuBar(mb);  //메뉴바를 프레임에 부착
		//2. 메뉴생성 및 부착
		file = new Menu("파일");
		mb.add(file);
		//3. 메뉴 아이템 생성 및 부착
		miOpen = new MenuItem("열기");
		MenuShortcut ms = new MenuShortcut('S');  //단축키
		miSave = new MenuItem("저장", ms);
		miExit = new MenuItem("종료", new MenuShortcut('X', true));  //true=> shift키와 함께 사용

		file.add(miOpen);
		file.add(miSave);
		file.addSeparator();   // 메뉴 아이템에 분리선 주기...
		file.add(miExit);
		// 리스너 부착
		MyHandler my = new MyHandler();
		miOpen.addActionListener(my);
		miSave.addActionListener(my);
		miExit.addActionListener(my);

		color = new Menu("색상");
		mb.add(color);
		miYellow = new MenuItem("노 랑");
		miGray = new MenuItem("회 색");
		color.add(miYellow);
		color.add(miGray);
		color.addSeparator();
		
		sub_color = new Menu("글자색");
		color.add(sub_color);
		sub_color.add("빨강");
		sub_color.add("파랑");

		lb=new Label("안녕하세요?", Label.CENTER);
		add(lb, "South");
		// 색상 메뉴 관련 리스너 부착
		miYellow.addActionListener(my);
		miGray.addActionListener(my);
		sub_color.addActionListener(my);
	}// 생성자-----

	class MyHandler implements ActionListener
	{
		Color bgCr = Color.white;
		Color fntCr = Color.black;
		public void actionPerformed(ActionEvent e)  {
			Object obj = e.getSource();
			String cmd = e.getActionCommand();
			if(obj==miOpen){
				//파일 대화상자 열기
				// 1>FileDialog 객체 생성해서 FileDialog(Frame parent)
				// FileDialog fd = new FileDialog(fr=new Frame()); 
				// 새로운 프레임을 생성하면 안되고, MenuTest프레임과 연동되어야 한다==> MenuTest.this
				FileDialog fd = new FileDialog(MenuTest.this);
				fd.setVisible(true);

				// 내가 선택한 파일명을 프레임 타이틀에 나오게....
				String dir= fd.getDirectory();  //디렉토리 얻어오기
				String filename = fd.getFile(); //파일명 얻어오기
				setTitle(dir+filename);

			}else if(obj==miSave){
				FileDialog fd = new FileDialog(MenuTest.this, "저장", FileDialog.SAVE);  //저장모드
				fd.setVisible(true);
			}else if(obj==miExit){
				System.exit(0);
			}else if(obj==miYellow) 
			{
				bgCr=Color.yellow;
			}else if(obj==miGray){
				bgCr=Color.gray;
			}
			if(cmd.equals("빨강")) {
				fntCr=Color.red;
			}else if (cmd.equals("파랑")){
				fntCr=Color.blue;
			}
			lb.setForeground(fntCr);
			setBackground(bgCr);
			lb.setBackground(bgCr);

		}
	}//////////////////////

	public static void main(String[] args) 
	{
		MenuTest mt= new MenuTest();
		mt.setSize(400,400);
		mt.setVisible(true);
	}
}


AWT TextField Action Event 처리(inputTest)

import java.awt.*;
import java.awt.event.*;//1>

public class InputTest extends Frame
implements ActionListener//2>
{

	Label lb;
	TextField tf;
	Button btOk;
	TextArea ta;
	public InputTest(){
		super("::InputTest::");
		Panel p1=new Panel();
		add(p1,"North");
		p1.setBackground(Color.blue);
		ta=new TextArea();
		add(ta,"Center");

		lb=new Label("입력", Label.CENTER);
		tf=new TextField(20);
		btOk=new Button("O K");
		p1.setLayout(new BorderLayout());
		p1.add(lb,"West");
		p1.add(tf,"Center");
		p1.add(btOk,"East");

		//리스너 부착--
		tf.addActionListener(this);//4>
		btOk.addActionListener(this);

	}//생성자-------
	public void actionPerformed(ActionEvent e){//3>
		//5>
		Object obj=e.getSource();
		if(obj==tf|| obj==btOk){
			setTitle("^^^");
	//1) tf에 입력한 값을 얻어온다...String getText()
	//2) 1)번에서 얻어온 값을 int로 변환해본다.
	//3)  제대로 변환이 된다면 ta에 그 값을 붙인다.
	//4)  변환이 안되고 예외가 발생한다면 그 예외를 잡아 처리한다.
			String str=tf.getText();  //1)
			int n=0;
			try{                     //4)
				str=str.trim();// 문자열 앞 뒤에 여백(공백)이 있다면 이를 제거해준다.
			n=Integer.parseInt(str);   //2) 문자열을 정수로 변환
			}catch(NumberFormatException ex){
					ta.append("정수를 입력해야 합니다.\n");
					return;            //밑에문장 수행 안하게
			}
			ta.append(n+"\n");    //3)textarea에 붙여준다// 정수를 스트링으로 변환하는 간단한 방법 ""를 붙여준다
			tf.setText("");//텍스트필드 내용을 지워줌

	

		}
	}//---------------


	public static void main(String[] args) 
	{
		InputTest it=new InputTest();
		it.setSize(300,300);
		it.setVisible(true);
	}
}  

'Java > Awt_Swing' 카테고리의 다른 글

AWT Window Event 처리 및 Anonymous 클래스 사용  (0) 2011.12.01
AWT Window Event 처리 및 Adapter 사용  (0) 2011.12.01
AWT Popup Menu Action Event 처리  (0) 2011.12.01
AWT Menu Action Event 처리  (0) 2011.12.01
Swing 예제  (0) 2011.11.29

예외 처리(Exception)

// 예외 처리(에러 처리)
public class ExceptionHandlingDemo {
	public static void main(String[] args) {
		
	int i = 3;
	int j = 0;
	int r = 0;
		
	//r = 3 / 0;  //[1] 문법적인 오류가 발생 => 컴파일 에러 => Java 인터프리터가 알아서 발생
	//r = i / j; //[2] 런타임 에러 => 컴파일되고, 실행시점에 에러가 발생 => 테스트 많이  	
	// 고객이 원하는 것 : i - j인데, 개발자 실수로 i + j => [3] 논리 에러 : 많은 프로그래밍 경험
	//r = i + j;
	
	// 예외 처리 구문 : try~catch~finally절
	try
	{
		// 인위적으로 예외를 발생하려면???
		//throw new Exception("아무 예외 발생");
		throw new ArithmeticException();  //해당 예외처리로 던져준다
//		r = i / j; 
//		System.out.println(r);
	}
	catch (ArithmeticException ae)
	{
		System.out.println("0으로 나눌 수 없습니다.");
	}
	catch (Exception e)
	{			
		System.out.println("에러가 발생함... : " + e);
		//System.exit(1); // <= 여기 시점에서 프로그램 종료, 0이면 정상종료, 1이면 비정상종료
	}		
	finally   //무조건 실행
	{
		System.out.println("프로그램을 종료합니다.");
	}
		
	}
}

'Java' 카테고리의 다른 글

String 클래스의 주요 메서드 정리  (0) 2011.11.30
객체지향 프로그래밍(Object Oriented Programming)  (0) 2011.11.30
다형성(Polymorphism)  (0) 2011.11.30
인터페이스(Interface)  (0) 2011.11.30
추상(Abstract) 클래스  (0) 2011.11.30

InputStream과 OutputStream

import java.io.*;

class InputStreamTest3 
{
	public static void main(String[] args) throws IOException
	{
		int r=0, count=0;
		while((r=System.in.read()) != -1)  {
			if( r!= 10 && r!= 13) {   //엔터키는 제외
			// System.out.println("r: " +((char)r));
			System.out.write(r);
			System.out.flush();
			count++;
			}
		}//while----------------
		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~");
		System.out.println("총 "+count+ "바이트 읽음");
		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~");
		System.in.close();
		System.out.close();
	}//main()-----------
}////////////////////////////////////////////////////////////////////////////////////////////
import java.io.*;

class InputStreamTest4 
{
	public static void main(String[] args) throws IOException
	{
		int r=0, count=0, total=0;
		byte[] ba=new byte[4]; //달걀판
		while((r=System.in.read(ba)) != -1)  {
			//r은 달걀갯수
			System.out.write(ba, 0 , r);
			count++; //반복문 횟수
			total += r;
		}//while-----
		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~");
		System.out.println("총 "+total+ "바이트 읽음");
		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~");
		System.in.close();
		System.out.close();
	}
}

'Java > I_O' 카테고리의 다른 글

File class(dir 출력)  (0) 2011.12.10
File class  (0) 2011.12.10
DataInputStream, DataOutputStream  (0) 2011.12.10
File Input/Output Stream  (0) 2011.12.09
File Input Stream  (0) 2011.12.09

String 클래스의 주요 메서드 정리

// String 클래스의 주요 메서드 정리
public class StringDemo {

	public static void main(String[] args) {
		String str = new String(" Abc DeF Fed Cba ");
	//  String str = " ABC DEF Fed Cba ";
		System.out.println(str); // 전체출력
		System.out.println(str.length()); // 문자열의 길이 출력
		System.out.println(str.charAt(5)); // 특정인덱스에 해당하는 문자 검색 : D
		System.out.println(str.indexOf("Fed")); // 특정문자열이 몇번째 인덱스에 위치하는지?? :9
		System.out.println(str.indexOf("e")); // index는 앞에서 부터 검색  :6
		System.out.println(str.lastIndexOf("e")); // lastIndex는 뒤에서 부터 검색 : 10
		System.out.println(str.indexOf("e", 7)); // 7번째 이후 부터 검색 : 10
		System.out.println(str.trim().length()); // 공백제거 출력(앞뒤 공백) :17-2=15
		System.out.println(str.replace(" ","").replace("Abc","aBC")); 
		// 특정문자 치환, 가운데 공백(white space) 제거 후 Abc->aBC
		System.out.println(str.substring(5, 8)); // n번째 ~ m번째 인덱스까지의 문자열 검색
		System.out.println(str.substring(5)); // n번째 이후 인덱스까지의 문자열 검색
		char[] buff = new char[3];
		str.getChars(5, 8, buff, 0 ); //buff ="Def";
		System.out.println(buff);
		
		//문자열 비교
		String s1 = "Test";
		String s2 = "test";
		System.out.println(s1 == s2); //false
		System.out.println(s1.equalsIgnoreCase(s2)); //대소문자 구분하지 않고 비교
		
		String url = "http://www.javacampus.com";
		System.out.println(url.startsWith("http")); //~시작하는지 :true
		System.out.println(url.endsWith(".net")); //~ 끝나는지 :false
		
		int year = 2011;
		System.out.println(year + year);
		System.out.println(String.valueOf(year) + String.valueOf(year));
		// 성질 자체를 문자열로 변환
		
		System.out.println("abce".toUpperCase()); //대문자로 출력
		System.out.println("abce".toLowerCase()); //소문자로 출력
	}
}

'Java' 카테고리의 다른 글

예외 처리(Exception)  (0) 2011.11.30
객체지향 프로그래밍(Object Oriented Programming)  (0) 2011.11.30
다형성(Polymorphism)  (0) 2011.11.30
인터페이스(Interface)  (0) 2011.11.30
추상(Abstract) 클래스  (0) 2011.11.30

객체지향 프로그래밍(Object Oriented Programming)

<< Object Oriented Programming-OOP >> 

절차지향 프로그래밍, 구조적 프로그래밍
        ex) C 프로그래밍
     - 일을 처리하는 순서와 과정을 프로그래밍으로 구현
     - Procedure, Process 를 중시함
     - 순서, 과정이 달라지면 새로운 작업 모델이 필요함
     - 재사용성이 불가능
  반면...
 OOP(객체지향 프로그래밍)는
 - 프로세스 중심이 아닌 객체 중심으로 프로그래밍 하는 것.
 - 재사용성이 뛰어남. 모듈화. 확장성..

□ Object Oriented Programming
      : 인간의 현실세계를 프로그램에 반영한 것.
         즉, 현실세계에 존재하는 객체(object-물건, 물체)를 프로그램에 반영한 것.

   1) Object : 물건, 물체를 의미,  유 무형의 물체
       ex) 자전거, 컴퓨터, 책상, 집, 정치, 윤리, 사회, 공기 ....

   2) 이러한  객체-object의 특징으로는
       속성(attribute)과 행위(behavior)를 갖는다는 것.
        ...따라서 프로그램에 객체를 반영할 때는 먼저  속성과 행위를 뽑아내는 과정이 필요
           -> 이를 객체 모델링이라 한다.

 OOP의 주요 특징
  1) 추상화-Abstraction
 
2) 은닉화-Encapsulation(캡슐화)
  3) 다형성-Polymorphism
  4) 상속성-Inheritance

1) 추상화(Abstraction)란?
   ...어떤 물체(object)에서 주된 특징을 부각시켜 표현하고, 나머지 부분은 과감하게 생략하는 것

   OOP에서 사용되는 추상화도 이와 비슷하다.
   한 물체를 대표하는 속성(명사)과 기능(동사)를 추출해내는 것을 프로그래밍에서는 추상화라고 한다.
   ex) 집을 프로그래밍으로 추상화해보면...
        House
           |-속성(attribute): 방수, 주인이름, 지붕색...
           +-행위(behavior) : 세를 놓다. 수리하다. 청소하다. 사다. 팔다....
       위의 속성은 멤버변수로... 
              행위 또는 기능은 메소드로 표현한다.

 위의 집이란 객체를 자바 프로그램에 추상화해보면

 class House
 {  //...속성...멤버변수: "has a" 관계를 갖는다.
      int room;
      String ownerName;
      String addr;

      public void existAt(String addr){ 
           System.out.println(addr+"에 위치하다");
      }
 }
 class HouseTest   {
      public static void main(String args[]) {
           House h=new House();
           h.existAt("300번지");

           House h2=new House();
           h2.existAt("100번지");
     }
 }////////////////////////////

2) 은닉화(Encapsulation)
   - Data를 캡슐화하되
   - Data에 접근할 때는 메소드로 접근하도록 한다.

  ○ 캡슐화 방법
    ㄱ) 멤버 변수 앞에 private 접근 지정자를 붙인다.
 private 지정자는 자기 클래스에서만 접근 가능한 접근지정자이다.(access modifier);
        ex) private String name;

    ㄴ) 멤버 변수에 값을 할당하고 값을 꺼내올 수 있는 메소드를 만든다.
 - setter/getter메소드.
 - 메소드의 접근 지정자는 public으로 주고
 - setter 메소드들은 반환타입은 없되, 매개변수를 받아들이도록
 - setter 메소드의 역할은 매개변수의 값을 멤버변수에 할당하는 일.
   ex) public void setName(String n) {
    name=n;
       }
 - getter메소드들은 반환타입이 있되 매개변수는 받아들이지 않는다.
 - getter메소드의 역할:  멤버변수 값을 반환해주는 일
    ex) public String getName() {
    return name;
        }
3) 다형성(Polymorphism)

○  오버로딩(Overloading) - 다중정의, 중복정의
○  오버라이딩(Overriding) - 재정의

□  오버로딩(Overloading) - 다중정의, 중복정의
   (기존방식-절차중심)
 밀크커피-  void getMilkCoffee (int cf, int s, int cr)
 블랙커피-  void getBlackCoffee (int cf)
 프림커피-  void getCreamCoffee (int cf, int cr)
  (OOP방식 - 오버로딩)
        void   getTea (int cf, int su, int cr) - 밀크커피
 String getTea (int cf)                - 블랙커피 [o, 반환타입은 신경안씀]
 void   getTea (int cf, int cr)         - 프림커피
 void   getTea (int cf, int sugar)      - 설탕커피[x, 프림커피와 중복됨]
        void   getTea (Yuja y)                - ○, 블랙커피와 데이터형이 다름

        ==> 오버로딩(중복정의,다중정의)
            : 메소드 이름을 동일하게 주되,
              매개변수의 데이터 타입과 갯수, 순서를 다르게 주어 구성하는 것.

    ***오버로딩의 조건***
     1) 오버로딩하려는 메소드 이름이 같아야 한다.
     2) 메소드의 매개변수의 데이터타입이 다르거나, 갯수가 다르거나 순서가 달라야 한다.
     3) 메소드의 반환타입은 신경 안써도 된다 (같아도 되고 달라도 됨)

□ 오버로딩의 종류
    i) 생성자 오버로딩
    ii) 메소드 오버로딩

I ) 생성자 오버로딩
  ○ 생성자란?
     : 객체가 생성될 때 최초로 실행되는 메소드를 의미.
  ○ 생성자 구성시 유의할 점
  a) 생성자 이름은 클래스명과 동일하게
  b) 반환타입을 가져선 안된다.
  c) 생성자의 접근지정자로는 public, protected, 생략형,private 모두 가능하나,
     대부분 public속성을 많이 준다.
     cf) Math 클래스의 경우 생성자에 private 지정자를 두고 있다.

  ○ 생성자의 주요 역할  :  멤버 변수를 초기화 하는 일
  ○ 사용자가 생성자를 구현하지 않았을 경우
     -->컴파일러는 default 생성자를 제공해줌

※ 그러나 사용자가 생성자를 하나라도 구현했다면, 그 때는 컴파일러가 제공 해주는 기본 생성자는 사라진다.
  - 자바에서는 생성자를 다양하게 오버로딩 함으로써 다양한 초기값을 부여하고 있다.

 ○ 생성자 안에서 this()의 사용
    - this()는 자기 자신의 생성자를 호출하는 메소드
    - 한 클래스 안에 여러 개의 생성자가  오버로딩된 형태로 존재하고,
      그 기능이 유사할 때, this라는 키워드를 이용해서 자기 자신의 다른 생성자를  호출할 수 있다.

    - 이 때 주의할 점...
     ㄱ) this()는 생성자 안에서만 호출해야 한다.
     ㄴ) this()를 호출할 때는 반드시 생성자의 첫 번째 문장이어야 한다.
     ㄷ) 또한 생성자 안에서 this()와 super()를 함께 쓸 수 없다.

 ※ this 의 사용(정리)******************************
 1) this.변수 : 자기 클래스의 멤버변수(인스턴스 변수)를 접근할 때 사용
 2) this.메소드: 자기 클래스의 멤버 메소드를  접근할 때 사용
 3) this() : 자기 자신의 생성자 호출 시 사용

 *** this 라는 키워드는 static 메소드 안에서는 사용할 수 없다.

**************************************************
□ 오버라이딩(Overriding)
    ...상속 개념과 맞물려 사용 부모로부터 상속 받은 메소드를 재정의해서 사용하는 것
      : 재정의
   **오버라이딩 조건******************
     - 오버라이드 하려는 메소드가 부모 클래스에 존재해야 한다.
     - 메소드 이름이 동일해야 한다.
     - 메소드의 매개변수 갯수, 데이터타입이 같아야 한다.
     - 메소드의 반환타입도 같아야 한다.
     - 메소드의 접근 지정자는 부모클래스와 동일하거나, 접근 범위가 넓어야 한다.
     - Exception의 경우 부모 클래스의 메소드와 동일하거나 더 구체적인 Exception을
       발생시켜야 한다.

4) 상속성(Inheritance)
  : 기존 클래스에 작은 기능이나 특성을 추가하여 새로운 클래스로 만드는 것을 의미.
    즉 부모클래스를 만들고, 그 부모클래스에 있는 속성과 기능을 자식클래스에서 상속받아,
    새로운 기능과 속성을 추가하는 것.

 -상속 개념을 적용함으로써 개발시간 단축,  재사용성 등에 놀라운 장점이 있다.


-------------+  +--------------+                                  
Person       |      |Student    |
-------------+ <----+--------------+
-name: String|  | - subject    |
-age : int   |  |   : String   |
-------------+  +--------------+
 |
 |
-------------+     상속관계는 "is a" 관계가
Staff        |  성립할 때 맺을 수 있다.
-------------+      ex) Student is a Person
-dept: String|   Staff is a Person
             |   Teacher is a Person
-------------+

**자바에서 상속을 받을 때는 extends 란 키워드를 사용한다.
  자바는 단일 상속 개념이므로 extends 로 상속 받을 수 있는 클래스는 단 하나뿐이다.
/////////////////////////////////////////////
※ super 의 사용(정리)*****************************
   1) super.변수 : 부모클래스로부터 물려받은 변수
   2) super.메소드:   "              "      메소드
   3) super() : 부모클래스의 생성자
 ..super()역시 생성자 안에서만 호출 가능하며, 생성자의 맨 첫줄에 위치 해야 한다.
         super 라는 키워드도 static 메소드 안에서 사용 불가.
         super() 는 부모클래스에 생성자가 오버로딩된 형태로 여러 개 존재할 때 그 중에서
         어떤 생성자를 호출할 지 결정할 수 있다.

 **그러나 super()생성자를 사용자가 명시적으로 호출하지 않는다면, 컴파일러는 자식클래스
   생성자에서 super()의 디폴트 생성자를 자동으로 호출한다.
   ----------------------------------------
  ex)
   class Parent   {
        String name;
       public Parent(String n) {
           name=n;
       }//인자 생성자----
   }//////////////////
   class Son extends Parent  {
       public Son()  {
            super("아무개");  //만일 이 문장이 없다면 에러발생
       }//---------        //컴파일러가 super()를 자동호출 하므로...
    }////////////////////

**************************************************
[실습문제]
좌표를 나타내는 MyPoint클래스를 설계해보자.
   1. 클래스이름: MyPoint
   2. 멤버변수: x, y좌표를 기억시킬 변수
   3. 2의 멤버변수를 캡슐화한다.
   4. 캡슐화한 변수에 접근할 set/get계열 메소드를 구성한다.
   5. MyPoint클래스의 생성자를 구성한다.
      ...3가지 형태로 오버로딩해보자.
   6. this()를 이용해서 멤버변수 값을 초기화하자.
   7. 메소드 구성:
      1) MyPoint클래스의 x, y좌표값을 증가 감소시켜주는 메소드
      2) x와 y값이 같은지를 비교하는 메소드를 구성해보자.
   8. main()메소드를 갖는 PointTest클래스를 만들어
      MyPoint객체 생성해 자기가 구성한 메소드를 호출해보자.
/////////////////////////////////////////////

'Java' 카테고리의 다른 글

예외 처리(Exception)  (0) 2011.11.30
String 클래스의 주요 메서드 정리  (0) 2011.11.30
다형성(Polymorphism)  (0) 2011.11.30
인터페이스(Interface)  (0) 2011.11.30
추상(Abstract) 클래스  (0) 2011.11.30

다형성(Polymorphism)

abstract class Animal { //동물 클래스 : base class
	abstract String cry();  // 동물들은 "울다"라는 기능을 정의
}
class Dog extends Animal {
	public String cry() {
		return "멍멍멍";
	}
}
class Crow extends Animal {
	public String cry() {
		return "까악까악";
	}
}
class Trainer  {
	public void doCry(Animal animal) {
		//뭐가실행 ??  => 컴파일 타임? 몰라요,  런타임:넘겨온 매개변수
		System.out.println(animal.cry());//다형성 : dynamic  
	}
}

//다형성 
public class PolymorphismDemo {
	public static void main(String[] args) {
		Dog     dog = new Dog();  System.out.println(dog.cry());
		Crow   crow = new Crow(); System.out.println(crow.cry());
		
		Animal ani1 = new Dog();  System.out.println(ani1.cry()); //멍멍멍
		Animal ani2 = new Crow(); System.out.println(ani2.cry()); //까악까악
		// 동일한 cry 메서드이지만, 넘겨준 메시지에 따라서 서로 다른 유형의 기능을 구현
		// 다형성은 메서드 오버라이드(override;재정의)를 통해서 구현
		Trainer tra1 =new Trainer(); 
		tra1.doCry(new Dog());  // 멍멍머
		tra1.doCry(new Crow()); // 까악까악
	}
}

◀ PREV 123456 NEXT ▶