Laboratory Activity #1 Java Fundamentals: Ncp2210 (Computerfundamentalsandprogramming)

NCP 2210 (Computer Fundamentals and Programming)
LABORATORY ACTIVITY #1
JAVA FUNDAMENTALS
NAME: ALMOSURA PAOLO R. DR. JOAN P. LAZARO
SECTION: DATE: GRADE: 2nd yr
Program Development Process

The figure below illustrates the process of writing a Java program, compiling it to byte
code, and running it.
The figure below illustrates the concept of a compiled Java program running on Windows,
Linux, Mac, and UNIX computers.
1|Page
The parts of a Java program
package example;
/**
* @author Joan Lazaro
*/
// This is a simple Java program.
public class Example {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
System.out.println("Programming in Java is fun!");
}
}
Note:
 Java is a case-sensitive language. It does not regard uppercase letters as being the same
character as their lowercase equivalents.
 All Java programs must be stored in a file with a name that ends with .java.
 Comments are ignored by the compiler.
 A .java file may contain many classes, but may have only one public class. If a .java file
has a public class, the class must have the same name as the file. For instance, if the file
Pizza.java contains a public class, the class’s name would be Pizza.
 Every Java application program must have a method named main.
 For every left brace, or opening brace, there must be a corresponding right brace, or
closing brace.
 Statements are terminated with semicolons. This does not include comments, class
headers, method headers, or braces.
The Java API

Performing output in Java, as well as many other tasks, is accomplished by using the Java
API. The term API stands for Application Programmer Interface. The API is a standard library of
prewritten classes for performing specific operations. These classes and their methods are
available to all Java programs. The print and println methods are part of the API and provide
ways for output to be displayed on the standard output device.
 The System class is part of the Java API. It has member objects and methods for
performing system-level operations, such as sending output to the console.
 The out object is a member of the System class. It provides methods for sending output to
the screen.
 The print and println methods are members of the out object. They actually perform the
work of writing characters on the screen.
2|Page
Example Program #1
package Xyz;
/**
* @author paolo cutie
*/
public class Xyz {
/**
*/
System.out.println("Programming in Java is fun!");
}
}}
Result:
Observation:
The example was good using \n
Example Program #2
package Xyz;
/**
3|Page

*/
public class Xyz {
/**
*/
System.out.print("These are our top sellers:\n");
System.out.print("\tComputer games\n\tCoffee\n");
System.out.println("\tAspirin");
}
}
Result:
Observation:
The example program no.2 shows the function of print and println. Using the \n and \t
Common escape sequences

Escape
Sequenc Name Description
e Newline Advances the cursor to the next line for subsequent printing
\n
\t Horizontal tab Causes the cursor to skip over to the next tab stop
\b Backspace Causes the cursor to back up, or move left, one position 4|Page
\r Return Causes the cursor to go to the beginning of the current line, not the
next line
Identifiers
An identifier is a programmer-defined name that represents some element of a program. Variable
names and class names are examples of identifiers.
The following are some specific rules that must be followed with all identifiers:
 The first character must be one of the letters a–z or A–Z, an underscore (_), or a dollar
sign ($).
 After the first character, you may use the letters a–z or A–Z, the digits 0–9, underscores
(_), or dollar signs ($).
 Uppercase and lowercase characters are distinct. This means itemsOrdered is not the
same as itemsordered.
 Identifiers cannot include spaces.
Primitive Data Types

Data Type Size Range
byte 1 byte Integers in the range of −128 to +127
short 2 bytes Integers in the range of −32,768 to +32,767
int 4 bytes Integers in the range of −2,147,483,648 to +2,147,483,647
Integers in the range of −9,223,372,036,854,775,808 to
long 8 bytes
+9,223,372,036,854,775,807
Floating-point numbers in the range of ±3.4 × 10−38 to ±3.4 × 1038,
float 4 bytes
with 7 digits of accuracy
Floating-point numbers in the range of ±1.7 × 10−308 to ±1.7 × 10308,
double 8 bytes
with 15 digits of accuracy
Example Program #3
package Xyz;
/**
5|Page

*/
public class Xyz {
/**
*/
int checking; // Declare an int variable named checking.
byte miles; // Declare a byte variable named miles.
short minutes; // Declare a short variable named minutes.
long days; // Declare a long variable named days.
checking = -20;
miles = 105;
minutes = 120;
days = 189000;
System.out.println("We have made a journey of " + miles + " miles.");
System.out.println("It took us " + minutes + " minutes.");
System.out.println("Our account balance is $" + checking);
System.out.println("About " + days + " days ago Columbus stood on this spot.");
}
}Result:
Observation:
The example program no.3 shows how the function of println, int, byte, short and long.
With the use of + and $ sign.
6|Page
Example Program #4
package Xyz;
/**
*/
public class Xyz {
/**
*/
double price, tax;
float total;
price = 29.75;
tax = 1.76;
total = 31.51F;
System.out.println("The price of the item is " + price);
System.out.println("The tax is " + tax);
System.out.println("The total is " + total);
}
}
Result:
Observation:
The example program no.4 show how to use the function of println, double and float. With
the use of +sign.
Example Program #5
package Xyz;
/**
*/
public class Xyz {
/**
*/
double distance, mass;
distance = 1.495979E11;
mass = 1.989E30;
7|Page
System.out.println("The sun is " + distance + " meters away.");

System.out.println("The sun's mass is " + mass + " kilograms.");
}
}
Result:
Observation:
The example program no.5 show the function of double and println. With the use of +sign.
Example Program #6
package Xyz;
/**
*/
public class Xyz {
/**
*/
boolean bool;
bool = true;
System.out.println(bool);
bool = false;
System.out.println(bool);
}
}
Result:
8|Page
Observation:
The example program no.6 shows us how is the function of println and boolean.
Example Program #7
package Xyz;
/**
*/
public class Xyz {
/**
*/
char letter;
letter = '@';
System.out.println(letter);
letter = '1';
//using ASCII codes
letter = 65;
letter = 66;
}
}
Result:
9|Page
Observation:
The example program no. 7 shown the use of println and char. With the use of ASCII codes.
Operators
Arithmetic operators
Operator Meaning Type
+ Addition Binary
− Subtraction Binary
* Multiplication Binary
/ Division Binary
% Modulus Binary
Combined assignment operator

Operator Example Usage Equivalent To
+= x += 5; x = x + 5;
−= y −= 2; y = y − 2;
*= z *= 10; z = z * 10;
/= a /= b; a = a / b;
%= c %= 3; c = c % 3;
Example Program #8
package Xyz;
/**
*/
public class Xyz {
/**
*/
double regularWages; // The calculated regular wages.
double basePay = 25; // The base pay rate.
double regularHours = 40; // The hours worked less overtime.
double overtimeWages; // Overtime wages
double overtimePay = 37.5; // Overtime pay rate
double overtimeHours = 10; // Overtime hours worked
double totalWages; // Total wages
10 | P a g e
regularWages = basePay * regularHours;

overtimeWages = overtimePay * overtimeHours;
totalWages = regularWages + overtimeWages;
System.out.println("Wages for this week are $" + totalWages);
}
}
Result:
Observation:
The example no.8 shows the funtion of double and println. With the use of +, * and $ sign
and the total wages.
Conversion between Primitive Data Types

Before a value can be stored in a variable, the value’s data type must be compatible with
the variable’s data type. Java performs some conversions between data types automatically, but
does not automatically perform any conversion that can result in the loss of data. Java also
follows a set of rules when evaluating arithmetic expressions containing mixed data types.
Primitive data type ranking
In assignment statements where values of lower-ranked data types are stored in variables
of higher-ranked data types, Java automatically converts the lower-ranked value to the higher-
ranked type. This is called a widening conversion. A narrowing conversion is the conversion of a
11 | P a g e
value to a lower-ranked type. Because narrowing conversions can potentially cause a loss of data,
Java does not automatically perform them.
Cast operators
The cast operator lets you manually convert a value, even if it means that a narrowing
conversion will take place. Cast operators are unary operators that appear as a data type name
enclosed in a set of parentheses. The operator precedes the value being converted.
Statement Description
littleNum = (short)bigNum; The cast operator returns the value in bigNum, converted to a short. The converted
value is assigned to the variable littleNum.
x = (long)3.7; The cast operator is applied to the expression 3.7. The operator returns the value
3, which is assigned to the variable x.
number = (int)72.567; The cast operator is applied to the expression 72.567. The operator returns 72,
which is used to initialize the variable number.
value = (float)x; The cast operator returns the value in x, converted to a float. The converted value
is assigned to the variable value.
value = (byte)number; The cast operator returns the value in number, converted to a byte. The converted
value is assigned to the variable value.
Creating named constants with final

The final key word can be used in a variable declaration to make the variable a named
constant. Named constants are initialized with a value, and that value cannot change during the
execution of the program.
A named constant is a variable whose value is read only and cannot be changed during
the program’s execution. You can create such a variable in Java by using the final key word in
the variable declaration. The word final is written just before the data type.
The String class

The String class allows you to create objects for holding strings. It also has various
methods that allow you to work with strings. The table below shows some of the common
methods used for string classes.
Method Description
charAt(index) The argument index is an int value and specifies a character position in the string. The first
character is at position 0, the second character is at position 1, and so forth. The method
returns the character at the specified position. The return value is of the type char.
length() This method returns the number of characters in the string. The return value is of the type
int.
toLowerCase() This method returns a new string that is the lowercase equivalent of the string contained in
the calling object.
toUpperCase() This method returns a new string that is the uppercase equivalent of the string contained in
the calling object.
12 | P a g e
Example Program #9
package Xyz;
/**
*/
public class Xyz {
/**
*/
String message = "Java Programming is Fun";
String upper = message.toUpperCase();
String lower = message.toLowerCase();
char letter = message.charAt(2);
int stringSize = message.length();
System.out.println(message);
System.out.println(upper);
System.out.println(lower);
System.out.println(stringSize);
}
}
Result:
Observation:
Example program no.9 shows the function string, char, int and println.
Reading Keyboard input

Objects of the Scanner class can be used to read input from the keyboard. The Java API
has another object, System.in, which refers to the standard input device. The standard input
device is normally the keyboard. You can use the System.in object to read keystrokes that have
been typed at the keyboard. However, using System.in is not as simple and straightforward as
using System.out because the System.in object reads input only as byte values. The table below
shows the different method of the Scanner class that can be used with the System.in object.
13 | P a g e
Method Description
nextByte Returns input as a byte.
nextDouble Returns input as a double.
nextFloat Returns input as a float.
nextInt Returns input as an int.
nextLine Returns input as a String.
nextLong Returns input as a long.
nextShort Returns input as a short.
Example Program #10

package Xyz;
/**
*/
public class Xyz {
/**
*/
String name; // To hold a name
int hours; // Hours worked
double payRate; // Hourly pay rate
double grossPay; // Gross pay
// Create a Scanner object to read input.

Scanner keyboard = new Scanner(System.in);
// Get the user's name.

System.out.print("What is your name? ");
name = keyboard.nextLine();
// Get the number of hours worked this week.
System.out.print("How many hours did you work this week? ");
hours = keyboard.nextInt();
// Get the user's hourly pay rate.
System.out.print("What is your hourly pay rate? ");
payRate = keyboard.nextDouble();
// Calculate the gross pay.
grossPay = hours * payRate;
// Display the resulting information.

System.out.println("Hello, " + name);
System.out.println("Your gross pay is $" + grossPay);
}
}
Result:
14 | P a g e
Observation:
Example program no.10 shows the function of string, int, double and println. With the use
of the signs of +, * and $.
Dialog Boxes
The JOptionPane class allows you to quickly display a dialog box, which is a small graphical
window displaying a message or requesting input. A dialog box is a small graphical window that
displays a message to the user or requests input. You can quickly display dialog boxes with the
JOptionPane class.
 Message Dialog. A dialog box that displays a message; an OK button is also displayed
 Input Dialog. A dialog box that prompts the user for input and provides a text field where input
is typed; an OK button and a Cancel button are also displayed
Example Program #11

package Xyz;
/**
*/
public class Xyz {
/**
*/
String firstName; // The user's first name
String middleName; // The user's middle name
String lastName; // The user's last name
// Get the user's first name.

firstName = JOptionPane.showInputDialog("What is your first name? ");
// Get the user's middle name.
middleName = JOptionPane.showInputDialog("What is your middle name?
");
// Get the user's last name.
lastName = JOptionPane.showInputDialog("What is your last name? ");
// Display a greeting
15 | P a g e
JOptionPane.showMessageDialog(null, "Hello " + firstName + " " +

middleName + " " + lastName);
System.exit(0);
}}
Result:
Observation:
The example program no.11 shows the funtion of string and exit. With the use of null.
Converting string input to numbers

Unlike the Scanner class, the JOptionPane class does not have different methods for
reading values of different data types as input. The showInputDialog method always returns the
user’s input as a String, even if the user enters numeric data. The table below shows the different
conversion of string to numeric types.
Method Description
Byte.parseByte Convert a string to a byte.
Double.parseDouble Convert a string to a double.
Float.parseFloat Convert a string to a float.
Integer.parseInt Convert a string to an int.
Long.parseLong Convert a string to a long.
Short.parseShort Convert a string to a short.
Example Program #12

package example;
import javax.swing.JOptionPane;
/**
* @author Aj Sabino
*/
public class Example {
/**
*/
String inputString; // For reading input
16 | P a g e
String name; // The user's name

int hours; // The number of hours worked
double payRate; // The user's hourly pay rate
double grossPay; // The user's gross pay
// Get the user's name.

name = JOptionPane.showInputDialog("What is your name? ");
// Get the hours worked.
inputString = JOptionPane.showInputDialog("How many hours did you
work this week? ");
// Convert the input to an int.
hours = Integer.parseInt(inputString);
// Get the hourly pay rate.
inputString = JOptionPane.showInputDialog("What is your hourly pay
rate? ");
// Convert the input to a double.
payRate = Double.parseDouble(inputString);
// Calculate the gross pay.
grossPay = hours * payRate;
// Display the results.

JOptionPane.showMessageDialog(null, "Hello " + name + ". Your gross
pay is $" + grossPay);
System.exit(0);
}
}
Result:
Observation:
the last example program shows the function of string. With the use of joptionpane and
input dialog
17 | P a g e
18 | P a g e

Laboratory Activity #1 Java Fundamentals: Ncp2210 (Computerfundamentalsandprogramming)

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Laboratory Activity #1 Java Fundamentals: Ncp2210 (Computerfundamentalsandprogramming)

Uploaded by

Copyright:

Available Formats

NCP 2210 (Computer Fundamentals and Programming)

Program Development Process

The parts of a Java program

The Java API

* @author paolo cutie

Common escape sequences

Primitive Data Types

* @author paolo cutie

System.out.println("The sun is " + distance + " meters away.");

Combined assignment operator

regularWages = basePay * regularHours;

Conversion between Primitive Data Types

Creating named constants with final

The String class

Reading Keyboard input

Example Program #10

// Create a Scanner object to read input.

// Get the user's name.

// Display the resulting information.

Example Program #11

// Get the user's first name.

JOptionPane.showMessageDialog(null, "Hello " + firstName + " " +

Converting string input to numbers

Example Program #12

String name; // The user's name

// Get the user's name.

// Display the results.

You might also like