자바3주차 시험자료

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;

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 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;

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 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 {

 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);
 
  final JSlider slider1 = new JSlider(SwingConstants.HORIZONTAL, 0, 255, 10);
  final JSlider slider2 = new JSlider(SwingConstants.HORIZONTAL, 0, 255, 10);
  final JSlider slider3 = new JSlider(SwingConstants.HORIZONTAL, 0, 255, 10);
 
  slider1.setName("RED");
  slider2.setName("GREEN");
  slider3.setName("BLUE");

  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 {

 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());
   }
  }
 }
}

/** 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;

public class BankAccountThreadTester {
 public static void main(String[] args) {
  BankAccount account = new BankAccount();
  final double AMOUNT = 100;
  final int REPET = 1000;
 
  DepositRunnable d = new DepositRunnable(account, AMOUNT, REPET);
  WithdrawRunnable w = new WithdrawRunnable(account, AMOUNT, REPET);
 
  Thread t1 = new Thread(d);
  Thread t2 = new Thread(w);
 
  t1.start();
  t2.start();
 }
}

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 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 p4;

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 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);
   }
}