OOP2

		public enum e_action {ADD, SUB, DIV, MUL};

		public calculator(int x, int y, e_action action) {

				setX(x);

				setY(y);

				switch(action){

						case ADD:

								addition();

								break;

						case SUB:

								substraction();

								break;

						case DIV:

								division();

								break;

						case MUL:

								multiplication();

								break;

				}

		}

		private int m_x;

		private int m_y;

		private int m_result;

		public int x() {

				return m_x;}

		public void setX(int x) {

				m_x = x;}

		public int y() {

				return m_y;}

		public void setY(int y) {

				m_y = y;}

		public int result() {

				return m_result;}

		public void setResult(int result) {

				m_result = result;}

		private addition() {

				setResult(x() + y());}

		private void substraction() {

				setResult(x() - y());}

		private void division() {

				setResult(x() / y());}

		private void multiplication() {

				setResult(x() * y());}

}

class view{

		private int test;

}

		public Boek(String naam, int prijs, e_type type) {

				setNaam(naam);

				setPrijs(prijs);

				setType(type);

		}

		public enum e_type {FOTOBOEK, ROMAN, STRIP};

		private e_type m_type;

		private String m_naam;

		private int m_prijs;

		public e_type type() {

				return m_type;}

		public void setType(e_type type) {

				m_type = type;}

		public String naam() {

				return m_naam;}

		public void setNaam(String naam) {

				m_naam = naam;}

		public int prijs() {

				return m_prijs;}

		public void setPrijs(int prijs) {

				m_prijs = prijs;}

}

In plaats van voor alle verschillende boeken een aparte class te maken, heb ik besloten om de verschillende soorten aan te duiden middels een enum.

De verschillende soorten boeken bieden geen specialisatie aan. Ook zou inheritance ervoor zorgen dat, als er in de basisklasse iets verandert (een extra variabele), in elke afgeleide klasse dezelfde aanpassingen moeten worden doorgevoerd.

Deze keuze komt ook tegemoet aan het principe van low coupling.

Ik heb ook besloten de GUI een aparte class te geven, om tegemoet te komen aan de MVC-architectuur.

		public Boek(String naam, int prijs, e_type type) {

				setNaam(naam);

				setPrijs(prijs);

				setType(type);

		}

		public enum e_type {FOTOBOEK, ROMAN, STRIP};

		private e_type m_type;

		private String m_naam;

		private int m_prijs;

		public e_type type() {

				return m_type;}

		public void setType(e_type type) {

				m_type = type;}

		public String naam() {

				return m_naam;}

		public void setNaam(String naam) {

				m_naam = naam;}

		public int prijs() {

				return m_prijs;}

		public void setPrijs(int prijs) {

				m_prijs = prijs;}

}

		import java.util.*;

		class gui extends javax.swing.JFrame {

				public gui() {

						//Generating a couple of books:

						List<Boek> temp = new ArrayList<Boek>();

						temp.add(new Boek("Fotocollage", 5, Boek.e_type.FOTOBOEK));

						temp.add(new Boek("Vijftig tinten", 80, Boek.e_type.ROMAN));

						temp.add(new Boek("De jacht op een voetbal", 2, Boek.e_type.STRIP));

						setBoeken(temp);

						//Putting the books in a JList:

						DefaultListModel list = new DefaultListModel();

						for(int i=0; i<temp.size(); i++) {

								list.addElement(temp.get(i).naam());

						}

						final JList jlist = new JList(list);

						jlist.addListSelectionListener( //Dit voegt de listeners toe voor deze list. werk. (By Mannu)

										new javax.swing.event.ListSelectionListener() {

												public void valueChanged(javax.swing.event.ListSelectionEvent event) {

														viewBookDetails(event, jlist); }

										});

						JPanel panel = new JPanel();

						panel.add(jlist);

						JLabel label = new JLabel("Een test");

						panel.add(label);

						JFrame frame = new JFrame("Stock management");

						frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

						frame.getContentPane().add(panel);

						frame.pack();

						frame.setVisible(true);

				}

				public void viewBookDetails(javax.swing.event.ListSelectionEvent event, JList boeken) {

						Boek boek = boeken.getSelectedValue();

						//Creating a new panel with book information:

						JPanel panel = new JPanel();

						JLabel naam = new JLabel(boek.naam());

						JLabel prijs = new JLabel(boek.prijs());

						panel.add(naam);

						panel.add(prijs);

						frame().getContentPane.add(panel);

						frame.pack();

						frame.setVisible(true);

		}

			private List<Boek> l_boeken;

			private JPanel m_jpanel;

			public List<Boek> boeken() {

					return l_boeken;}

			public void setBoeken(List<Boek> boeken) {

					l_boeken = boeken;}

			public JPanel jpanel() {

					return m_jpanel;}

			public void setPanel(JPanel jpanel) {

					m_jpanel = jpanel;}

}

import java.util.*;

class help {

		public static int selectedIndex(ListSelectionModel list) {

				//Declaring variables to limit the search to the selected options only:

				int minimum = list.getMinSelectionIndex();

				int maximum = list.getMaxSelectionIndex();

				//Looping through the possible options and checking if it's selected:

				for(int i = minimum; i <= maximum; i++) {

						if(list.isSelectedIndex(i))

								return i;

				}

				return -1;

		}

}

		public static void main(String[] args) {

				gui test = new gui();

		}

}

/**

 *

 * @author jvermeulen

 */

public abstract class AbstractController implements Controller {

    private Observable mModel;

    private View mView;

    public AbstractController(Observable model) {

        // Set the model.

        setModel(model);

    }

    @Override

    public void setView(View view) {

        mView = view;

    }

    @Override

    public View getView() {

        return mView;

    }

    @Override

    public void setModel(Observable model) {

        mModel = model;

    }

    @Override

    public Observable getModel() {

        return mModel;

    }

}

import java.util.Observer;

/**

 *

 * @author jvermeulen

 */

public abstract class AbstractView implements View, Observer {

    private Observable mModel;

    private Controller mController;

    /**

     * Empty constructor so that the model and controller can be set later.

     */

    public AbstractView() {        

    }

    public AbstractView(Observable model, Controller controller) {

        // Set the model.

        setModel(model);

        // If a controller was supplied, use it. Otherwise let the first call to 

        // getController() create the default controller.

        if (controller != null) {

            setController(controller);

        }

    }

    @Override

    public void setController(Controller controller) {

        mController = controller;

        // Tell the controller this object is its view.

        getController().setView(this);

    }

    @Override

    public Controller getController() {

        // If a controller hasn't been defined yet...

        if (mController == null) {

            // ...make one. Note that defaultController is normally overriden by 

            // the AbstractView subclass so that it returns the appropriate 

            // controller for the view.

            setController(defaultController(getModel()));

        }

        return mController;

    }

    @Override

    public void setModel(Observable model) {

        mModel = model;

    }

    @Override

    public Observable getModel() {

        return mModel;

    }

    @Override

    public Controller defaultController(Observable model) {

        return null;

    }

    /**

     * A do-nothing implementation of the Observer interface's update method.

     * Subclasses of AbstractView will provide a concrete implementation for 

     * this method.

     */

    @Override

    public void update(Observable o, Object arg) {    

    }

}

import java.awt.event.WindowEvent;

import javax.swing.BoxLayout;

import javax.swing.JFrame;

/**

 * Main user interface for the application. Makes sure the model, views and

 * controllers are connected to each other.

 * @author jvermeulen

 */

public class Clock {

    // The clock data (i.e., the Model).

    private ClockModel mModel;

    // A digital view of the clock.

    private ClockDigitalView mDigitalView;

    // A toolbar for controlling the clock.

    private ClockTools mTools;

    // An analog view of the clock.

    private final ClockAnalogView mAnalogView;

    public Clock(int hour, int minute, int second) {

        // Create the data model.

        mModel = new ClockModel();

        // Create the digital clock view.

        mDigitalView = new ClockDigitalView(mModel, null);

        mModel.addObserver(mDigitalView);

        // Create the analog clock view.

        mAnalogView = new ClockAnalogView(mModel, null);

        mModel.addObserver(mAnalogView);

        // Create the clock tools view.

        mTools = new ClockTools(mModel, null);

        mModel.addObserver(mTools);

        // Set the time.

        mModel.setTime(hour, minute, second);

        // Start the clock ticking.

        mModel.start();

    }

    public void createGUI() {

        JFrame frame = new JFrame("Clock");

        frame.setLayout(new BoxLayout(frame.getContentPane(), BoxLayout.Y_AXIS));

        frame.getContentPane().add(mDigitalView.getUI());

        frame.getContentPane().add(mAnalogView);

        frame.getContentPane().add(mTools.getUI());                

        frame.addWindowListener(new WindowAdapter() {

            @Override

            public void windowClosing(WindowEvent e) {

                System.exit(0);

            }

        });

        frame.pack();

        frame.setVisible(true);

    }

    private static void createAndShowGUI() {

        Clock clock = new Clock(9, 10, 22);

        clock.createGUI();

    }

    public static void main(String[] args) {

        //Schedule a job for the event-dispatching thread:

        //creating and showing this application's GUI.

        javax.swing.SwingUtilities.invokeLater(new Runnable() {

            @Override

            public void run() {

                createAndShowGUI();

            }

        });

    }

}

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.RenderingHints;

import java.awt.geom.AffineTransform;

import java.awt.geom.Ellipse2D;

import java.awt.geom.GeneralPath;

import java.util.Calendar;

import java.util.Observable;

import javax.swing.JComponent;

/**

 * An analog clock View for the ClockModel. This View has no user inputs, so

 * no controller is required. This class implements the View interface, and

 * subclasses JComponent directly, to illustrate that not all Views need to

 * inherit from AbstractView.

 *

 * Note: it is not necessary to understand all the details of the rendering 

 * of the analog clock.

 *

 * @author jvermeulen (inspired by IBM Java2D tutorial)

 */

public class ClockAnalogView extends JComponent implements View {

    private Observable mModel;

    private Controller mController;

    int mHour;

    int mMinute;

    int mSecond;

    ClockAnalogView(Observable model, Controller controller) {

        mModel = model;

        mController = controller;

    }

    @Override

    public void setController(Controller controller) {

        mController = controller;

    }

    @Override

    public Controller getController() {

        return mController;

    }

    @Override

    public void setModel(Observable model) {

        mModel = model;

    }

    @Override

    public Observable getModel() {

        return mModel;

    }

    @Override

    public Controller defaultController(Observable model) {

        return null;

    }

    @Override

    public void update(Observable o, Object info) {

        // Cast info to ClockUpdate type.

        ClockUpdate clockInfo = (ClockUpdate) info;

        // Store hour, minute, second for repainting.

        mHour = clockInfo.getHour()+5; // +5 Geeft een latere tijdzone weer. Dit is namelijk opdracht 3.

        mMinute = clockInfo.getMinute();

        mSecond = clockInfo.getSecond();

        // Using a little trigonometry, set the transforms to rotate

        // each hand into the proper position.  Center the rotation

        // around the pivot point (50, 50) instead of the origin

        hourTransform.setToRotation(((double) mHour) *

                                            (Math.PI / 6.0), 50, 50);

        minuteTransform.setToRotation(((double) mMinute) *

                                            (Math.PI / 30.0), 50, 50);

        secondTransform.setToRotation(((double) mSecond) *

                                            (Math.PI / 30.0), 50, 50);

        repaint();

    }

    /**

     * Sets this components preferred size to 150x150.

     * @return

     */

    @Override

    public Dimension getPreferredSize() {

        return new Dimension(100, 100);

    }

    // Create a shape for the face of the clock

    protected static Ellipse2D face = new Ellipse2D.Float(3, 3, 94, 94);

    // Create a path that represents a tick mark

    protected static GeneralPath tick = new GeneralPath();

    static // http://www.jusfortechies.com/java/core-java/static-blocks.php

    {

        tick.moveTo(100, 100);

        tick.moveTo(49, 0);

        tick.lineTo(51, 0);

        tick.lineTo(51, 6);

        tick.lineTo(49, 6);

        tick.lineTo(49, 0);

    }

    // Create a cool hour hand

    protected static GeneralPath hourHand = new GeneralPath();

    static

    {

        hourHand.moveTo(50, 15);

        hourHand.lineTo(53, 50);

        hourHand.lineTo(50, 53);

        hourHand.lineTo(47, 50);

        hourHand.lineTo(50, 15);

    }

    // Create a cool minute hand

    protected static GeneralPath minuteHand = new GeneralPath();

    static

    {

        minuteHand.moveTo(50, 2);

        minuteHand.lineTo(53, 50);

        minuteHand.lineTo(50, 58);

        minuteHand.lineTo(47, 50);

        minuteHand.lineTo(50, 2);

    }

    // And a cool second hand

    protected static GeneralPath secondHand = new GeneralPath();

    static

    {

        secondHand.moveTo(49, 5);

        secondHand.lineTo(51, 5);

        secondHand.lineTo(51, 62);

        secondHand.lineTo(49, 62);

        secondHand.lineTo(49, 5);

    }

    // Create some colors for the pieces of the clock

    protected static Color faceColor = new Color(220, 220, 220);

    protected static Color hourColor = Color.red.darker();

    protected static Color minuteColor = Color.blue.darker();

    protected static Color secondColor = new Color(180, 180, 0);

    protected static Color pinColor = Color.gray.brighter();

    // Create circles for the pivot and center pin

    protected Ellipse2D pivot = new Ellipse2D.Float(47, 47, 6, 6);

    protected Ellipse2D centerPin = new Ellipse2D.Float(49, 49, 2, 2);

    // Create three transforms that center around the pivot point

    protected AffineTransform hourTransform =

                    AffineTransform.getRotateInstance(0, 50, 50);

    protected AffineTransform minuteTransform =

                    AffineTransform.getRotateInstance(0, 50, 50);

    protected AffineTransform secondTransform =

                    AffineTransform.getRotateInstance(0, 50, 50);

    // Create a timer that fires once a second and a Calendar

    // instance for getting the time values

    // protected Timer timer = new Timer(1000, this);

    protected Calendar calendar = Calendar.getInstance();

    // This is an alternative to creating a UI delegate.  Since JPanel's

    // paint() method only paints the border and backgound, we can just

    // override the paint method of the component to do the graphics.

    public void paint(Graphics g)

    {

        // Call the superclass first to paint the border (if one is assigned)

        super.paint(g);

        // Get the graphics context and turn on anti-aliasing

        Graphics2D g2 = (Graphics2D) g;

        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

                            RenderingHints.VALUE_ANTIALIAS_ON);

        // Set the paint for the clock face and fill it in

        g2.setPaint(faceColor);

        g2.fill(face);

        // Set the paint to black and draw the clock's outline

        g2.setPaint(Color.black);

        g2.draw(face);

        // Fill in the 12 ticks around the face of the clock

        for (double p = 0.0; p < 12.0; p += 1.0)

        {

            // This is probably terribly inefficient and should be

            // done statically or in the constructor - draw the

            // tick as a transformed shape that is rotated.

            g2.fill(tick.createTransformedShape(

                AffineTransform.getRotateInstance((Math.PI / 6.0)  * p,

                        50, 50)));

        }

        // Set the paint and draw the hour hand.  It is lowest in the

        // 'z-order' so will appear underneath the other hands.  Notice

        // how each hand is transformed by a different <AffineTransform>.

        g2.setPaint(hourColor);

        g2.fill(hourHand.createTransformedShape(hourTransform));

        // Set the paint and draw the minute hand, the second hand,

        // the pivot and the center pin

        g2.setPaint(minuteColor);

        g2.fill(minuteHand.createTransformedShape(minuteTransform));

        g2.setPaint(secondColor);

        g2.fill(secondHand.createTransformedShape(secondTransform));

        g2.fill(pivot);

        g2.setPaint(pinColor);

        g2.fill(centerPin);

    }

}

import java.util.Calendar;