F to C

timer Asked: Dec 17th, 2017
account_balance_wallet $15

Question description

please use Eclipse Jee Oxygen and can you combine all the code to word


Graphical User Interfaces (GUI)


Create a Graphical User Interface (GUI-based) application that converts a temperature in Fahrenheit to Centigrade and vice verse. See picture below.



GUI-based Program

A program that contains a Graphical User Interface (GUI) is called a GUI-based program. It uses GUI components for interfacing with the user.

A GUI Component

A GUI component is a visual component that a user can use for communicating with the program . Buttons, text fields, menus, drop-down lists etc are all examples of GUI components.

GUI Object

Internally, each GUI component is a program object. For example, two buttons displayed above are internally two JButton objects. Similarly, other GUI components above are also objects of Java classes such as JPanel, JTextField, JLabels, etc.

Difference Between a GUI Object and Non-GUI Object

Both a GUI Object and a non-GUI object have internal representations consisting of its field values and methods. However a GUI Object additionally has an external representation that a user can visually see. The Java runtime keeps the two representations always in synch. For example, each GUI program starts by displaying a window. This window is an external representation of an internal JFrame object. When the user changes the width of a JFrame window visually by clicking and dragging the mouse, the internal value of the field named “width” also changes accordingly. Similarly, when the program changes the value of field named “width” by calling the method setWidth, the external width of the JFrame window also changes accordingly. The two representations always stay in synch.

Creating a GUI program

You can create a GUI program by creating an object of JFrame. However, this program would have minimal functionality.

In creating a practical GUI program, we extend the JFrame class using inheritance and then add functionality to it. Then we create an object of extended JFrame class and display the extended JFrame object.

Content Pane

In creating a GUI-based program, the programmer first extends the JFrame class. Then, in its constructor, the programmer creates a main JPanel object and puts all the needed GUI in it. Then the programmer makes the main JPanel as the content pane. When the main JPanel is made into a content pane, all the GUI in it becomes the GUI of the running program. (Note that the main JPanel may contain other JPanels which may contain GUI objects. Above, the main JPanel object contains three JPanel objects. Each of which contain other GUI objects).

Creating A GUI program.

Creating a GUI program involves the following:

JFrameExt class

Create a class that extends JFrame (e.g JFrameExt). In the constructor of this class, create the GUI as below:

Create a main JPanel

Make the main JPanel as the content pane of the extended JFrame object

Create a layout object (such as GridLayout, FlowLayout or BorderLayout object).

Set the layout of the main JPanel by passing it the above layout object

Add GUI components to the main JPanel object by calling its add method.

Register the extended JFrame object as a listener with GUI components (such as JButton object) from which you want to receive events.

Write an event handler in extended JFrame for receiving the events (e.g. event handler actionPerformed).

TestJFrameExt class

Create another class containing the main method (e.g. TestJFrameExt class). In the main method, do the following:

Create an object of extended JFrame class created above (use new to create the object).

Set the size of the extended JFrame. (by calling its method setSize)

Make the JFrame visible (by calling its method setVisible)

Note that when you create the JFrameExt, its constructor is called which creates its GUI. So when the main method shows the JFrameExt object, you will see the GUI.

Synchronous I/O

In this type of I/O, the program initiates input/output activity and is called Synchronous I/O. For example when you use showMessageDialog and showInputDialog methods of the class JOptionPane for input and output.

Asyncronous I/O or Event Driven I/O

In this type of I/O, the user initiates the input/output activity and is called Asynchronous I/O or Event Driven I/O. For example, the user may initiate I/O by clicking on a button or by selecting a menu item. In this type of I/O, each time user initiates an I/O activity, the system creates an event. The program responds to the event by invoking an event handler.

GUI Programs

All GUI based programs use Event Driven I/O. For example, when the user selects a menu item such as Open File, it results in an event. This event results in invoking a method (event handler) in the program that responds to the user request.

Thus a GUI program is made up of a number of event handling methods which are invoked to handle specific events.

Sample Code

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class JFrameExt extends JFrame implements ActionListener{

private JPanel jpMain = new JPanel();

private JPanel jpFrom = new JPanel();

private JPanel jpTo = new JPanel();

private JPanel jpOp = new JPanel();

private JLabel jlbFrom = new JLabel("From");

private JLabel jlbTo = new JLabel ("To ");

private JTextField jtfFrom = new JTextField(10);

private JTextField jtfTo = new JTextField(10);

private JButton jbtFtoC = new JButton("FtoC");

private JButton jbtCtoF = new JButton("CToF");

public JFrameExt (){

setTitle ("Converter");

setSize(400, 200);


//set jpMain layout

GridLayout gl = new GridLayout (3,1);


//add panels to jpMain







//Make jpMain as the content pane


//add components to panels








//register this object as a listener with buttons




//Listener method

public void actionPerformed(ActionEvent ev) {

String sFrom,sTo;

double dFrom, dTo;

sFrom = jtfFrom.getText().trim();

dFrom = Double.parseDouble(sFrom);

if (ev.getSource()==jbtFtoC){

dTo = 5.0/9.0 * (dFrom - 32.0);

sTo = "" + dTo;



else if (ev.getSource()==jbtCtoF){

dTo = (9.0/5.0 *dFrom) + 32.0;

sTo = "" + dTo;





Tutor Answer

School: New York University


package Tst;
import java.awt.event.*;
import javax.swing.*;
import java.awt.*;

public class Test extends JFrame implements ActionListener{

private JPanel

panel1 = new JPanel();

private JPanel panel2 = new JPanel();
private JPanel panel3 = new JPanel();
private JPanel jpOp = new JPanel();
private JLabe...

flag Report DMCA

The best tutor out there!!!!

Similar Questions
Hot Questions
Related Tags

Brown University

1271 Tutors

California Institute of Technology

2131 Tutors

Carnegie Mellon University

982 Tutors

Columbia University

1256 Tutors

Dartmouth University

2113 Tutors

Emory University

2279 Tutors

Harvard University

599 Tutors

Massachusetts Institute of Technology

2319 Tutors

New York University

1645 Tutors

Notre Dam University

1911 Tutors

Oklahoma University

2122 Tutors

Pennsylvania State University

932 Tutors

Princeton University

1211 Tutors

Stanford University

983 Tutors

University of California

1282 Tutors

Oxford University

123 Tutors

Yale University

2325 Tutors