Answer to Question #17756 in Java | JSP | JSF for Sayed Abdullah Almousawi

Question

One application of switch statements is in processing menus. A menu is a list of options. The user selects one of the options. The computer has to respond to each possible choice in a different way. If the options are numbered 1, 2, ..., then the number of the chosen option can be used in a switch statement to select the proper response. Write a Java program that asks the user to enter the measurement in inches and the type of conversion 1. Inches 2. Feets 3. Yards 4. Mies The program should use switch statement and TextIO library to write text on the screen and prints the converted measurement. In a TextIO-based program, the menu can be presented as a numbered list of options, and the user can choose an option by typing in its number.

Answer 1

public class Conversion {

public static void main(String[] args) {

TextIO.putln("Enter a value in inches: ");
int i=TextIO.getInt();
TextIO.putln("(1) Inches (2) Feets (3) Yards (4) Mies");
TextIO.putln("Convert to: ");
int y=TextIO.getInt();
switch (y) {
case 1: TextIO.putln(i+" Inches = "+i+" Inches"); break;
case 2: TextIO.putln(i+" Inches = "+(double)i/12+" Feets"); break;
case 3: TextIO.putln(i+" Inches = "+(double)i/36+" Yards"); break;
case 4: TextIO.putln(i+" Inches = "+(double)i*1.57828282828283e-05+" Mies"); break;
default:TextIO.putln("Incorrect choice");
}
}

}


// TextIO class is not there in the standard library of Java.So you need to put it in your project by yourself.
/*
Some versions of java do not implement standard input. Many of
my programming examples use standard input, through a class named
TextIO. This file is an attempt to solve the problem of the
missing standing input. It can also be used if you simply prefer
to have a GUI-style window for doing text input/output.

* * *

The class in this file named TextIO is an alternative for another
class of the same name. The original TextIO provided an easy
interface to standard input and standard output. This version
defines exactly the same functions and subroutines, but now
they do input and output in a window that is opened automatically
when this class is used. You can use the class in this file
as a substitute for the original TextIO. A program that does
input and output exclusively by using TextIO will work with
this version of TextIO without any changes. If the program
uses System.out, you have two choices: Either change references
to System.out.print to TextIO.put and System.out.println to
TextIO.putln. Or add the subroutine call

TextIO.captureStandardOutput();

at the beginning of the main() routine. After this line is
executed, the output from System.out.print and System.out.println
will go to the window, instead of to their usual destination.
(TextIO.captureStandardOutput might not work in all versions of Java.)

One thing about this class: The window will not close when the
program ends. You will have to close it yourself by hand, by clicking
on its close box. (Alternatively, you could add the line
System.exit(0); to the end of your main() routine.) Actually, this
is not so bad, since it gives you a chance to read all of the
program's output.

When you compile this file, you'll get five .class files:
TextIO.class, TextIO$ConsoleCanvas.class, TextIO$1.class,
TextIO$2.class, and TextIO$TextIOConsole.class. You need all
these classes to run your programs.


Written by: David Eck
Department of Mathematics and Computer Science
Hobart and William Smith Colleges
Geneva, NY 14456
Email: [e-mail]
WWW: https://math.hws.edu/eck/

*/

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

public class TextIO {

/* The following is the only public routine in this version of TextIO that
was not in the original version. It can be used to redirect the
output that would usually go to System.out to the GUI window used
by this class. It will probably not work in all versions of Java.
*/

public static void captureStandardOutput() {
OutputStream out = new OutputStream() {
public void write(int b) throws IOException {
char ch = (char)(b & 0x7F);
if (ch == '
' || ch == ' ')
console.putCR();
else if (ch >= 0x20 && ch != 0x7F)
console.putCh(ch);
}
};
try {
System.setOut(new PrintStream(out));
}
catch (Exception e) {
}
}

// *************************** I/O Methods *********************************

// Methods for writing the primitive types, plus type String,
// to the console, with no extra spaces.
//
// Note that the real-number data types, float
// and double, a rounded version is output that will
// use at most 10 or 11 characters. If you want to
// output a real number with full accuracy, use
// "TextIO.put(String.valueOf(x))", for example.

public static void put(int x) { put(x,0); } // Note: also handles byte and short!
public static void put(long x) { put(x,0); }
public static void put(double x) { put(x,0); } // Also handles float.
public static void put(char x) { put(x,0); }
public static void put(boolean x) { put(x,0); }
public static void put(String x) { put(x,0); }


// Methods for writing the primitive types, plus type String,
// to the console,followed by a carriage return, with
// no extra spaces.

public static void putln(int x) { put(x,0); newLine(); } // Note: also handles byte and short!
public static void putln(long x) { put(x,0); newLine(); }
public static void putln(double x) { put(x,0); newLine(); } // Also handles float.
public static void putln(char x) { put(x,0); newLine(); }
public static void putln(boolean x) { put(x,0); newLine(); }
public static void putln(String x) { put(x,0); newLine(); }


// Methods for writing the primitive types, plus type String,
// to the console, with a minimum field width of w,
// and followed by a carriage return.
// If output value is less than w characters, it is padded
// with extra spaces in front of the value.

public static void putln(int x, int w) { put(x,w); newLine(); } // Note: also handles byte and short!
public static void putln(long x, int w) { put(x,w); newLine(); }
public static void putln(double x, int w) { put(x,w); newLine(); } // Also handles float.
public static void putln(char x, int w) { put(x,w); newLine(); }
public static void putln(boolean x, int w) { put(x,w); newLine(); }
public static void putln(String x, int w) { put(x,w); newLine(); }


// Method for outputting a carriage return

public static void putln() { newLine(); }


// Methods for writing the primitive types, plus type String,
// to the console, with minimum field width w.

public static void put(int x, int w) { dumpString(String.valueOf(x), w); } // Note: also handles byte and short!
public static void put(long x, int w) { dumpString(String.valueOf(x), w); }
public static void put(double x, int w) { dumpString(realToString(x), w); } // Also handles float.
public static void put(char x, int w) { dumpString(String.valueOf(x), w); }
public static void put(boolean x, int w) { dumpString(String.valueOf(x), w); }
public static void put(String x, int w) { dumpString(x, w); }


// Methods for reading in the primitive types, plus "words" and "lines".
// The "getln..." methods discard any extra input, up to and including
// the next carriage return.
// A "word" read by getlnWord() is any sequence of non-blank characters.
// A "line" read by getlnString() or getln() is everything up to next CR;
// the carriage return is not part of the returned value, but it is
// read and discarded.
// Note that all input methods except getAnyChar(), peek(), the ones for lines
// skip past any blanks and carriage returns to find a non-blank value.
// getln() can return an empty string; getChar() and getlnChar() can
// return a space or a linefeed ('
') character.
// peek() allows you to look at the next character in input, without
// removing it from the input stream. (Note that using this
// routine might force the user to enter a line, in order to
// check what the next character is.)
// Acceptable boolean values are the "words": true, false, t, f, yes,
// no, y, n, 0, or 1; uppercase letters are OK.
// None of these can produce an error; if an error is found in input,
// the user is forced to re-enter.
// Available input routines are:
//
// getByte() getlnByte() getShort() getlnShort()
// getInt() getlnInt() getLong() getlnLong()
// getFloat() getlnFloat() getDouble() getlnDouble()
// getChar() getlnChar() peek() getAnyChar()
// getWord() getlnWord() getln() getString() getlnString()
//
// (getlnString is the same as getln and is onlyprovided for consistency.)

public static byte getlnByte() { byte x=getByte(); emptyBuffer(); return x; }
public static short getlnShort() { short x=getShort(); emptyBuffer(); return x; }
public static int getlnInt() { int x=getInt(); emptyBuffer(); return x; }
public static long getlnLong() { long x=getLong(); emptyBuffer(); return x; }
public static float getlnFloat() { float x=getFloat(); emptyBuffer(); return x; }
public static double getlnDouble() { double x=getDouble(); emptyBuffer(); return x; }
public static char getlnChar() { char x=getChar(); emptyBuffer(); return x; }
public static boolean getlnBoolean() { boolean x=getBoolean(); emptyBuffer(); return x; }
public static String getlnWord() { String x=getWord(); emptyBuffer(); return x; }
public static String getlnString() { return getln(); } // same as getln()
public static String getln() {
StringBuffer s = new StringBuffer(100);
char ch = readChar();
while (ch != '
') {
s.append(ch);
ch = readChar();
}
return s.toString();
}


public static byte getByte() { return (byte)readInteger(-128L,127L); }
public static short getShort() { return (short)readInteger(-32768L,32767L); }
public static int getInt() { return (int)readInteger((long)Integer.MIN_VALUE, (long)Integer.MAX_VALUE); }
public static long getLong() { return readInteger(Long.MIN_VALUE, Long.MAX_VALUE); }

public static char getAnyChar(){ return readChar(); }
public static char peek() { return lookChar(); }

public static char getChar() { // skip spaces & cr's, then return next char
char ch = lookChar();
while (ch == ' ' || ch == '
') {
readChar();
if (ch == '
')
dumpString("? ",0);
ch = lookChar();
}
return readChar();
}

public static float getFloat() {
float x = 0.0F;
while (true) {
String str = readRealString();
if (str.equals("")) {
errorMessage("Illegal floating point input.",
"Real number in the range " + Float.MIN_VALUE + " to " + Float.MAX_VALUE);
}
else {
Float f = null;
try { f = Float.valueOf(str); }
catch (NumberFormatException e) {
errorMessage("Illegal floating point input.",
"Real number in the range " + Float.MIN_VALUE + " to " + Float.MAX_VALUE);
continue;
}
if (f.isInfinite()) {
errorMessage("Floating point input outside of legal range.",
"Real number in the range " + Float.MIN_VALUE + " to " + Float.MAX_VALUE);
continue;
}
x = f.floatValue();
break;
}
}
return x;
}

public static double getDouble() {
double x = 0.0;
while (true) {
String str = readRealString();
if (str.equals("")) {
errorMessage("Illegal floating point input",
"Real number in the range " + Double.MIN_VALUE + " to " + Double.MAX_VALUE);
}
else {
Double f = null;
try { f = Double.valueOf(str); }
catch (NumberFormatException e) {
errorMessage("Illegal floating point input",
"Real number in the range " + Double.MIN_VALUE + " to " + Double.MAX_VALUE);
continue;
}
if (f.isInfinite()) {
errorMessage("Floating point input outside of legal range.",
"Real number in the range " + Double.MIN_VALUE + " to " + Double.MAX_VALUE);
continue;
}
x = f.doubleValue();
break;
}
}
return x;
}

public static String getWord() {
char ch = lookChar();
while (ch == ' ' || ch == '
') {
readChar();
if (ch == '
')
dumpString("? ",0);
ch = lookChar();
}
StringBuffer str = new StringBuffer(50);
while (ch != ' ' && ch != '
') {
str.append(readChar());
ch = lookChar();
}
return str.toString();
}

public static boolean getBoolean() {
boolean ans = false;
while (true) {
String s = getWord();
if ( s.equalsIgnoreCase("true") || s.equalsIgnoreCase("t") ||
s.equalsIgnoreCase("yes") || s.equalsIgnoreCase("y") ||
s.equals("1") ) {
ans = true;
break;
}
else if ( s.equalsIgnoreCase("false") || s.equalsIgnoreCase("f") ||
s.equalsIgnoreCase("no") || s.equalsIgnoreCase("n") ||
s.equals("0") ) {
ans = false;
break;
}
else
errorMessage("Illegal boolean input value.",
"one of: true, false, t, f, yes, no, y, n, 0, or 1");
}
return ans;
}

// ***************** Everything beyond this point is private *******************

// ********************** Utility routines for input/output ********************


private static TextIOConsole console = new TextIOConsole();

// private static InputStream in = System.in; // rename standard input stream
// private static PrintStream out = System.out; // rename standard output stream

private static String buffer = null; // one line read from input
private static int pos = 0; // position of next char in input line that has
// not yet been processed


private static String readRealString() { // read chars from input following syntax of real numbers
StringBuffer s=new StringBuffer(50);
char ch=lookChar();
while (ch == ' ' || ch == '
') {
readChar();
if (ch == '
')
dumpString("? ",0);
ch = lookChar();
}
if (ch == '-' || ch == '+') {
s.append(readChar());
ch = lookChar();
while (ch == ' ') {
readChar();
ch = lookChar();
}
}
while (ch >= '0' && ch <= '9') {
s.append(readChar());
ch = lookChar();
}
if (ch == '.') {
s.append(readChar());
ch = lookChar();
while (ch >= '0' && ch <= '9') {
s.append(readChar());
ch = lookChar();
}
}
if (ch == 'E' || ch == 'e') {
s.append(readChar());
ch = lookChar();
if (ch == '-' || ch == '+') {
s.append(readChar());
ch = lookChar();
}
while (ch >= '0' && ch <= '9') {
s.append(readChar());
ch = lookChar();
}
}
return s.toString();
}

private static long readInteger(long min, long max) { // read long integer, limited to specified range
long x=0;
while (true) {
StringBuffer s=new StringBuffer(34);
char ch=lookChar();
while (ch == ' ' || ch == '
') {
readChar();
if (ch == '
');
dumpString("? ",0);
ch = lookChar();
}
if (ch == '-' || ch == '+') {
s.append(readChar());
ch = lookChar();
while (ch == ' ') {
readChar();
ch = lookChar();
}
}
while (ch >= '0' && ch <= '9') {
s.append(readChar());
ch = lookChar();
}
if (s.equals("")){
errorMessage("Illegal integer input.",
"Integer in the range " + min + " to " + max);
}
else {
String str = s.toString();
try {
x = Long.parseLong(str);
}
catch (NumberFormatException e) {
errorMessage("Illegal integer input.",
"Integer in the range " + min + " to " + max);
continue;
}
if (x < min || x > max) {
errorMessage("Integer input outside of legal range.",
"Integer in the range " + min + " to " + max);
continue;
}
break;
}
}
return x;
}

private static String realToString(double x) {
// Goal is to get a reasonable representation of x in at most
// 10 characters, or 11 characters if x is negative.
if (Double.isNaN(x))
return "undefined";
if (Double.isInfinite(x))
if (x < 0)
return "-INF";
else
return "INF";
if (Math.abs(x) <= 5000000000.0 && Math.rint(x) == x)
return String.valueOf( (long)x );
String s = String.valueOf(x);
if (s.length() <= 10)
return s;
boolean neg = false;
if (x < 0) {
neg = true;
x = -x;
s = String.valueOf(x);
}
if (x >= 0.00005 && x <= 50000000 && (s.indexOf('E') == -1 && s.indexOf('e') == -1)) { // trim x to 10 chars max
s = round(s,10);
s = trimZeros(s);
}
else if (x > 1) { // construct exponential form with positive exponent
long power = (long)Math.floor(Math.log(x)/Math.log(10));
String exp = "E" + power;
int numlength = 10 - exp.length();
x = x / Math.pow(10,power);
s = String.valueOf(x);
s = round(s,numlength);
s = trimZeros(s);
s += exp;
}
else { // constuct exponential form
long power = (long)Math.ceil(-Math.log(x)/Math.log(10));
String exp = "E-" + power;
int numlength = 10 - exp.length();
x = x * Math.pow(10,power);
s = String.valueOf(x);
s = round(s,numlength);
s = trimZeros(s);
s += exp;
}
if (neg)
return "-" + s;
else
return s;
}

private static String trimZeros(String num) { // used by realToString
if (num.indexOf('.') >= 0 && num.charAt(num.length() - 1) == '0') {
int i = num.length() - 1;
while (num.charAt(i) == '0')
i--;
if (num.charAt(i) == '.')
num = num.substring(0,i);
else
num = num.substring(0,i+1);
}
return num;
}

private static String round(String num, int length) { // used by realToString
if (num.indexOf('.') < 0)
return num;
if (num.length() <= length)
return num;
if (num.charAt(length) >= '5' && num.charAt(length) != '.') {
char[] temp = new char[length+1];
int ct = length;
boolean rounding = true;
for (int i = length-1; i >= 0; i--) {
temp[ct] = num.charAt(i);
if (rounding && temp[ct] != '.') {
if (temp[ct] < '9') {
temp[ct]++;
rounding = false;
}
else
temp[ct] = '0';
}
ct--;
}
if (rounding) {
temp[ct] = '1';
ct--;
}
// ct is -1 or 0
return new String(temp,ct+1,length-ct);
}
else
return num.substring(0,length);

}
private static void dumpString(String str, int w) { // output string to console
for (int i=str.length(); i<w; i++)
console.putCh(' ');
for (int i=0; i<str.length(); i++)
if ((int)str.charAt(i) >= 0x20 && (int)str.charAt(i) != 0x7F) // no control chars or delete
console.putCh(str.charAt(i));
else if (str.charAt(i) == '
' || str.charAt(i) == ' ')
newLine();
}

private static void errorMessage(String message, String expecting) {
&