SE 8
Daniel Reckerth
Content
1. Introduction
2. Structure of a Java class
3. The Java Environment: Compiler and Interpreter
4. Fundamental Building Blocks
5. Memory Allocation in Java
6. Operators and Statements in Java
7. Access Modifiers
8. Core Java APIs: Strings, Arrays
1. Introduction
• Java is a general-purpose programming language
• Follows the Object-oriented programming paradigm
• Announced in may 1995 and started as an internal corporate research by Sun
Microsystem in 1991
• Follows the WORA principle: “Write once, run anywhere”
• One of the most popular languages, especially for client-server web
applications
2. Java Class Structure
• Java is a class-based programming language
structure of a Java Class
3. The Java Environment: Compiler and Interpreter
• compiler: javac
• converts source code into bytecode
• checks all code and displays all errors
javac Hello.java
• interpreter: java
• converts bytecodes into specific OS
machine code
• reads line by line and interrupts itself for
each runtime error
java Hello students
argument
4. Java Fundamental Building Blocks
• Java classes have two primary elements:
• fields known as variables – hold the state of the program
members of the class
• methods – operate on the state
• comments: /**
* Models a student.
*
* @author Daniel Reckerth
*/
public class Student {
// the name of the student
String name;
/* Age of the
* student
*/
int age;
public String getName() {
return name
}
public void setAge(int newAge) {
age = newAge;
}
}
Main method and Packages
• Java starts execution with the main() method
• it is the entry point of a Java process
• Java places classes in packages (similar to file cabinet)
• their names are in a hierarchy like a mail
• java.lang package is automatically imported - it is redundant to import it
package mypackage;
import java.util.*;
public class Main {
public static void main(String[] args) {
Random r = new Random();
System.out.println("Hello number “ + r.nextInt(10));
}
}
Constructors
• a class is a template
• instance of a class is an object
• creating it using new : MyClass myClassName = new MyClass();
• the variable name is a place to store a reference to our object
• by default is null
• we used a constructor, which is a method to create a new object
• it always matches the name of the class
• it has no return type
public class MyClass {
public MyClass() {
System.out.println("This is my class");
}
}
Code Blocks
• code block is the code between { } – have their own scope
• they can be inside a method – run when the method is called
• they can be outside a method – called instance initializers
• they are run in the order in which they appear
public class MyClass {
private String name = "Daniel";
{ System.out.println("set a field"); } // instance initializer
public MyClass() {
System.out.println("This is my class");
}
}
Java Types
Primitive Size Default Wrapper
type value type
boolean - false Boolean
byte 8-bit 0 Byte
short 16-bit 0 Short
int 32-bit 0 Integer
long 64-bit 0L Long
float 32-bit 0.0f Float
double 64-bit 0.0d Double
char 16-bit \u0000 Character
Unicode
Variable Types and Scope
• local variables
• defined within a method, must be initialized before use
• scope local to the method or smaller to the block of code
• instance variables
• called fields
• given default value (0/false – primitives, null- objects)
• available as soon as defined and last for the entire life of the object
• class variables
• shared across multiple object
• contain keyword static before them
• given default value
• go into scope when declared, stay for the entire life of the program
5. Java Memory
• 3 main components Meta-space
• meta-space
• stack
• heap
• Garbage Collector String Pool
• automatic process by which Java
perform memory management
• works on the heap ONLY
• System.gc() – calls it but it is not
guaranteed to run (suggests only)
• finalize() – called if the GC
tries to collect the object; can run
zero or one time Stack Heap
JVM
6. Operators and Statements
• operator = special symbol which can be applied to variables, values, literals
and returns a result operands
• types: unary, binary, ternary
• unless overridden with () Java operators follow the order of operations
• if two operators have the same level of precedence left-to-right evaluation
Precedence Operators Type Associativity
15 () [] . parenthesis, array subscript, member selection left -> right
6. Operator Precedence
14 post ++ -- unary post in/decrement
pre ++ -- unary pre in/decrement
+ - ! ~ unary plus, minus, log. neg. bitwise complement right -> left
13
(type) unary type cast
12 * / % multiplication, division, modulus
11 + - addition, subtraction
<< >> >>> bitwise left, right (with sign extension) shift and right shift
10 with zero extension
< <= > >= relational operators
9 instanceof type comparison (objects only)
8 == != equality
left -> right
7 & bitwise AND
6 ^ bitwise XOR
5 | bitwise OR
4 && logical AND
3 || logical OR
2 ?: ternary
= += -= *= /= %= &= right -> left
1 ^= |= <<= >>= assignment
<<<=
Operators Examples and Numeric Promotion
• if two values have different data types => Java promotes the smaller to the
larger one
• promotion of integral to floating-point
• smaller integral types promoted firstly to int when used with a arithmetic
operator
• after all promotions the result will have the same data type as its promoted
operands
• examples:
int x = 1; short x = 5;
1) promote x to int
long y = 50L; float y = 50;
2) promote int x to float
// int x promoted to long double z = 30;
3) promote x * y to double
long z = x * y; double r = x * y / z;
Java Statements
• complete unit of execution terminated with ;
• control flow statements
• applied to single expressions or code blocks
• examples:
• if, if-then-else
• switch
• while
• do-while
• for
• advanced flow control:
• nested loops
• adding optional labels
• break and continue statements
Java Statements
if, if-then-else switch
if (<condition>) { switch(<test_variable>) {
// code case <label 1>:
} // case body 1
break; <test_variable> must be of type
… char, byte, short, int or
if (<condition>) { case <label n>: String literal
// code // case body n
} else { break;
// code default:
} // default code
}
Java Statements
while loop do-while loop
executed at least once
while (<condition>) { do {
// code // code
} } while(<condition>);
for loop
for(<initialization>; <condition>; <increment>) {
// code enhanced for loop
}
for(<datatype_instance> : <collection>) {
// code
}
Advanced Flow Control
• if statements and loops can be nested, i.e. contain other loops or statements in tem
• if-then statements, switch and loops can have optional labels
OUTER_LOOP: for(int i = 0; i < rows; i++) {
INNER_LOOP: for(int j = 0; j < cols; j++) {
System.out.println(table[i][j] + "\t");
}
}
• break transfer flow of control out to the enclosing statement
• continue causes flow to finish the execution of the current loop (applied to the nearest
inner loop)
• can be used with labels
7. Access Modifiers
• private – "Visible to myself"
• private to the class
• protected – "Visible to the family"
• can be seen by the class, all subclasses, and other classes within the same package
• public – "Visible to all"
• can be seen by all classes
• default access modifier – "Visible in the neighborhood"
• public to members of same package
• private to anyone outside the package
• called package access
8. Core Java APIs: String, Arrays
• core data structures and classes: String, StringBuilder, StringBuffer, Arrays, ArrayList,
Dates and Times
• Java has no primitive type for strings, therefore we have the String class
• a string is a sequence of characters
• it can be given the value of a String object
String name = "Daniel";
String name = new String("Daniel");
• +, += applied on a String operand means concatenation
String fullName = "Daniel" + "Reckerth"; // DanielReckerth
String s = "one" + 1; // one1
• Strings are immutable, i.e. they are not allowed to change once created
• in Java String indexes starts from 0
String Cont'd.
• important methods include:
• length() – returns the number of characters in the string
• charAt() – return the character at the specified index
• substring() – return the part of the string specified in the range
• indexOf() – returns the index of the specified character
• toLowerCase(), toUpperCase() – make characters lower, upper case (original
string does not change)
• equals(), equalsIgnoreCase() – check whether two strings contains exactly the
same characters in the same order
• startsWith(), endsWith() – provided value matches part of the string's beginning/
ending
• contains() – looks for matches in the string
• replace() – replaces the specified character with a new one
• trim() – remove whitespaces from the beginning and end of a string
• method chaining
String result = "AniMaL ".trim().toLowerCase().replace('a','A'); // "Animal"
String str = "Learning";
// length
System.out.println(str.length()); // 8
// charAt()
System.out.println(str.charAt(0)); // L
// substring()
System.out.println(str.substring(3)); // "rning"
System.out.println(str.substring(3,6)); // "ni"
// indexOf()
System.out.println(str.indexOf('a')); // 2
System.out.println(str.indexOf("ear")); // 1
System.out.println(str.indexOf('n', 6)); // 6
System.out.println(str.indexOf("ni", 4)); // -1
// toLowerCase(), toUpperCase()
System.out.println(str.toLowerCase()); // "learning"
System.out.println(str.toUpperCase()); // "LEARNING"
// equals(), equalsIgnoreCase()
System.out.println("abc".equals("ABC")); // false
System.out.println("abc".equalsIgnoreCase("ABC")); // true
// startsWith(), endsWith()
System.out.println("abc".startsWith("a")); // true
System.out.println("abc".endsWith("b")); // false
// contains()
System.out.println("abc".contains("a")); // true
System.out.println("abc".contains("B")); // false
// replace()
System.out.println("abcabc".replace('a', 'A')); // AbcAbc
System.out.println("abcabc".replace("a", "A")); // AbcAbc
// trim()
System.out.println("abc".trim()); // abc
System.out.println("\t a b c\n".trim()); // a b c
StringBuilder and StringBuffer
• provided by Java in order to create strings without storing additional String values
• they are mutable
• reuse the same StringBuilder/StringBuffer without creating additional Strings each time
• they change their own state and return a reference to themselves
• creating a StringBuilder – same goes for StringBuffer
StringBuilder sb1 = new StringBuilder();
StringBuilder sb2 = new StringBuilder("learning");
StringBuilder sb3 = new StringBuilder(10);
• they have most of the methods presented before on Strings
• in addition we have:
• append() – add the parameter to the sequence and returns a reference to the current one
• insert() – adds character to the sequence at the requested index and returns a reference to the
current Builder/Buffer
• delete(), deleteCharAt() – remove character from the sequence
• reverse() – reverses the characters in the sequence
• toString() – convert StringBuilder/StringBuffer into a String
StringBuilder and StringBuffer
// append
StringBuilder sb = new StringBuilder();
sb.append("hello").append(" world").append(", ").append(2021); // "hello world, 2021"
// insert
sb.insert(sb.length, "!"); // "hello world, 2021!"
// delete
sb.delete(0,6); // "world, 2021"
sb.deleteCharAt(sb.length – 1); // "world, 2021"
// reverse
sb.reverse(); // "1202 ,dlrow"
// toString
String s = sb.toString();
StringBuilder vs StringBuffer
StringBuilder StringBuffer
not thread safe, i.e. two threads can thread safe, i.e. cannot be accessed by
access its methods at the same time multiple threads simultaneously
non-synchronized methods synchronized-methods
faster performance slower performance
Java Arrays
• indexed collection of data of the same type
• in Java it is a reference data type
• use new operator to allocate the memory
• use indexed expression to refer to individual values
• Java uses zero-based indexing
• an array has a public constant length, i.e. we do not use method call
• fixed-size array declaration (Problems?)
• we can have arrays of primitives or arrays of objects
• however, an array of characters is not a String, but it can be converted
char[] arr = {'A', 'B', 'C'};
String str = a; // Illegal
String str = new String(a); // Legal
String str = new String(a,0,2); // Legal – uses subrange -> "AB"
Java Arrays
• creating an array: int[] data int [] data int data[] int data [] – all valid
int[] data = new int[3]; // array of ints of size 3
data[0] = 56;
data[1] = 272;
String[] names = {"Vlad", "Alexandra", "Tudor"}; // allocates space for a
reference to where the objects are stored
Java Arrays
• sorting an array – import java.util.Arrays
int[] numbers = {7,29,1,3};
String[] strings = {"10", "7", "100"};
Arrays.sort(numbers); • searching – if already sorted
Arrays.sort(strings);
// 1, 3, 7, 29 • found – return index
for (int number : numbers) {
System.out.print(number + " ");
• not found – negative index, one smaller
} than the negative of the index, where
inserted it will keep the order
// 10 100 7 – alphabetic order int[] numbers = {1, 3, 7, 29};
for (String str : strings) { int res = Arrays.binarySearch(numbers,7); // 2
System.out.print(str + " "); res = Arrays.binarySearch(numbers, 1); // 0
} res = Arrays.binarySearch(numbers, 2); // -2
Java Arrays
• multidimensional arrays – 2, 3 or more
• declaration using pairs of []
• examples
char[][] board = new char[3][3]; int[][] sizes = {{1,4}, {3}, {9,8,7}};
char[0][0] = 'O'; System.out.println(int[0][1]); // 4
char[0][1] = 'X';
char[1][1] = 'X';
ArrayList
• fixed-size arrays problems:
• not enough capacity for the task
• wasted space
• not knowing how many elements will be when creating it
• ArrayList is similar to a StringBuilder
• it can change its size at runtime as needed
• creating it:
ArrayList arrList1 = new ArrayList();
ArrayList arrList2 = new ArrayList(10);
ArrayList arrList3 = new ArrayList(arrList2);
ArrayList<String> arrList4 = newArrayList<>(); // using generics allowing type specification
List<String> arrList5 = new ArrayList<>(); // ArrayList implements the List interface
ArrayList
• main methods
• add() – inserts a new value in the array list
• remove() – removes first matching value in the array list or the element specified at an index
• set() – change one of the elements of the list without changing the size
• isEmpty(), size() –returns true if the array list is empty, otherwise false; returns the size
• clear() –discard all elements of the array list
• contains() – checks whether a certain value is in the array list
• equals() – compare two lists to see if they have the same elements in the same order
ArrayList
// add
ArrayList list = new ArrayList();
list.add("Java"); // [Java]
list.add("Daniel"); // [Java, Daniel]
list.add(Boolean.TRUE); // [Java, Daniel, TRUE] – allowed because we have not specified a type
list.add(1, "Adelin"); // [Java, Adelin, Daniel, TRUE]
list.add(2, "Andrei'); // [Java, Adelin, Andrei, Daniel, TRUE]
// remove
System.out.println(list.remove(4)); // TRUE [Java, Adelin, Andrei, Daniel]
System.out.println(list.remove("Daniel")); // Daniel [Java, Adelin, Andrei]
// set
list.set(0, "Victor"); // [Victor, Adelin, Andrei]
// isEmtpy, size()
System.out.println(list.isEmpty()); // false
System.out.println(list.size()); // 3
// contains
System.out.println(list.contains("Andrei")); // true
