day 0523 컬렉션

// 클래스 : 인터페이스를 구현하는 클래스를 만들 때는 implements
interface A{
}

// B가 인터페이스를 구현한다 
class B implements A{
}

// 인터페이스끼리 상속가능 : 인터페이스를 상속받은 인터페이스를 만들 때는 extends
interface A{
}
interface B extends A{
}


// 인터페이스끼리 다중상속 가능
interface A{
}
interface B{
}
interface C extends A,B{
}

 

1) 변수명 앞에 final

    변수의 형태를 띄지만 상수로 사용하고자 할 때 사용한다

 

2) 메소드명 앞에 final

    일반적으로 상속관계에 있을 때 자식클래스는 부모의 메소드를 필요로한다면 오버라이딩 할 수 있어요

    그런데 만약, 부모클래스를 만들 때 미래에 만들어지는 후손들이 어떠한 메소드를

    오버라이딩 하지 않도록 하기 위한 방법입니다

    미래에 만들어질 후손들이 가져야할 공통적인 속성과 동작을 뽑아서 일반화(부모클래스를 만들 때)를 할 때에

    특정메소드는 의미상 완전하여 더이상 후손들이 동작방식을 변경시키지 않도록 하기 위함 입니다

 

3) 클래스명 앞에final ==> 상속금지

    일반적으로 클래스의 세상에서는 얼마든지 이미 있는 클래스를 확장하여 새로운 클래스를 만들 수 있어요

    그런데 만약 어떠한 클래스는 의미상 완전하여 더이상 이 클래스를 확장하여 새로운 속성이나 동작을

    추가하지 않도록 하려면 final 클래스로 만들어서 상속을 금지시킵니다

package com.kosta.exam01;

class A {
	public void pro() {
		System.out.println("A 클래스의 pro입니다.");
	}
	//  메소드명 앞에 final
	public final void test() {
		System.out.println("테스트 입니다.");
	}
}

class B extends A{
	public void pro() {
		System.out.println("B 클래스의 pro입니다.");
	}
	
	public void test() {
		// 부모 클래스의 final 메소드는 오버라이딩 할 수 없다
	}
}

public class FinalTest {
	public static void main(String[] args) {
		B ob = new B();
		ob.pro();		
	}
}

package com.kosta.exam02;

// 클래스명 앞에 final
final class Person{
	String name;
	int age;
	public void sayHello() {
		System.out.println("hello," + name);
	}
}

class Student extends Person{
	String major;
	public void study() {
		System.out.println("study" + major);
	}
}

public class FinalTest {
	public static void main(String[] args) {
		
	}
}

 

자바의 컬렉션 프레임워크(동적인 배열)

: 배열은 자료형이 같은 기억장소의 모임이며 많은양의 데이터를 처리하기에 적합합니다

  그러나 배열에는 자료형이 같아야하고 또, 배열의 크기를 미리 정해야 하므로 

  용량이 부족하거나 혹은 낭비가 되는 경우가 있어요

  그리고 배열의 중간에 데이터를 추가하거나 삭제할 때 상당히 번거로운 작업이 됩니다

 

  그래서 자바에서는 이러한 배열의 단점을 보완하기 위하여

  동적인 배열 즉 컬렉션 프레임워크를 만들어 두었습니다

 

<< 컬렉션 프레임워크의 종류 (동적인 배열) >>

 

1) Set  :  데이터의 중복을 허용하지 않아요

    - HashSet  :  입력한 순서를 유지하지 않아요

    - LinkedHashSet  :  입력한 순서를 유지합니다

    - TreeSet  :  데이터를 정렬 해 줍니다 (단, 자료형이 같아야 합니다)

 

2) List  :  데이터의 중복을 허용합니다

    - ArrayList  :  자바의 컬렉션중에서 가장 많이 사용합니다

    - LinkedList  :  데이터 중간에 추가 삭제가 빈번한 경우에 사용하면 ArrayList보다 더 효율적입니다

 

3) Map :  key,value가 한 쌍으로 이루어진 자료구조

               (인덱스 대신에 key에 의해 데이터에 접근하는 방식)

               ==> 사전 자료형

 

Interface Set<E>

     +

extends

     +

All Superinterfaces:Collection<E>, Iterable<E>

interface Set extends Collection, Iterable{
}

 

All Known Subinterfaces:NavigableSet<E>, SortedSet<E>

interface NavigableSet extends Set{
}
interface SortedSet extends Set{
}

All Known Implementing Classes:AbstractSet, ConcurrentHashMap.KeySetView, ConcurrentSkipListSet, CopyOnWriteArraySet, EnumSet, HashSet, JobStateReasons, LinkedHashSet, TreeSet

class HashSet implements Set{
}
class LinkedHashSet implements Set{
}
class TreeSet implements Set{
}

 

add(Object e) : boolean - 중복이 아니면 true, 중복이면 false

Object : 객체만 사용 가능하다(요즘은 auto boxing 해준다)

 

/HashSet/

package com.kosta.exam03;

import java.util.HashSet;
import java.util.Set;

public class HashSetTest {

	public static void main(String[] args) {

		// 데이터 타입이 Set, HashSet 이어도 된다
		Set data = new HashSet();
		
		// 이제는 안해도 된다
		// data.add(new  Integer(100)); 
		
		// 자동으로 만들어준다 auto Boxing
		boolean f1 = data.add(100); 
		boolean f2 = data.add("사과");
		boolean f3 = data.add(52.2);
		data.add(true);
		// 중복이라 안된다
		boolean f4 = data.add(100);  
		
		// 순서 랜덤, 중복만 처리한다
		System.out.println(data);
		System.out.println(f1);
		System.out.println(f2);
		System.out.println(f3);
		System.out.println(f4);
	}
}

 

/LinkedHashSet/

package com.kosta.exam03;

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetTest {

	public static void main(String[] args) {
		// LHS + ctrl + space
		// 입력한 순서를 유지한다
		Set data = new LinkedHashSet();
		
		data.add("된장찌개");
		data.add("백반");
		data.add("짬뽕");
		boolean f1 = data.add("김치찌개");
		boolean f2 = data.add("짬뽕"); // 중복은 허용하지 않는다
		System.out.println(data);
		System.out.println(f1);
		System.out.println(f2); // 중복 false		
	}
}

 

/treeSet/

package com.kosta.exam03;

import java.util.Set;
import java.util.TreeSet;

public class treeSetTest {

	public static void main(String[] args) {
		// 데이터 순서를 정렬해준다
		Set data = new TreeSet();
		
		data.add("된장찌개");
		data.add("백반");
		data.add("짬뽕");
		boolean f1 = data.add("김치찌개");
		boolean f2 = data.add("짬뽕"); // 중복은 허용하지 않는다
		System.out.println(data);
		System.out.println(f1);
		System.out.println(f2); // 중복 false		
		
		// size() 데이터가 몇 개 담겨있는지 알려준다
		System.out.println(data.size());
	}
}

 

class Random() 난수 : 임의의 값, 임의의 수

nextBoolean() : boolean 중에 무작위

nextInt() : int범위 내에서 무작위

// 메소드 중복 : 매개변수가 다르다

nextInt(int bound)

package com.kosta.exam03;

import java.util.Random;

public class RandomTest {

	public static void main(String[] args) {
		Random r = new Random();
		// int 범위 내에서 무작위 
		int data = r.nextInt();
		// -29964478
		// 1225077449 등..
		System.out.println(data);
		
		// bound 안에서 난수 발생, 0 ~ 10-1 사이에서 무작위
		int data2 = r.nextInt(10);
		// 3, 4, 7 등.. 
		System.out.println(data2);
		
		// 만약 1 ~ 10까지 발생해야 한다면
		int data3 = r.nextInt(10) +1;
		System.out.println(data3);
	}
}

 

[11, 16, 17, 27, 30, 36]

package com.kosta.exam03;

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class LottoTest {

	public static void main(String[] args) {
		// 이번주에 구입 할 로또번호를 생성 해 주세요
		// 1 ~ 45까지의 숫자를 중복이 되지않게 6개 필요
		Random r = new Random();
		Set data = new TreeSet();
		
		// i < 6을 사용하면 for문을 계속 돈다
		for(int i = 1;  ; i++) { // while(true) { 로 사용 가능하다
			int n = r.nextInt(45)+1;
			data.add(n);
				if(data.size() >= 6) {
					break;
				}
		}
		System.out.println(data);
	}
}

package com.kosta.exam03;

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class LottoTest3 {

	public static void main(String[] args) {
		Random r = new Random();
		Set data = new TreeSet();
		
		// while문
		while(data.size() < 6) {
			int n = r.nextInt(45)+1;
			data.add(n);
		}
		System.out.println(data);
	}
}

이번주 로또를 사야겠ㄷㅏ ㅎㅎㅎㅎㅎ

 

package com.kosta.exam03;

import java.util.Random;

public class RandomTest2 {

	public static void main(String[] args) {
		// 1 ~ 10 사이의 난수 만들기
		
		System.out.println("방법1 ==>");
		Random r1 = new Random();
		int data1 = r1.nextInt(10)+1;
		System.out.println(data1);
		
		System.out.println("방법2 ==>");
		Random r2 = new Random();
		int data2 = r2.nextInt();
		if(data2 < 0) {
			data2 = data2 * -1; // 양수 만들기
		}
		// data%10 : 0 ~ 9사이의값, + 1 : 1 ~ 10 사이의 값
		data2 = data2 % 10 + 1; 
		System.out.println(data2);
		
		System.out.println("방법3 ==>");
		Random r3 = new Random();
		// 양수, 음수 같이 나온다
		int data3 = r3.nextInt(); // r3.nextInt() <<< 1; 한줄로 만들 수 있다
		System.out.println(data3);
		
		// 비트 이동 연산자 >>> 양수로 만들어주는 연산자
		data3 = data3 >>> 1;
		data3 = data3 % 10 + 1;
		System.out.println(data3);
		
		System.out.println("방법4 ==>");
		// 현재 컴퓨터의 시간을 밀리세컨으로 반환한다
		long data = System.currentTimeMillis();
		System.out.println(data);
		data = data % 10 + 1;
		System.out.println(data);
	}
}

 

/난수 연습하기/

package com.kosta.exam03;

import java.util.Random;

public class RandomName {

	public static void main(String[] args) {
		// 난수 연습하기 : 무작위로 하나 출력하기
		Random r = new Random();
		
		String[] kor = {"가", "나", "다", "라", "마", "바", "사", "아", "자", "차", "카", "타", "파", "하"};
		
		int n = r.nextInt(kor.length);
		System.out.println(n); // index
		System.out.println(kor[n]);
	}
}

package com.kosta.exam03;

import java.util.Random;

public class RandomName {

	public static void main(String[] args) {
		// 난수 연습하기 : 무작위로 하나 출력하기
		Random r = new Random();
		
		String[] kor = {"가", "나", "다", "라", "마", "바", "사", "아", "자", "차", "카", "타", "파", "하"};
		
		int n = r.nextInt(kor.length);
		String data = "";
		for(int i = 0; i < 20; i++) {
			data = kor[i % kor.length];
			System.out.print(data+"\b");
			
			try {
				Thread.sleep(100); // 1000 = 1초동안 딜레이 주기, 100 = 0.1초 
			} catch (InterruptedException e) {
				e.printStackTrace();
			} 
			
		}
		System.out.println();
		System.out.println(kor[n]);
	}
}

 

/ArrayList/

package com.kosta.exam03;

import java.util.ArrayList;

public class ArrayListTest {

	public static void main(String[] args) {
		// 중복 허용, 순서 유지
		ArrayList data = new ArrayList();
		data.add("된장찌개");
		data.add("돈까스");
		data.add("김치찌개");
		data.add("돈까스");		
		data.add(100);
		System.out.println(data);

		// List는 배열처럼 index에 접근합니다
		data.get(1); // List에 [1]번째 반환
		
		// String food = data.get(1); // error
		
		// error 모든 타입이 가능해서 형변환 해줘야한다
		String food = (String)data.get(1);
		int num = (Integer)data.get(4);
		
		System.out.println(food);
		System.out.println(num);
	}
}

 

ArrayList list = new ArrayList() 와 같이 리스트를 생성하면
리스트에 온갖 자료형을 담을 수 있어요
처음에는 이것이 좋은 줄로만 알았는데
컬렉션을 경험 해 보니 결코 좋은것이 아니다 라는 것을 느끼게 됩니다
만약 리스트에 Person도 담고 Shape도 담고 또, Employee도 담고 등..

이렇게 되었을 때 리스트에 담긴 데이터의 수 만큼 반복하여
결국은 그 요소에 따라 일처리를 시켜야하는데
각각 자료형이 다르면 일일히 instanceof 연산자로 물어보고 형변환 한 후에
해당 클래스에 메소드를 호출해야 하는 것은 상당히 번거로운 일입니다

가능하면 Object보다는 내가 만든 클래스의 상속관계에 범위를 제한하도록 권장합니다
즉, 리스트에 담는 자료형을 제한하도록 합니다
이것을 "제네릭" 이라고 합니다 

ArrayList<Person> list = new new ArrayList<Person>(); 

이렇게 리스트를 만들어 두면 리스트에는 Person의 객체만 담을 수 있어요

만약 Person의 후손이 있다면 담을 수 있어요

package com.kosta.exam03;

import java.util.ArrayList;

class Person{
	String name;
	int age;
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

	public void sayHello() {
		System.out.println("hello, " + name);
	}
	
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
}

/*
ArrayList list = new ArrayList() 와 같이 리스트를 생성하면
리스트에 온갖 자료형을 담을 수 있어요
처음에는 이것이 좋은 줄로만 알았는데
컬렉션을 경험 해 보니 결코 좋은것이 아니다 라는 것을 느끼게 됩니다
만약 리스트에 Person도 담고 Shape도 담고 또, Employee도 담고 등..
이렇게 되었을 때 리스트에 담긴 데이터의 수 만큼 반복하여
결국은 그 요소에 따라 일처리를 시켜야하는데
각각 자료형이 다르면 일일히 instanceof 연산자로 물어보고 형변환 한 후에
해당 클래스에 메소드를 호출해야 하는 것은 상당히 번거로운 일입니다

가능하면 Object보다는 내가 만든 클래스의 상속관계에 범위를 제한하도록 권장합니다
즉, 리스트에 담는 자료형을 제한하도록 합니다
이것을 "제네릭" 이라고 합니다 
ArrayList<Person> list = new new ArrayList<Person>(); 
*/

public class ArrayListTest2 {

	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		
		// 자료형을 다 담을 수 있다
		list.add(100);
		list.add("자바");
		list.add(true);
		list.add(new Person("이름1", 20));
		list.add(2024 );
		list.add(new Person("이름2", 21));
		
		// 해당 값을 꺼내려면 캐스팅해야한다 instanceof 
		for(int i = 0; i < list.size(); i++) {
			Object obj = list.get(i);
			System.out.println(obj);
			
			// 리스트에 담긴 요소가 만약에 Person이면 sayHello 동작을 시키고 싶어요
			if(obj instanceof Person) {
				((Person)obj).sayHello();
			}
		}
	}
}

 

/list <> 제네릭 사용/

package com.kosta.exam03;

import java.util.ArrayList;

class Human{
	String name;
	int age;
	
	@Override
	public String toString() {
		return "Human [name=" + name + ", age=" + age + "]";
	}

	public void sayHello() {
		System.out.println("hello, " + name);
	}
	
	public Human() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Human(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
}

public class ArrayListTest3 {

	public static void main(String[] args) {
		// list에 Human만 담겠다
		ArrayList<Human> list = new ArrayList<Human>();
		
		list.add(new Human("이름1", 21));
		list.add(new Human("이름2", 22));
		list.add(new Human("이름3", 23));
		
		// 지금의 list에는 Human만 담을 수 있다
		// list.add("자바"); // error
		// list.add(2024); // error
		
		for(int i =0; i < list.size(); i ++) {
			Human h = list.get(i);
			h.sayHello();
		}
		
		// for each 반복문
		for(Human h:list) {
			h.sayHello();
		}
		
	}
}

 

/PROGRAMMING/

package com.kosta.exam04;

import java.util.ArrayList;
import java.util.Scanner;

public class StudentTest {
	// 어디서든 사용할 수 있게 static으로 만들어준다
	public static Scanner sc = new Scanner(System.in);

	public static void menu() {
		System.out.println("[1] 추가 [2] 검색 [3] 삭제 [0] 종료");
		System.out.println("메뉴를 선택하세요 : ");
	}
	
	public static void insertStudent(ArrayList<Student> list) {
		String name, addr, phone;
		
		// 학생의 정보를 입력받아 list에 담기
		System.out.println("** 학생 정보 추가 **");
		System.out.print("이름 : ");
		name = sc.next();
		System.out.print("주소 : ");
		addr = sc.next();
		System.out.print("번호 : ");
		phone = sc.next();
		
		Student s = new Student(name, addr, phone);
		// 객체를 list에 담아주기
		list.add(s);
		System.out.println("학생의 정보를 추가하였습니다.");
		System.out.println("------------------------------");
	}
	
	public static void searchStudent(ArrayList<Student> list) {
		String phone;
		System.out.println("** 학생 정보 검색 **");
		System.out.println("학생의 번호를 입력하시오 : ");
		phone = sc.next();
		
		// 이름이 유일한가, 유일하지 않은가 (중복)
		// 번호로 검색하기
		boolean flag = false;
		for(Student s : list) {
			if(s.getPhone().equals(phone)) {
				System.out.println(s);
				flag = true;
				break; 
			} // end if
		} // end for
		if(flag == false) {
			System.out.println("찾는 학생의 정보가 없습니다.");
		}
	}
	
	public static void deleteStudent(ArrayList<Student> list) {
		String phone;
		
		System.out.println("** 학생 정보 삭제 **");
		System.out.println("학생의 번호를 입력하시오. : ");
		phone = sc.next(); //  A, B, C, D  // D  i:3, size:3
		int i; // 삭제 시키기전에 담아두기
		int cnt = list.size();
		for(i = 0; i < list.size(); i++) {
			Student s = list.get(i);
			if(s.getPhone().equals(phone)){
				list.remove(i);
				System.out.println("해당 학생 정보를 삭제하셨습니다. ");
				break;
				} // end if
		} // end for		
	}

	public static void main(String[] args) {
		// 동적 배열
		ArrayList<Student> list = new ArrayList<Student>();
		Scanner sc = new Scanner(System.in);
		int sel;
		
		while(true) {
			menu();
			sel = sc.nextInt();
			if(sel  == 0) {
				break;
			} // end if
			
			switch(sel) {
			// 간결하게 하기위해 메소드 만들기
			case 1: insertStudent(list); break;
			case 2:searchStudent(list); break;
			case 3:deleteStudent(list); break;
				
			}
		} // end while
		System.out.println("** 프로그램 종료 **");
	}
}

 

---

 

14:00 ~ 

잠 깨기 위한 심리테스트 ~

0. 숲속을 걸어가는데 앞에 예쁜 열쇠가 떨어져있다 (줍는다/안줍는다)
1. 왕자/공주가 살 것 같은 성이 있다. 그 성의 담 높이는?
2. 첫번째 방에 들어갔는데 하얀 방이 있다. 그 방을 보고 느낀 감정
3. 두번째 방에 들어갔다. 창문에서 풍경을 보고, 옷장을 구경하고, 침대에 누워보고싶다. 하고싶은 순서는?
4. 창문을 열었더니 수영장에 연인이 수영을 하고있다(없어도 상상해)
5. 마지막 방에 들어갔다. 커피향이 나는 깜깜한 방이다. 어떻게 할 것인가?
======================================================================
0. 줍는다 - 살아가면서 요행을 바라는 스타일 
1. 이성을 사귀면서 자존심의 높이
2. 하얀방 : 처음 태어났을 때 느낌
3. 두번째방 : 연인을 볼 때 침대(사람) > 옷장(재력) > 창문(배경)
4. 미래의 연인이 다른 이성과 바람 핀 후 하는말
5. 마지막방 : 불을킨다,나간다 - 죽을 때 안죽으려고 발악한다

 

/그림판 선 그리는 기능 만들기/

 

Superclass에서 Panel 추가하기

 

Container에서 paint선택하기 (paintComponents는 안됨)

package com.kosta.exam05;

import java.awt.Graphics;
import java.awt.Panel;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class LinePanel extends Panel implements MouseListener {
	
	int x1, y1, x2, y2;
	
	public LinePanel() {
		System.out.println("생성자 동작함");
		
		// 마우스가 눌러질 때 일처리 당담자 등록하기
		addMouseListener(this);
	}
	
	@Override
	public void paint(Graphics g) {
		// super.paint(g);
		
		System.out.println("paint 동작함");
		g.drawLine(x1, y1, x2, y2);	
	}

	// 2개만 사용하더라도 전부 Override 해줘야한다
	@Override
	public void mouseClicked(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub
		System.out.println("마우스 눌러짐");
		x1 = e.getX();
		y1 = e.getY();
	}

	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub
		System.out.println("마우스 떼어짐");
		x2 = e.getX();
		y2 = e.getY();

		repaint();
	}

	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}
}

package com.kosta.exam05;

import java.awt.Frame;

// Frame 자식클래스 MyFrame
public class MyFrame extends Frame {
	// 상속관계(is a)가 아니다
	// has a 관계, MyFrame의 부속품 (가지고있다)
	LinePanel lp;
	
	public MyFrame() { // 생성자 만들기
		lp = new LinePanel();
		
		// Frame의 메소드
		add(lp);
		
		setSize(400, 300);
		setVisible(true);
	}
}

package com.kosta.exam05;

public class GrimpanTest {

	public static void main(String[] args) {
		new MyFrame();
		
	}
}

 

/하나의 그래픽을 표현하기 위한 GraphicInfo 클래스를 만들어 보세요/

package com.kosta.exam06;

import java.util.ArrayList;

/*
하나의 그래픽에 대한 정보를 표현하기 위해 새로운 클래스를 만들었어요
지금은 그래픽이 "선"이기 때문에 선의 정보인 시작점 x1,y1, 끝점 x2,y2로
구성되는 클래스를 만들었습니다
*/
public class GraphicInfo {
	private int x1;
	private int y1;
	private int x2;
	private int y2;

	public GraphicInfo() {
		super();
		// TODO Auto-generated constructor stub
	}

	public GraphicInfo(int x1, int y1, int x2, int y2) {
		super();
		this.x1 = x1;
		this.y1 = y1;
		this.x2 = x2;
		this.y2 = y2;
	}

	public int getX1() {
		return x1;
	}
	
	public void setX1(int x1) {
		this.x1 = x1;
	}
	public int getY1() {
		return y1;
	}
	public void setY1(int y1) {
		this.y1 = y1;
	}
	public int getX2() {
		return x2;
	}
	public void setX2(int x2) {
		this.x2 = x2;
	}
	public int getY2() {
		return y2;
	}
	public void setY2(int y2) {
		this.y2 = y2;
	}
}

package com.kosta.exam06;

import java.awt.Frame;

/*
윈도우 프로그래밍(GUI 프로그래밍)을 위하여
자바가 제공하는 Frame을 상속받은 MyFrame 클래스를 만들어요 
 */

// Frame 자식클래스 MyFrame
public class MyFrame extends Frame {
	// 상속관계(is a)가 아니다
	// has a 관계, MyFrame의 구성요소 (부속품, 멤버변수)로 LinePanel을 선언해요
	LinePanel lp;
	
	public MyFrame() { // 생성자 만들기
		
		// 생성자에서 부속품인 LinePanel을 생성 해 줍니다
		lp = new LinePanel();
		
		// 생성된 LinePanel을 프레임에 담아줍니다 담지 않으면 패널이 보이지 않아요
		// Frame의 메소드
		add(lp);
		
		// 프레임의 크기를 설정합니다
		setSize(400, 300);
		
		// 프레임을 화면에 보여줄것을 설정합니다
		setVisible(true);
	}
}

package com.kosta.exam06;

import java.awt.Graphics;
import java.awt.Panel;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;

/*
Panel은 복잡한 화면구성을 위한 서브컨테이너 역할을 하거나
그래픽을 표현하기 위하여 사용하는 화면구성요소 입니다
아래의 LinePanel은 그래픽을 표현하기 위하여 Panel 클래스로부터 상속받고
마우스 움직임에 대한 이벤트 처리를 위하여 MouseListener 인터페이스를 구현하도록 합니다  
*/

public class LinePanel extends Panel implements MouseListener {
	/*
	선을 그리면 이전에 그려진 선은 사라집니다
	그려진 모든 선을 그리려면 선을 그릴때마다 리스트에 담아두고
	paint 메소드에서 리스트에 담긴 요소만큼 모두 다시 그려주도록 해야합니다
	*/
	
	/*
	화면에 그려진 모든 그래픽(선)을 담기 위하여 리스트를 선언해요
	리스트에는 그래픽의 정보를 표현하기 위한 GraphicInfo만 담도록 한정합니다
	*/
	ArrayList<GraphicInfo> list = new ArrayList<GraphicInfo>();

	// 현재의 그래픽(선)의 시작점 x1, y1과 끝점 x2, y2를 저장하기 위한 멤버변수를 선언
	int x1, y1, x2, y2;
	
	public LinePanel() { // LinePanel 생성자면 객체 생성시에 자동 동작
		// 선을 담을 리스트 생성하기
		list = new ArrayList<GraphicInfo>();
		
		// 마우스가 눌러질 때 일처리 당담자 등록하기
		// 현재 패널인 LinePanel에 마우스 이벤트 담당자가 자신임을 등록한다
		addMouseListener(this);
	}
	
	/*
	윈도우 프로그래밍(GUI 프로그래밍)에서는 화면을 다시 그려줘야 할 필요가 있으면
	다음의 paint 메소드가 자동으로 동작합니다
	처음 LinePanel을 생성하여 프레임에 담으면 이 paint 메소드가 자동으로 동작하고
	또, 프레임의 크기를 조절하면 그 속에 있는 패널의 크기도 변경되기 때문에
	그때도 paint가 자동으로 동작합니다
	무언가 다시 그려줘야 할 필요가 있을 때 paint가 자동으로 동작합니다
	그러나 원래 윈도우는 모르는 사항에 대해서 다시 그려줄 것을 요청하려면
	우리가 paint를 직접 호출 할 수는 없고 repaint 메소드를 호출하여 paint를 요청 할 수 있어요
	*/
	@Override
	public void paint(Graphics g) { 
		
		/*
		사용자가 그린 그래픽(선)의 모든 정보는 리스트에 담겨있기 때문에
		담긴 요소만큼 반복 실행하여 모든 그래픽(선)을 그려 줍니다
		*/
		
		// 선을 담을 반복문
		for(GraphicInfo info : list) {
			g.drawLine(info.getX1(), info.getY1(), info.getX2(), info.getY2());
		}
	}

	@Override
	public void mouseClicked(MouseEvent e) {
	}

	@Override
	public void mousePressed(MouseEvent e) {
		/*
	 	마우스가 눌러졌을 때 동작하는 메소드이며
	 	눌러진 마우스의 위치 정보를 매개변수 MouseEvent e가 받아옵니다
	 	이를 통해서 마우스가 눌러진 x, y를 그래픽(선)의 시작점인 x1, y1에 저장합니다
		*/
		x1 = e.getX();
		y1 = e.getY();
	}

	@Override
	public void mouseReleased(MouseEvent e) {
		/*
		마우스를 떼었을 때 동작하는 메소드이며
		그때의 x, y를 그래픽(선)의 끝점을 위한 x2, y2에 저장하고
		현재 그려진 그래픽(선)의 시작점 x1, y1, x2, y2를 갖고
			
		GraphicInfo 객체를 생성하여 리스트에 담아요
		
		리스트에 담긴 그래픽의 정보만큼 모두 다시 그려줄것을 요청합니다
		*/
		x2 = e.getX();
		y2 = e.getY();
		
		// 그래픽을 생성해서 list에 담는다
		list.add(new GraphicInfo(x1, y1, x2, y2));
		
		// paint로 돌아간다
		repaint();
	}

	@Override
	public void mouseEntered(MouseEvent e) {
	}

	@Override
	public void mouseExited(MouseEvent e) {
	}
}

package com.kosta.exam06;

public class GrimpanTest {

	public static void main(String[] args) {
		new MyFrame();
		
	}
}

 

- 오늘 학습한 내용에 대하여 요약 및 정리하고 잘 이해가 되지않는 부분이 있다면

  질문을 통해 이해하고 넘어가도록 합니다

- 요약 및 정리가 끝난 사람들은 com.kosta.exam06을 복사하여 com.kosta.exam07, com.kosta.exam08로

  각각 만든 후 "선 그리기" 대신에 "사각형 그리기", "원 그리기"로 코드를 수정 해 봅니다

 

자바 API Graphics 클래스를 참조합니다.