Java Programming Basics

 

Topics

  • Dissecting “Helloworld” sample application
  • Java comments
  • Statements and blocks
  • Java identifiers
  • Java literals
  • Variables
  • Primitive types
  • Operators

Dissecting “Helloworld” Sample App

1 public class Hello {
2 /**
3 * My first Java program
4 */
5 public static void main( String[] args ){
6
7 //prints the string Hello world on screen
8 System.out.println(“Hello world”);
9
10 }
11 } 

Class Declaration

 1 public class Hello {
2 /**
3 * My first Java program
4 */
  • Indicates the name of the class is Hello
  • The class uses an access modifier public, which indicates that our class is accessible to other classes

Start of code block

1 public class Hello {
2 /**
3 * My first Java program
4 */

 

  • The curly brace { indicates the start of a code block
  • In this code, we placed the curly brace at the end of the first line, however, we can also place { in the next line. So, we could actually write our code as:

public class Hello {

Comment

1 public class Hello {
2 /**
3 * My first Java program
4 */
  • The next three lines indicates a Java comment.
  • A comment
    • Something used to document a part of a code.
    • It is not part of the program itself - does not affect the programming logic - and used only for documentation purposes. 
    • It is good programming practice to add comments to your code.

main(..) method

1 public class Hello {
2 /**
3 * My first Java program
4 */
5 public static void main( String[ ] args ) {
  • The main(..) method is a special method, which indicates the starting point of a Java program. 
  • The main(..) method always takes command line arguments in the form of String array

Another Comment

1 public class Hello {
2 /**
3 * My first Java program
4 */
5 public static void main( String[] args ){
6
7 //prints the string “Hello world” on screen
  • It is a single line Java comment

System.out.println(..)

1 public class Hello {
2 /**
3 * My first Java program
4 */
5 public static void main( String[] args ){
6
7 //prints the string “Hello world” on screen
8 System.out.println(“Hello world”);
  • The System.out.println(“something to print”); prints the text enclosed by double-quotation on the standard output device - typically a display screen.

Ending Method and Class blocks

1 public class Hello {
2 /**
3 * My first Java program
4 */
5 public static void main( String[] args ){
6
7 //prints the string “Hello world” on screen
8 System.out.println(“Hello world”);
9
10 }
11 }
  • The last two lines which contain the two curly braces are used to close the main method and class respectively.

Coding Requirements: File name & Class name must match

  1. A file that contains Java code must end with the .java extension.
  2. A file that contains Java class code must match the name of your public class For example, if the name of your public class is Hello, you should save it in a file called Hello.java - otherwise, a compile error will occur.

Java Comments

  • Comments
    • These are notes written to a code for documentation purpose
    • Those texts are not part of the program and does not affect the flow or logic of the program in any way
  • 2 Types of comments in Java:
    • // Comments - used for single line comment
    • /* Comments This is used for multi-line comment */

Statements and Blocks

Java Statements

Each Java statement is terminated by a semicolon.

System.out.println(“Hello world”);
 int x = 2;

Java Code Blocks

  • One or more Java statements are bounded by opening and closing curly braces { … }
  • Any amount of white space is allowed
public static void main( String[] args ){
System.out.println("Hello");
System.out.println("world”);
} 

Java Identifiers

  • Tokens that represent names of variables, methods, classes, etc. 
    • Example identifiers are: Hello, main, System, out.
  • Java identifiers are case-sensitive.
    • This means that the identifier Hello is not the same as hello
  • Identifiers must begin with either a letter, an underscore “_”, or a dollar sign “$”. (They cannot begin with numbers.) Letters may be lower or upper case. Subsequent characters may use numbers 0 to 9. 
  • Identifiers cannot use Java keywords like class, public, void, etc 20

Java Keywords 

  • Keywords are predefined identifiers reserved by Java for a specific purpose. 
  • You cannot use these keywords as your own identifiers - names for your variables, classes, methods ... etc.
  • The next slide contains the list of the Java Keywords.

Java Programming Basics

Java Literals

  • Literals are tokens that do not change - they are sometimes called constant
  • The different types of literals in Java are: 
    • Integer Literals 
    • Floating-Point Literals 
    • Boolean Literals 
    • Character Literals 
    • String Literals 

Java Literals: Integer 

  • Special Notations in using integer literals in our programs: 
  • Decimal
    • No special notation 
    • example: 12 
  • Hexadecimal 
    • Precede by 0x or 0X 
    • example: 0xC 
  • Octal 
    • Precede by 0 
    • example: 014

Java Literals: Floating Point

  • Represents decimals with fractional parts 
    • Example: 3.1416 
  • Can be expressed in standard or scientific notation 
    • Example: 583.45 (standard), 5.8345e2 (scientific)

Java Literals: Boolean 

Boolean literals have only two values, true or false.

Java Literals: Character 

  • Character Literals represent Unicode characters 
  • Unicode character set 
    • A 16-bit character set that replaces the 8-bit ASCII character set 
    • Unicode allows the inclusion of symbols and special characters from other languages 28 Java Literals: Character 
  • To use a character literal, enclose the character in single quote delimiter. 
  • For example 
    • The letter a, is represented as ‘a’.
    • Special characters such as a newline character, a backslash is used followed by the character code. For example, ‘\n’ for the newline character, ‘\r’ for the carriage return, ‘\b’ for backspace.

Java Literals: String 

  • String literals represent multiple characters and are enclosed by double quotes.
  • An example of a string literal is, “Hello World”.

Variables

  • A variable is used to store the state of objects 
  • A variable has a: 
    • Data type - The data type indicates the type of value that the variable can hold 
    • Name - The variable name must follow rules for identifiers.

Declaring and Initializing Variables 

  • Declare a variable as follows:
<data type> <name> [=initial value];
  •  The Java programming language is statically-typed, which means that the must first be declared before variables can be used 
  • The can be either Primitive type or Reference type (Object type) 
double grade = 0.0; // Primitive type
Double grade2; // Reference type (Object type)
Person x; // Reference type (Object type)

Declaring and Initializing Variables: Sample Program

1 public class VariableSamples { 2 public static void main( String[] args ){ 3 // declare a data type with variable name 4 // result and boolean data type 5 boolean result; 67 // declare a data type with variable name 8 // option and char data type 9 char option;
10 option = 'C'; //assign 'C' to option
11
12 // declare a data type with variable name
13 // grade, double data type and initialized
14 // to 0.0
15 double grade = 0.0;
16
}
17 } 

Outputting Variable Data: Sample Program

1 public class OutputVariable {
2 public static void main( String[] args ){
3 int value = 10;
4 char x;
5 x = ‘A’;
6
7 System.out.println( value );
8 System.out.println( “The value of x=“ + x );
9 }
10 } 

The program will output the following text on screen:

10

The value of x=A

System.out.println() vs. System.out.print()

  • System.out.println() 
    • Appends a newline at the end of the data output 
  • System.out.print() 
    • Does not append newline at the end of the data output

Lab: Exercise 1: Variables 1002_javase_progbasics.zip

Primitive Data Types

  • The Java programming language defines eight primitive data types. 
    • boolean (for logical)
    • char (for textual) 
    • byte 
    • short 
    • int 
    • long (integral)
    • double 
    • float (floating point).
  • Used to hold non-Object values (non-Reference type values) 
  • In Java, they are provided for higher performance for compute-intensive applications 
    • Other programming languages might not have primitive types.

Primitive Data Types: Logicalboolean

  • A boolean data type represents two states: true and false
  • An example is:
 boolean result = true;
  • The example shown above, declares a variable named result as boolean type and assigns it a value of true.

Primitive Data Types: Textual-char

  • A character data type (char), represents a single Unicode character.
  • It must have its literal enclosed in single quotes(’ ’)
‘a’ //The letter a
‘\t’ //A tab 
  • To represent special characters like ' (single quotes) or " (double quotes), use the escape character \
'\'' //for single quotes
'\"' //for double quotes 

 Primitive Data Types: Integral – byte, short, int & long 

  • Integral data types in Java uses three forms – decimal, octal or hexadecimal. 
  • Examples are,
2 //The decimal value 2
077 //The leading 0 indicates an octal value
0xBACC //The leading 0x indicates a hex value
  • You can define its long value by appending the letter l or L 10L

Primitive Data Types: Integral – byte, short, int & long

  • Integral data type have the following ranges:

Integral data type

Primitive Data Types: Floating Point – float and double

  • Floating-point literal includes either a decimal point or one of the following,
E or e //(add exponential value)
F or f //(float)
D or d //(double) 
  •  Examples are,
3.14 //A simple floating-point value (a double)
6.02E23 //A large floating-point value
2.718F //A simple float size value
123.4E+306D//A large double value with redundant D 

Primitive Data Types: Floating Point – float and double

  • Floating-point data types have the following ranges:

Floating-point data types

Lab: Exercise 2: Compute Average & Sum 1002_javase_progbasics.zip

Operators 

  • Different types of operators: 
    • Arithmetic operators 
    • Relational operators 
    • Logical operators 
    • Conditional operators 
  • These operators follow a certain kind of precedence so that the compiler will know which operator to evaluate first in case multiple operators are used in a single statement

Arithmetic Operators

Arithmetic Operators

Increment and Decrement Operators

  • Unary increment operator (++) 
  • Unary decrement operator (--) 
  • Increment and decrement operators increase and decrease a value stored in a number variable by 1. 
  • For example, the expression,
count=count + 1; //increment the value of count by 1
  • is equivalent to,
count++; // same as above 

Increment and Decrement Operators

The increment and decrement operators can be placed before or after an operand

++a or a++ 

When used before an operand, it causes the variable to be incremented or decremented by 1 first, and then the new value is used in the expression in which it appears.

int i = 10;
 int j = 3;
 int k = 0;
 k = ++j + i; // j =4, k = 4+10 = 14

When the increment and decrement operators are placed after the operand, the old value of the variable will be used in the expression where it appears.

int i = 10;
int j = 3;
int k = 0;
k = j++ + i; // k = 3+10 = 13, j = 4 

Relational Operators

  • Relational operators compare two values and determines the relationship between those values. 
  • Output of evaluation is boolean value: true or false.

 Relational Operators

Logical Operators

  • Logical operators have one or two boolean operands that yield a boolean result.
  • There are six logical operators: 
    • && (logical AND) 
    • & (boolean logical AND) 
    • || (logical OR) 
    • | (boolean logical inclusive OR) 
    • ^ (boolean logical exclusive OR)
    • ! (logical NOT)

Logical Operators: &&

  • Here is the truth table for && and &,

Logical Operators: &&

Logical Operators: ||

  • Here is the truth table for ||

Logical Operators: ||

Logical Operators: ^ (boolean logical exclusive OR)

  • Here is the truth table for ^,

boolean logical exclusive OR

  • The result of an exclusive OR operation is TRUE, if and only if one operand is true and the other is false. 
  • Note that both operands must always be evaluated in order to calculate the result of an exclusive OR.

Logical Operators: ! ( logical NOT)

  • The logical NOT takes in one argument, wherein that argument can be an expression, variable or constant. 
  • Here is the truth table for !,

logical NOT

Logical Operators: Conditional Operator (?:)

  • The conditional operator ?: 
  • is a ternary operator. 
    • This means that it takes in three arguments that together form a conditional expression. 
  • The structure of an expression using a conditional operator is
exp1?exp2:exp3 
  • wherein, exp1 - is a boolean expression whose result must either be true or false
  • Result:
    • If exp1 is true, exp2 is the value returned.
    • If it is false, then exp3 is returned.
1 public class ConditionalOperator {
2 public static void main( String[] args ){
3 String status = "";
4 int grade = 80;
5 //get status of the student
6 status = (grade >= 60)?"Passed":"Fail";
7 //print status
8 System.out.println( status );
9 }

Conditional Operator

 

Operator Precedence

  • Given a complicated expression, 6%2*5+4/2+88-10 
  • we can re-write the expression and place some parenthesis base on operator precedence, ((6%2)*5)+(4/2)+88-10;

Lab: Exercise 3: Conditional Operator Exercise 4: Find Greatest Number 1002_javase_progbasics.zip

  Download Course Content: