자바3주차 시험자료

정리필요2

자바3주차 시험자료

ShineWithMe 2008. 9. 1. 00:46

package p1;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Color;
import java.awt.geom.Ellipse2D;
import javax.swing.JComponent;

public class Circlecomponent extends JComponent{

public Circlecomponent(int x, int y)
{
circle = new Ellipse2D.Double(x, y, 100, 100);
}
public void paintComponent(Graphics g)
{
Graphics2D g2 = (Graphics2D) g;
g2.setColor(col);
g2.fill(circle);
g2.draw(circle);
}
public void setColor(Color c)
{
col = c;
repaint();
}
private Ellipse2D.Double circle;
private Color col = Color.white;
}

package p1;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Color;

public class CircleViewer {

public static void main(String[] args) {

JFrame frame = new JFrame();
frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final Circlecomponent component = new Circlecomponent(FRAME_WIDTH/2-50, FRAME_HEIGHT/2-50);

JButton button1 = new JButton("RED");
JButton button2 = new JButton("BLUE");
JButton button3 = new JButton("YELLOW");

class ClickListener implements ActionListener {

public ClickListener(JButton b)
{
button = b;
}

public void actionPerformed(ActionEvent event)
{
button = (JButton)event.getSource(); // 리스너가 하나일시 event발생 소스로 버튼을 구분한다.

if(button.getText().equals("RED"))
{
component.setColor(Color.red);
}
else if(button.getText().equals("BLUE"))
{
component.setColor(Color.blue);
}
else if(button.getText().equals("YELLOW"))
{
component.setColor(Color.yellow);
}
}
private JButton button;
}

JPanel p1 = new JPanel();

button1.setSize(100, 80);
button2.setSize(100, 80);
button3.setSize(100, 80);
p1.add(button1);
p1.add(button2);
p1.add(button3);

p1.setSize(300, 80);
frame.add(p1);
p1.setLocation(FRAME_WIDTH/2-150, FRAME_HEIGHT-200);
frame.add(component);

ActionListener listener1 = new ClickListener(button1);
listener1 = new ClickListener(button2);
listener1 = new ClickListener(button3);
button1.addActionListener(listener1);
button2.addActionListener(listener1);
button3.addActionListener(listener1);

frame.setVisible(true);

}
private static final int FRAME_WIDTH = 600;
private static final int FRAME_HEIGHT = 600;

}

package p2;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Color;
import java.awt.geom.Ellipse2D;
import javax.swing.JComponent;

package p2;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Color;

public class CircleViewer {

public static void main(String[] args) {

JFrame frame = new JFrame();
frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final Circlecomponent component = new Circlecomponent(FRAME_WIDTH/2-50, FRAME_HEIGHT/2-50);

JCheckBox check1 = new JCheckBox("RED");
JCheckBox check2 = new JCheckBox("GREEN");
JCheckBox check3 = new JCheckBox("BLUE");

class ClickListener implements ActionListener {

public ClickListener(JCheckBox b)
{
check = b;
}

public void actionPerformed(ActionEvent event)
{
check = (JCheckBox)event.getSource(); // 리스너가 하나일시 event발생 소스로 버튼을 구분한다.

if(check.getText().equals("RED"))
{
if(r==0)
r = 1;
else
r = 0;

}
else if(check.getText().equals("GREEN"))
{
if(g==0)
g = 1;
else
g = 0;
}
else if(check.getText().equals("BLUE"))
{
if(b==0)
b = 1;
else
b = 0;
}

component.setColor(new Color(r, g, b));
}
private float r=0, g=0, b=0;
private JCheckBox check;
}

JPanel p1 = new JPanel();

check1.setSize(100, 80);
check2.setSize(100, 80);
check3.setSize(100, 80);
p1.add(check1);
p1.add(check2);
p1.add(check3);

p1.setSize(300, 80);
frame.add(p1);
p1.setLocation(FRAME_WIDTH/2-150, FRAME_HEIGHT-200);
frame.add(component);

ActionListener listener1 = new ClickListener(check1);
listener1 = new ClickListener(check2);
listener1 = new ClickListener(check3);
check1.addActionListener(listener1);
check2.addActionListener(listener1);
check3.addActionListener(listener1);

frame.setVisible(true);
}

private static final int FRAME_WIDTH = 600;
private static final int FRAME_HEIGHT = 600;
}

package p3;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Color;
import java.awt.geom.Ellipse2D;
import javax.swing.JComponent;

package p3;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.border.*;

import java.awt.Color;

public class CircleViewer {

class Listener implements ChangeListener {

public Listener(JSlider b){
slider = b;
}

public void stateChanged(ChangeEvent e){

slider = (JSlider)e.getSource();

if(slider.equals(slider1))
{
r = slider.getValue();
}
if(slider.equals(slider2))
{
g = slider.getValue();
}
if(slider.equals(slider3))
{
b = slider.getValue();
}

component.setColor(new Color(r, g, b));

}
private JSlider slider;
private int r, g, b;
}

JPanel p1 = new JPanel();
JPanel p2 = new JPanel();
JPanel p3 = new JPanel();
p1.setBorder(new TitledBorder(slider1.getName()));
p1.add(slider1);
p2.setBorder(new TitledBorder(slider2.getName()));
p2.add(slider2);
p3.setBorder(new TitledBorder(slider3.getName()));
p3.add(slider3);

p1.setSize(300, 50);
p1.setLocation(FRAME_WIDTH/2-150, FRAME_HEIGHT/2+60);

p2.setSize(300, 50);
p2.setLocation(FRAME_WIDTH/2-150, FRAME_HEIGHT/2+120);

p3.setSize(300, 50);
p3.setLocation(FRAME_WIDTH/2-150, FRAME_HEIGHT/2+180);

frame.add(p1);
frame.add(p2);
frame.add(p3);
frame.add(component);

Listener listener = new Listener(slider1);
listener = new Listener(slider2);
listener = new Listener(slider3);

slider1.addChangeListener(listener);
slider2.addChangeListener(listener);
slider3.addChangeListener(listener);

frame.setVisible(true);

}

private static final int FRAME_WIDTH = 600;
private static final int FRAME_HEIGHT = 600;

}

package p4;

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

import javax.swing.*;
import javax.swing.event.*;

public class SliderFrame extends JFrame {

public SliderFrame()
{
JPanel colorPanel = new JPanel();
colorPanel.setLayout(new GridLayout(2, 1));

colorP = new JPanel(); // 현재 그려질 패널
colorP.setBackground(Color.black);

colorPanel_1 = new JPanel(); // 윗패널
colorPanel_1.setBackground(Color.black);
colorPanel_2 = new JPanel(); // 아랫패널
colorPanel_2.setBackground(Color.black);

colorPanel.add(colorPanel_1);
colorPanel.add(colorPanel_2);

colorP = colorPanel_1;

add(colorPanel, BorderLayout.CENTER);
createControlPanel();
setSampleColor();
setSize(FRAME_WIDTH, FRAME_HEIGHT);
}

public void createControlPanel()
{
class MousePressListener implements MouseListener{
public MousePressListener(){}
public void mousePressed(MouseEvent event){}
public void mouseReleased(MouseEvent event){
colorP = (JPanel)event.getSource();
nowColor = new Color(colorP.getBackground().getRed(),
colorP.getBackground().getGreen(),
colorP.getBackground().getBlue());

redSlider.setValue(nowColor.getRed());
greenSlider.setValue(nowColor.getGreen());
blueSlider.setValue(nowColor.getBlue());
}
public void mouseClicked(MouseEvent event){}
public void mouseEntered(MouseEvent event){}
public void mouseExited(MouseEvent event){}
}

class ColorListener implements ChangeListener {
public void stateChanged(ChangeEvent event) {
setSampleColor();
}
}

MousePressListener listenerM = new MousePressListener();
colorPanel_1.addMouseListener(listenerM);
colorPanel_2.addMouseListener(listenerM);

ChangeListener listener = new ColorListener();

redSlider = new JSlider(0, 255, 0);
redSlider.addChangeListener(listener);

greenSlider = new JSlider(0, 255, 0);
greenSlider.addChangeListener(listener);

blueSlider = new JSlider(0, 255, 0);
blueSlider.addChangeListener(listener);

JPanel controlPanel = new JPanel();
controlPanel.setLayout(new GridLayout(3, 2));

controlPanel.add(new JLabel("Red"));
controlPanel.add(redSlider);

controlPanel.add(new JLabel("Green"));
controlPanel.add(greenSlider);

controlPanel.add(new JLabel("Blue"));
controlPanel.add(blueSlider);

add(controlPanel, BorderLayout.SOUTH);
}

public void setSampleColor()
{
int red = redSlider.getValue();
int green = greenSlider.getValue();
int blue = blueSlider.getValue();

colorP.setBackground(new Color(red, green, blue));
colorP.repaint();

}

private JPanel colorP, colorPanel_1, colorPanel_2;

private Color nowColor;
private JSlider redSlider;
private JSlider greenSlider;
private JSlider blueSlider;

private static final int FRAME_WIDTH = 300;
private static final int FRAME_HEIGHT = 400;
}

package p4;

import javax.swing.JFrame;

public class SliderFrameViewer {
public static void main(String[] args) {
// TODO Auto-generated method stub

SliderFrame frame = new SliderFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}

}

package p5;

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

import javax.swing.*;
import javax.swing.event.*;

public class CalComponent extends JFrame {
public CalComponent()
{
calPanel = new JPanel();
input1 = new JTextField("입력1 ");
//input1.setSize(200, 80);
input2 = new JTextField("입력2 ");
//input2.setSize(200, 80);
cBox = new JComboBox(op);
equal = new JLabel("=");
result = new JTextField("결과 ");
//result.setSize(200, 80);

calPanel.add(input1);
calPanel.add(cBox);
calPanel.add(input2);
calPanel.add(equal);
calPanel.add(result);

add(calPanel);
createControlPanel();
setSize(FRAME_WIDTH, FRAME_HEIGHT);
}

public void createControlPanel()
{

cBox.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent ev) {
if(ev.getStateChange() == ItemEvent.SELECTED){
JComboBox jbox = (JComboBox)ev.getItemSelectable();
String str = jbox.getSelectedItem().toString();

double x, y, r;
x = Double.parseDouble(input1.getText());
y = Double.parseDouble(input2.getText());

if(str.equals("+")){
r = x + y;
result.setText(""+r+"");
}else if(str.equals("-")){
r = x - y;
result.setText(""+r+"");
}else if(str.equals("*")){
r = x * y;
result.setText(""+r+"");
}else if(str.equals("/")){
r = x / y;
result.setText(""+r+"");
}
}
}
});
}

private JPanel calPanel;
private JTextField input1;
private JTextField input2;
private String op[] = {" ", "+", "-", "*", "/"};
private JComboBox cBox;
private JLabel equal;
private JTextField result;

private static final int FRAME_WIDTH = 900;
private static final int FRAME_HEIGHT = 100;

}

package p5;

import javax.swing.JFrame;

public class CalTester {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

CalComponent frame = new CalComponent();
frame.setTitle("허접계산기");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}

}

/** BankAccount.java */
package p1;

import java.lang.IllegalArgumentException;

public class BankAccount {
public BankAccount() {
balance = 0;
}
public BankAccount(double initialBalance) {
if(initialBalance < 0) {
throw new IllegalArgumentException("음수 금액의 계좌 개설은 불가능 합니다.");
}
balance = initialBalance;
}
public void despoit(double amount) {
if(amount < 0) {
throw new IllegalArgumentException("음수 금액의 입금은 불가능 합니다.");
}
double newBalnace = balance + amount;
balance = newBalnace;
}
public void withdraw(double amount) {
if(amount < 0 || amount > balance) {
throw new IllegalArgumentException("음수 금액과 계좌금액의 한도를 넘은 금액의 출금은 불가능 합니다.");
}
double newBalance = balance - amount;
balance = newBalance;
}
public double getBalance() {
return balance;
}

private double balance;
}

/** BankAccountExceptionTester.java */
package p1;

import java.lang.IllegalArgumentException;
import java.util.Scanner;

public class BankAccountExceptionTester {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
BankAccount ba;
int coni = 1;

System.out.print("계좌 개설 금액: ");
double money = sc.nextDouble();

try {
ba = new BankAccount(money);
}
catch(IllegalArgumentException exception) {
System.out.println("생성자 호출에서 오류가 발생하였습니다.");
exception.getMessage();
exception.printStackTrace();

ba = new BankAccount();
}

while(coni != 0) {
System.out.print("1.입금 , 2.출금, 0.거래종료: ");
coni = sc.nextInt();

if(coni != 0) {
System.out.print("거래 금액: ");
money = sc.nextInt();

if(coni == 1) {
try {
System.out.println(money + "입금.");
ba.despoit(money);
}
catch(IllegalArgumentException exception) {
System.out.println("deposit 메서드 호출에서 오류가 발생하였습니다.");
exception.getMessage();
exception.printStackTrace();
}
}
else if(coni == 2) {
try {
System.out.println(money + "출금.");
ba.withdraw(money);
}
catch(IllegalArgumentException exception) {
System.out.println("withdraw 메서드 호출에서 오류가 발생하였습니다.");
exception.getMessage();
exception.printStackTrace();
}
}
else {
System.out.println("다시 선택하세요.");
}

System.out.println("계좌잔고: " + ba.getBalance());
}
}
}
}

/** BankAccountExceptionTester.java */
package p1;

import java.lang.IllegalArgumentException;
import java.util.Scanner;

public class BankAccountExceptionTester {

/** BankAccountException.java */
package p2;

public class BankAccountException extends Exception {

public BankAccountException() {
super();
}

public BankAccountException(String msg) {
super(msg);
}
}

/** BankAccountExceptionTester.java */
package p2;

import java.util.Scanner;

public class BankAccountExceptionTester {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
BankAccount ba;
int coni = 1;

System.out.print("계좌 개설 금액: ");
double money = sc.nextDouble();

try {
ba = new BankAccount(money);
}
catch(BankAccountException exception) {
System.out.println("생성자 호출에서 오류가 발생하였습니다.");
exception.getMessage();
exception.printStackTrace();

ba = new BankAccount();
}

while(coni != 0) {
System.out.print("1.입금 , 2.출금, 0.거래종료: ");
coni = sc.nextInt();

if(coni != 0) {
System.out.print("거래 금액: ");
money = sc.nextInt();

if(coni == 1) {
try {
System.out.println(money + "입금.");
ba.despoit(money);
}
catch(BankAccountException exception) {
System.out.println("deposit 메서드 호출에서 오류가 발생하였습니다.");
exception.getMessage();
exception.printStackTrace();
}
}
else if(coni == 2) {
try {
System.out.println(money + "출금.");
ba.withdraw(money);
}
catch(BankAccountException exception) {
System.out.println("withdraw 메서드 호출에서 오류가 발생하였습니다.");
exception.getMessage();
exception.printStackTrace();
}
}
else {
System.out.println("다시 선택하세요.");
}

System.out.println("계좌잔고: " + ba.getBalance());
}
}

}
}

/** BadDataException.java */
package p3;

public class BadDataException extends Exception {

public BadDataException() {
super();
}

public BadDataException(String eMessage) {
super(eMessage);
}
}

/** DataSetReader.java */
package p3;

import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class DataSetReader {

public double[] readFile(String filename) throws IOException, BadDataException {
FileReader reader = new FileReader(filename);
try {
Scanner in = new Scanner(reader);
readData(in);
}
finally {
reader.close();
}
return data;
}

private void readData(Scanner in) throws BadDataException {
if(!in.hasNextInt()) {
throw new BadDataException("Length expected");
}
int numberOfValues = in.nextInt();
data = new double[numberOfValues];

for(int i=0; i<numberOfValues; i++) {
readValue(in, i);
}

if(in.hasNext()) {
throw new BadDataException("End of file expected");
}
}

private void readValue(Scanner in, int i) throws BadDataException {
if(!in.hasNextDouble()) {
throw new BadDataException("Data value expected");
}
data[i] = in.nextDouble();
}

private double[] data;
}

/** DataSetTester.java */
package p3;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Scanner;

public class DataSetTester {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
DataSetReader reader = new DataSetReader();

boolean done = false;
while(!done) {
try {
System.out.println("Please enter the file name: ");
String filename = in.next();

double[] data = reader.readFile(filename);
double sum = 0;
System.out.println("The sum is " + sum);
done = true;
}
catch(FileNotFoundException exception) {
System.out.println("File not found.");
}
catch(BadDataException exception) {
System.out.println("Bad data: " + exception.getMessage());
}
catch(IOException exception) {
exception.printStackTrace();
}
}
}

}

package p4;

import javax.swing.JComponent;
import java.awt.geom.Ellipse2D;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Color;

public class DrawComponent extends JComponent
{
private String shape;

public DrawComponent(String sh)
{
shape = sh;
}

public void paintComponent(Graphics g)
{
Graphics2D g2 = (Graphics2D) g;

if(shape.equals("원"))
{
g2.setColor(Color.RED);
g2.fill(new Ellipse2D.Double(0,0,getWidth(),getHeight()));
}
else
{
g2.setColor(Color.BLUE);
g2.fill(new Rectangle(0,0,getWidth(),getHeight()));
}

}
}

package p4;

import javax.swing.JFrame;
import java.io.FileReader;
import java.util.Scanner;
import java.io.FileNotFoundException;
import java.util.NoSuchElementException;

public class DrawFrame
{
public static final int Width = 400;
public static final int Height = 300;

private JFrame frame;
private DrawComponent component;

public DrawFrame(String shape)
{
frame = new JFrame("Program04!!");
component = new DrawComponent(shape);

frame.setSize(Width,Height);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.add(component);
frame.setVisible(true);
}

public void draw()
{
frame.setVisible(true);
}

public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
boolean done = false;

while(!done)
{
System.out.println("파일 이름을 입력하세요.");
String filename = sc.next();
try
{
Scanner fin = new Scanner(new FileReader(filename));
String shape = fin.next();

if(shape.equals("원") || shape.equals("사각형"))
{
DrawFrame df = new DrawFrame(shape);
df.draw();
done = true;
}
}
/*
* FileReader의 생성자가 던지는 예외
*/
catch(FileNotFoundException exception)
{
System.out.println("파일을 찾을 수 없습니다.");
exception.printStackTrace();
}
/*
* Scanner의 next()메소드가 던지는 예외
*/
catch(IllegalStateException exception)
{
System.out.println("파일에서 읽을 수 없습니다.");
exception.printStackTrace();
}
/*
* Scanner의 next()메소드가 던지는 예외
*/
catch(NoSuchElementException exception)
{
System.out.println("스트링 타입의 데이터를 읽을 수 없습니다.");
exception.printStackTrace();
}
}
}
}

package p1;

import java.io.FileReader;
import java.io.IOException;

public class FileCounter {
public FileCounter()
{
   chars = 0;
   words = 0;
   lines = 0;
}

public void read(FileReader reader) throws IOException
{
   boolean space = true;
   boolean more = true;

   while (more)
   {
int ic = reader.read();
if (ic == -1) more = false;
else
{
   chars++;
   char c = (char) ic;
   if (c == '\n')
   {
lines++;
space = true;
   }
   else if (c == ' ' || c == '\r')
space = true;
   else
   {
if (space)
   words++; // 공백문자 다음의 비공백 문자를 만날때마다 증가
space = false;
   }
}
lines++;
   }
}

public int getCharacterCount()
{
   return chars;
}

public int getWordCount()
{
   return words;
}

public int getLineCount()
{
   return lines;
}

private int chars;
private int words;
private int lines;
}

package p1;

import java.io.FileReader;
import java.io.IOException;
import javax.swing.JFileChooser;
import java.util.Scanner;
import java.io.File;

public class ExP16_1 {
public static void main(String[] args) {
   Scanner in = new Scanner(System.in);
   String input = "";

   JFileChooser chooser = new JFileChooser();
   FileReader fin = null;

   try
   {
boolean done = false;
while (chooser.showOpenDialog(null) == JFileChooser.APPROVE_OPTION)
{
   File selectedFile = chooser.getSelectedFile();
   fin = new FileReader(selectedFile);

FileCounter fileCounter = new FileCounter();
fileCounter.read(fin);
System.out.println(
   fileCounter.getCharacterCount() + " chars, "
   + fileCounter.getWordCount() + " words, "
   + fileCounter.getLineCount() + " lines");
fin.close();

}
   }
   catch (IOException e)
   {
e.printStackTrace();
   }
}
}

package p2;

import java.io.IOException;
import java.io.FileReader;
import java.io.FileWriter;

public class CatFiles {
public static void main(String[] args) {
   if (args.length < 2)
   {
System.out.println("Usage: CatFiles sourcefile1 sourcefile2 . . . targetfile");
return;
   }

   try
   {
FileWriter out = new FileWriter(args[args.length - 1]);
for (int i = 0; i < args.length - 1; i++)
{
   FileReader in = new FileReader(args[i]);
   boolean more = true;
   while (more)
   {
int ic = in.read();
if (ic == -1)
   more = false;
else
   out.write(ic);
   }
   in.close();
}
out.close();
   }
   catch (IOException e)
   {
e.printStackTrace();
   }
}
}

package p3;

import java.awt.Rectangle;
import java.io.Serializable;

public class Squares extends Rectangle implements Serializable{
public Squares(int x, int y, int w, int h){
super(x, y, w, h);
}
}

package p3;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import javax.swing.JComponent;
import java.util.ArrayList;

public class SquareComponent extends JComponent
{
public SquareComponent() {
sList = new ArrayList<Squares>();
}
   public void paintComponent(Graphics g)
   {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
for (Rectangle r : sList)
   g2.draw(r);
   }
   public void makeRectangle(int x, int y)
   {
   sList.add(new Squares(x, y, BOX_WIDTH, BOX_HEIGHT));
repaint();
   }
   public ArrayList<Squares> getList(){
return sList;
   }
   public void setList(ArrayList<Squares> a){
sList = a;
   }

   private ArrayList<Squares> sList;
   private static final int BOX_WIDTH = 20;
   private static final int BOX_HEIGHT = 20;
}

package p3;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
import java.util.ArrayList;

public class SquareFrame extends JFrame{
public SquareFrame(){
squaresDraw();
chooser = new JFileChooser();
JMenuBar menuBar = new JMenuBar();
setJMenuBar(menuBar);
menuBar.add(createFileMenu());
setSize(FRAME_WIDTH, FRAME_HEIGHT);
}

public JMenu createFileMenu(){
JMenu menu = new JMenu("File");
menu.add(openFileItem());
menu.add(saveFileItem());
menu.add(createFileExitItem());
return menu;
}

public JMenuItem createFileExitItem(){
JMenuItem item = new JMenuItem("Exit");
class MenuItemListener implements ActionListener{
public void actionPerformed(ActionEvent event){
System.exit(0);
}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
return item;
}

public JMenuItem openFileItem(){
   JMenuItem item = new JMenuItem("Open");
class MenuItemListener implements ActionListener{
public void actionPerformed(ActionEvent event){
try{
if(chooser.showOpenDialog(null) == JFileChooser.APPROVE_OPTION)
{
   File selectedFile = chooser.getSelectedFile();
   ObjectInputStream in = new ObjectInputStream(new FileInputStream(selectedFile));

   component.setList((ArrayList<Squares>) in.readObject());
   component.repaint();
   in.close();
}
}
catch (Exception e)
{
   e.printStackTrace();
}
}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
   return item;
}

public JMenuItem saveFileItem(){
   JMenuItem item = new JMenuItem("Save");
class MenuItemListener implements ActionListener{
public void actionPerformed(ActionEvent event){
try{
if(chooser.showSaveDialog(null) == JFileChooser.APPROVE_OPTION)
{
   File selectedFile = chooser.getSelectedFile();

   ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(selectedFile));
   out.writeObject(component.getList());

   out.close();
}
}
catch (Exception e){
e.printStackTrace();
}
}
}
ActionListener listener = new MenuItemListener();
item.addActionListener(listener);
   return item;
}

public void squaresDraw(){
   // 그림을 그릴 콤포넌트 올리기
component = new SquareComponent();
add(component, BorderLayout.CENTER);

   class MousePressListener implements MouseListener
   {
public void mousePressed(MouseEvent event)
{
   int x = event.getX();
   int y = event.getY();
   component.makeRectangle(x, y);
}
public void mouseReleased(MouseEvent event) {}
public void mouseClicked(MouseEvent event) {}
public void mouseEntered(MouseEvent event) {}
public void mouseExited(MouseEvent event) {}
   }

MouseListener listener = new MousePressListener();
component.addMouseListener(listener);
}

private JFileChooser chooser;
private SquareComponent component;
private static final int FRAME_WIDTH = 800;
private static final int FRAME_HEIGHT = 600;

}

package p3;

import javax.swing.JFrame;

public class ST {
public static void main(String[] args) {
JFrame frame = new SquareFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}

package p1;

import java.util.Date;

public class GreetingR implements Runnable{
public GreetingR(String a){
greeting = a;
}
public void run(){
try{
for(int i=0; i<=REPET; i++){
Date now = new Date();
System.out.println(now + " " + greeting);
Thread.sleep(DELAY);
}
}
catch(InterruptedException exception){

}
}

private String greeting;
private static final int REPET = 10;
private static final int DELAY = 1000;
}

package p1;

import java.util.Date;

public class GreetingRTester {
public static void main(String[] args) {
GreetingR r1 = new GreetingR("안녕");
GreetingR r2 = new GreetingR("하이");
GreetingR r3 = new GreetingR("어이");
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
Thread t3 = new Thread(r3);
t1.start();
t2.start();
t3.start();
}
}

package p2;

public class BankAccount {
public BankAccount(){
balance = 0;
}
public void deposit(double amount){
System.out.print("Depositing " + amount);
double newBalance = balance + amount;
System.out.println(", new balance is " + newBalance);
balance = newBalance;
}
public void withdraw(double amount){
System.out.print("Withdrawing " + amount);
double newBalance = balance - amount;
System.out.println(", new balance is " + newBalance);
balance = newBalance;
}
public double getBalance(){
return balance;
}
private double balance;
}

package p2;

public class DepositRunnable implements Runnable{
public DepositRunnable(BankAccount anAccount, double anAmount, int aCount){
account = anAccount;
amount = anAmount;
count = aCount;
}
public void run(){
try{
for(int i=1; i<=count; i++){
account.deposit(amount);
Thread.sleep(DELAY);
}
}
catch(InterruptedException exception){}
}
private static final int DELAY = 1;
private static BankAccount account;
private double amount;
private int count;
}

package p2;

public class WithdrawRunnable implements Runnable{
public WithdrawRunnable(BankAccount anAccount, double anAmount, int aCount){
account = anAccount;
amount = anAmount;
count = aCount;
}
public void run(){
try{
for(int i=1; i<=count; i++){
account.withdraw(amount);
Thread.sleep(DELAY);
}
}
catch(InterruptedException exception) {}
}
private static final int DELAY = 1;
private BankAccount account;
private double amount;
private int count;
}

package p2;

package p3;
public class RunThreads implements Runnable {
public void run() {
for (int i = 0; i < 25; i ++) {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " is running");
}
}
}

package p3;

public class RunThreadsTester {
public static void main(String[] args) {
RunThreads runner = new RunThreads();
Thread alpha = new Thread(runner);
Thread beta = new Thread(runner);
alpha.setName("Alpha thread");
beta.setName("Beta thread");
alpha.start();
beta.start();
}
}

package p4;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BankAccount {
public BankAccount(){
balance = 0;
balanceChangeLock = new ReentrantLock();
sufiicientFundsCondition = balanceChangeLock.newCondition();
}
public void deposit(double amount){
balanceChangeLock.lock();
try{
System.out.print("Depositing " + amount);
double newBalance = balance + amount;
System.out.println(", new balance is " + newBalance);
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " is running");
balance = newBalance;
sufiicientFundsCondition.signalAll();
}
finally{
balanceChangeLock.unlock();
}

}
public void withdraw(double amount) throws InterruptedException{
balanceChangeLock.lock();
try{
while(balance < amount)
sufiicientFundsCondition.await();
System.out.print("Withdrawing " + amount);
double newBalance = balance - amount;
System.out.println(", new balance is " + newBalance);
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " is running");
balance = newBalance;
}
finally{
balanceChangeLock.unlock();
}
}
public double getBalance(){
return balance;
}
private double balance;
private Lock balanceChangeLock;
private Condition sufiicientFundsCondition;
}

package p4;

public class BankAccountThreadTester {
public static void main(String[] args) {
BankAccount account = new BankAccount();
final double AMOUNT = 100;
final int REPET = 1000;

DepositRunnable d1 = new DepositRunnable(account, AMOUNT, REPET);
WithdrawRunnable w1 = new WithdrawRunnable(account, AMOUNT, REPET);
DepositRunnable d2 = new DepositRunnable(account, AMOUNT, REPET);
WithdrawRunnable w2 = new WithdrawRunnable(account, AMOUNT, REPET);

Thread t1 = new Thread(d1);
Thread t2 = new Thread(w1);
Thread t3 = new Thread(d2);
Thread t4 = new Thread(w2);

t1.start();
t2.start();
t3.start();
t4.start();
}

}

package p5;

import java.awt.Graphics2D;
import java.awt.Color;
import java.awt.geom.Ellipse2D;
import javax.swing.JPanel;
import java.util.Random;

public class Ball1
{
public Ball1(JPanel aPanel)
{
panel = aPanel;
generator = new Random();
dx = 0; // 공의 x 방향 이동 속력 (sleep 시간 당 픽셀)
dy = generator.nextInt(MAX_DY) + 1; // y 방향 이동 속력
color = Color.RED;
yTop = 0; // 공의 출발 위치 y 좌표
xLeft = generator.nextInt(panel.getWidth() - DIAMETER); // 공의 출발 위치 x 좌표
}

public void move()
{
// 공 이동
xLeft += dx;
yTop += dy;

// 만약 벽에 닿았거나 지나쳤으면 반사시킴
if (xLeft <= 0) // 왼쪽 벽에 닿은 경우
{
dx = -1 * dx;
xLeft = -xLeft;
}
if (xLeft + DIAMETER >= panel.getWidth()) // 오른쪽 벽에 닿은 경우
{
dx = -1 * dx;
xLeft = 2 * (panel.getWidth() - DIAMETER) - xLeft;
}

if (yTop <= 0) // 위 벽에 닿은 경우
{
dy = -1 * dy;
yTop = -yTop;
}
if (yTop + DIAMETER >= panel.getHeight()) //아래 벽에 닿은 경우
{
dy = -1 * dy;
yTop = 2 * (panel.getHeight() - DIAMETER) - yTop;
}

}

public void draw(Graphics2D g2)
{
Ellipse2D.Double ball
= new Ellipse2D.Double(xLeft, yTop, DIAMETER, DIAMETER);
g2.setColor(color);
g2.draw(ball);
}

public void animate() throws InterruptedException
{
while (true)
{
move();
panel.repaint(); // 패널을 다시 그림 (공 전체가 다시 그려짐)
Thread.sleep(DELAY);
} // sleep 시간마다 쓰레드 수 만큼 그림이 새로 그려짐
}

public static final int DIAMETER = 20; // 공 직경
public static final int MAX_DX = 10; // x 방향 최대 속력
public static final int MAX_DY = 10; // y 방향 최대 속력
public static final int DELAY = 50; // sleep 주기

private JPanel panel;
private int dx; // x 방향 속도, DELAY당 이동 거리
private int dy; // y 방향 속도, DELAY당 이동 거리
private Color color;
private Random generator;
private int xLeft; // 공의 위치
private int yTop; // 공의 위치
}

package p5;

import javax.swing.JPanel;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.ArrayList;

public class BallPanel1 extends JPanel
{
public BallPanel1()
{
setSize(500, 300);
balls = new ArrayList<Ball1>();
}

public void paintComponent(Graphics g)
{
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
for (Ball1 ball : balls)
ball.draw(g2);
}

public void addBall(Ball1 ball)
{
balls.add(ball); // arraylist에 ball을 넣음
class AnimationRunnable implements Runnable
{
public AnimationRunnable(Ball1 ball)
{
this.ball = ball;
}

public void run()
{
try
{
ball.animate();
}
catch (InterruptedException exception)
{ // Interrupt가 걸리면 run 메소드가 종료되고 쓰레드도 종료
}
}
private Ball1 ball;
}

// Ball 하나 하나마다 애니메이션을 위한 쓰레드를 실행
Runnable r = new AnimationRunnable(ball);
Thread t = new Thread(r);
t.start(); // 각 쓰레드는 자신이 맡은 공에 animnate를 호출
// animate 메소드는 무한 루프를 도는 메소드임
}

private ArrayList<Ball1> balls;
}

package p5;

import javax.swing.JFrame;

public class BallViewer1
{
public static void main(String[] args)
{
JFrame frame = new JFrame();

final int FRAME_WIDTH = 500;
final int FRAME_HEIGHT = 300;

frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

BallPanel1 panel = new BallPanel1();
frame.add(panel);
panel.addBall(new Ball1(panel));
panel.addBall(new Ball1(panel));
panel.addBall(new Ball1(panel));

frame.setVisible(true);
}
}

package p6;

import java.awt.Graphics2D;
import java.awt.Color;
import java.awt.geom.Ellipse2D;
import javax.swing.JComponent;
import java.util.Random;

public class Ball
{

   public Ball(JComponent aComponent)
   {
component = aComponent;
generator = new Random();
dx = generator.nextInt(MAX_DX) + 1;
dy = generator.nextInt(MAX_DY) + 1;
color = randomColor();
yTop = generator.nextInt(component.getHeight() - DIAMETER);
xLeft = generator.nextInt(component.getWidth() - DIAMETER);
   }

   private Color randomColor()
   {
int c = generator.nextInt(9);
switch(c)
{
   case 0: return Color.BLACK;
   case 1: return Color.BLUE;
   case 2: return Color.CYAN;
   case 3: return Color.GREEN;
   case 4: return Color.MAGENTA;
   case 5: return Color.ORANGE;
   case 6: return Color.PINK;
   case 7: return Color.RED;
   case 8: return Color.YELLOW;
}
return Color.RED;
   }

   /**
Moves the ball.
   */
   public void move()
   {
xLeft += dx;
yTop += dy;
if (xLeft <= 0)
{
   dx = -1 * dx;
   xLeft = -xLeft;
}
if (xLeft + DIAMETER >= component.getWidth())
{
   dx = -1 * dx;
   xLeft = 2 * (component.getWidth() - DIAMETER) - xLeft;
}

if (yTop <= 0)
{
   dy = -1 * dy;
   yTop = -yTop;
}
if (yTop + DIAMETER >= component.getHeight())
{
   dy = -1 * dy;
   yTop = 2 * (component.getHeight() - DIAMETER) - yTop;
}

}

   /**
Draws the ball.
@param g2 the graphics context
   */
   public void draw(Graphics2D g2)
   {
Ellipse2D.Double ball
= new Ellipse2D.Double(xLeft, yTop, DIAMETER, DIAMETER);
g2.setColor(color);
g2.draw(ball);
   }

   public void animate() throws InterruptedException
   {
while (true)
{
   move();
   component.repaint();
   Thread.sleep(DELAY);
}
   }

   public static final int DIAMETER = 20;
   public static final int MAX_DX = 10;
   public static final int MAX_DY = 10;
   public static final int DELAY = 50;

   private JComponent component;
   private int dx; // x 방향 속도, DELAY당 이동 거리
   private int dy; // y 방향 속도, DELAY당 이동 거리
   private Color color;
   private Random generator;
   private int xLeft;
   private int yTop;
}

package p6;

import javax.swing.JComponent;
import java.util.ArrayList;
import java.awt.Graphics;
import java.awt.Graphics2D;

public class BallComponent extends JComponent
{
   public BallComponent()
   {
balls = new ArrayList<Ball>();
   }

   public void paintComponent(Graphics g)
   {
Graphics2D g2 = (Graphics2D) g;
for (Ball ball : balls)
   ball.draw(g2);
   }

   public void addBall(Ball ball)
   {
balls.add(ball);
class AnimationRunnable implements Runnable
{
   public AnimationRunnable(Ball ball)
   {
this.ball = ball;
   }

   public void run()
   {
try
{
   ball.animate();
}
catch (InterruptedException exception)
{
}
   }
   private Ball ball;
}

// Ball 하나 하나마다 애니메이션을 위한 쓰레드를 실행
Runnable r = new AnimationRunnable(ball);
Thread t = new Thread(r);
t.start();
   }

   private ArrayList<Ball> balls;
}

package p6;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JComponent;
import javax.swing.JButton;
import javax.swing.JPanel;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.ArrayList;
import java.awt.BorderLayout;

public class BallPanel extends JPanel
{
   public BallPanel()
   {
ballComponent = new BallComponent();
setLayout(new BorderLayout());
add(ballComponent, BorderLayout.CENTER);
createButton();
   }
   private void createButton()
   {
class ButtonListener implements ActionListener
{
   public ButtonListener(JComponent aComponent)
   {
component = aComponent;
   }

   public void actionPerformed(ActionEvent event)
   {
// 버튼이 눌릴 때마다 Ball 객체를 하나 구성하여 ballComponent에 추가함
ballComponent.addBall(new Ball(component));
   }

   JComponent component;
}

JButton button = new JButton("Add ball");
ActionListener listener = new ButtonListener(ballComponent);
button.addActionListener(listener);
add(button, BorderLayout.SOUTH);
   }

   private BallComponent ballComponent;
}

package p6;

import javax.swing.JFrame;

public class BallViewer
{
public static void main(String[] args)
{
JFrame frame = new JFrame();

final int FRAME_WIDTH = 500;
final int FRAME_HEIGHT = 300;

frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

BallPanel panel = new BallPanel();
frame.add(panel);

frame.setVisible(true);
}
}