Programovací jazyk Java SE

Programovací jazyk Java SE
Petr Adámek

Content Course introduction Basic APIs in Java
Object oriented programing in Java Collections in Java I/O in Java Data types Introduction to functional programming in Java Program flow control Interface Rules for writing well maintainable code Inheritance Unit tests, JUnit

Course Introduction

Introduction: Lector Ing. Petr Adámek
Commercial programming since 1994 Java / Java EE developer since 2001 Java / Java EE lector at FI MU since 2002 Commercial trainings since 2004 Leading Java Trainee Programs since 2012 Independent consultant and lector since 2017

Introduction: You Your name Your experience Your expectations

Resources Effective Java (2nd Edition) Joshua Bloch

Resources Clean Code: A Handbook of Agile Software Craftsmanship
Robert C. Martin

Resources Refactoring: Improving the Design of Existing Code
Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts

Resources Design Patterns: Elements of Reusable Object-Oriented Software Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

Resources Javadoc Java Core API
Documentation of the contract of the classes For JavaCore API, libraries and also your classes Java Core API

The Most Important Rule
KISS

Java Programming Language
3rd generation language (3GL) – imperative high-level language Universal language – not specialized for particular application area Object-oriented language Inspired by C++ and Smalltalk Current java version is 9, information in this training is valid for version 8 and newer

Java Programming Language
Helps to develop robust applications Strong type system Virtual machine with runtime security checks Garbage collector, no pointer arithmetic Stable libraries Supports the creation of the right habits and systematically prevents the transmission of some bad habits from other languages.

Tools Netbeans IDE Maven Git JUnit

Practical exercise: First program in Java
Clone repository exercises.git git clone Checkout branch javase git checkout javase Open first-java-program project in your IDE Run the program from IDE Run the tests Modify the program to let the tests pass successfully Run the program from command line

Java Virtual Machine Source code in Java (*.java) is compiled into bytecode, each class has it’s own file (*.class). This bytecode is executed by Java Virtual Machine, which is providing runtime environment for Java programs Write once, run everywhere Java has automatic memory management, memory is released automatically by garbage collector, when it is not needed anymore Programmer does not need to explicitly release the memory, however he still must be careful to not introduce memory leaks caused by forgotten references to unused objects

Packages Classes in java are organized via packages
Each package contains classes which are somehow relevant Program can contain multiple classes with the same name as long as they are in different packages (very useful for big projects or projects using lot’s of libraries) Package name is usually based on internet domain, e.g.: cz.bilysklep.trainings Class files are located in appropriate directory, e.g.: cz/bilysklep/trainings Fully qualified class name Consists of package name and class name: <package_name>.<class_name> Must be unique within the application (as long as we are using single classloader) e.g.: cz.bilysklep.trainings.basicjava.firstprogram.HelloWorld

Running java program Java Virtual Machine needs this information to start the program: Where the classes of the program are located Which class is the entry point of the program CLASSPATH defines list of locations with the classes Directories with *.class files *.jar archives (zip files with multiple classes for easier distribution) Locations are separated with : (unix/linux) or ; (windows) java -cp target/classes cz.bilysklep.trainings.basicjava.firstprogram.HelloWorld java -cp target/first-java-program-1.0-SNAPSHOT.jar cz.bilysklep.trainings.basicjava.firstprogram.HelloWorld

Object oriented programming in Java I.

Basic OOP concepts Abstraction Encapsulation Polymorphism Inheritance
Complexity of the object and implementation details are hidden, only relevant aspects are exposed Encapsulation Data are bound with the code that manipulates it Data and code are protected from external interference Polymorphism Different objects could behave differently when some method is called Inheritance Some object can acquire properties of another object

Java versus JavaScript
Language type Object oriented Syntax Based on C/C++ Memory management Automated, garbage collector Type system Statically typed Dynamically typed Object definition Class based Prototype based

OOP in Java Java has strong and static type system
Each variable or attribute has defined type Types are verified during compilation Structure of object is defined via Class Class represents type of object Defines structure of the object (attributes and methods) Example: Person, Car, Order Concrete occurrence of object is called Instance Example: Petr Adámek, Car with VIN 1FACP41E9MF105932, Order /2018.

Structure of the class Fields (Attributes) Methods Constructor
Represents properties of the object (name, age, VIN, customer, etc.) Define state of the object Methods Define behavior of the object Constructor Special method responsible for initialization of the object If no constructor is defined, empty no-args constructor is created automatically

Class example Fields Constructor Methods
public class Rectangle { private int width; private int height; public Rectangle(int width, int height) { this.width = width; this.height = height; } public int getWidth() { return width; public int getHeight() { return height; public int getArea() { int area = width * height; return area; Fields Constructor Methods

Variables There are three type of variables in Java
public class Rectangle { private int width; private int height; public Rectangle(int width, int height) { this.width = width; this.height = height; } public int getWidth() { return width; public int getHeight() { return height; public int getArea() { int area = width * height; return area; There are three type of variables in Java Field – attributes of the object, exists for the whole lifespan of the object Local variable – temporary variable, exists only until end of code block Method (or constructor) parameter - special type of local variable, which can be used for passing information into method Parameters can be used as regular local variable and the value can be changed in the method, but it is considered as bad practice. Each variable must be explicitly declared with type (all variables in the example have type int). When the attribute has the same name as the local variable or parameter, it can be accessed with prefix this. Fields Parameters Local variable

Methods and Constructors
public class Rectangle { private int width; private int height; public Rectangle(int width, int height) { this.width = width; this.height = height; } public int getWidth() { return width; public int getHeight() { return height; public int getArea() { int area = width * height; return area; Method declaration consist of Modifiers (public, protected, private, final, static, abstract, native) Return type (int in our example) or void if the method does not return a value The parameter list in parenthesis or empty parenthesis if there are no parameters List of exceptions (will be discussed later) Method body enclosed between braces Constructor declaration is the same except it does not have a return type

Access modifiers public class Rectangle { private int width; private int height; public Rectangle(int width, int height) { this.width = width; this.height = height; } public int getWidth() { return width; public int getHeight() { return height; public int getArea() { int area = width * height; return area; Access modifier determines context from which can be class member (e.g. field or method) accessed from public – class member can be accessed from anywhere protected – class member can be accessed from the same package or from the subclasses (will be discussed later) (no modifier) – class member can be accessed from the same package. private – member can be accessed only within class (or enclosing class). For now, we will follow these rules: All attributes will be private to ensure encapsulation. Method will be public if it is supposed to be called from other context, or private otherwise.

Referencing classes from other packages
Referencing classes from same package Just simple name (e.g. Person) is sufficient Referencing classes from other packages Fully qualified name must be used java.time.LocalDate localDate; Or class must be imported import java.time.LocalDate; // … LocalDate localDate;

Practical exercise: First class in Java 1
Open classes-and-instances project in your IDE Open class Person and implement tasks a1 – a8 according to instructions in comment Verify that the tasks are correctly fulfilled with PersonTest class

Working with objects Operator new Creates new instance of given class
Rectangle smallRectangle = new Rectangle(10, 6); Rectangle bigRectangle = new Rectangle(40, 20); int smallRectangleArea = smallRectangle.getArea(); int bigRectangleArea = bigRectangle.getArea(); System.out.println("Small rectangle area: “ + smallRectangleArea); System.out.println("Big rectangle area: " + bigRectangleArea); Operator new Creates new instance of given class Appropriate constructor is called Operator = Assigns value on the right side to variable on the left side Static members Members which are not related to specific instance Marked with static modifier Operator . Accessing object (or class) members <object>.<member> (nonstatic members) <class>.<member> (static members)

Working with objects Accessing members of the same class
public class Rectangle { private int width; private int height; public Rectangle(int width, int height) { this.width = width; this.height = height; } public int getWidth() { return width; public int getHeight() { return height; public int getArea() { int area = width * height; return area; Accessing members of the same class Operator . is usually not needed Special variable this can be used in case of ambiguity

Open classes-and-instances project in your IDE Open class Main and implement method main according the instructions in comment Open class MainTest, comment annotation and use this test class to verify is the task has been completed correctly.

Identifiers Identifiers are names of
Classes Methods Variables Packages Identifiers must be composed of letters, numbers, the underscore _ and the dollar sign $. Identifiers may only begin with a letter, the underscore or a dollar sign. Any Unicode letter can be used, however it is good practice to use only ASCII letters Identifiers with multiple words CammelCase – moreWordsHere Under_score – more_words_here Conventions Class name – cammelCase with capital first letter (e.g. OrderItem) Method or variable name – cammelCase with small first letter (e.g. orderItem) Constant – Under_score with all capital letters (e.g. FIRST_LINE_TEXT) Try to use as comprehensible identifiers as possible

Data types

Primitive and Object types
Primitive types byte, short, int, long, float, double, boolean, char value is stored directly in variable (local variable, parameter or field) Object types Objects, Interfaces, Arrays Object is allocated in the heap, variable contains reference Each primitive type has also appropriate object equivalent Byte, Short, Integer, Long, Float, Double, Boolean, Character String is object type

Operator == and Object.equals(Object)
Compares value of two variables In case of primitive types, the values are compared In case of object types, the value is actually the reference to the object. It means that the operator == is comparing the references (if both variables refers to the same object) Object.equals(Object) method Compares if the object has the same value as other object Concrete meaning is defined by concrete class (read JavaDoc of appropriate class)

Primitive and Object types
int p1 = 1; Integer o1 = new Integer(1); int p2 = 1; Integer o2 = new Integer(1); Integer o3 = o2; System.err.println(p1 == p2); // true System.err.println(o1 == o2); // false System.err.println(o1.equals(o2)); // true System.err.println(o2 == o3); // true Do not use operator == for comparing strings or other object values. 1 p1 Integer o1 1 1 p2 Integer o2 1 o3

Primitive types Type Description Size Min Max byte Integer 8 bits -128
127 short 16 bits 32 767 int 32 bits -231 231 – 1 long 64 bits -263 263 – 1 float IEEE 754 floating point 32 bits (24 + 8) ∼ -3.4 × 1038 ∼ 3.4 × 1038 double 64 bits ( ) ∼ -1.8 × 10308 ∼ 1.8 × 10308 boolean true/false value 1 bit false true char 16-bit Unicode character 65 535

Null value null value Special value which means that given variable does not contain reference to any object (it is empty) Any object type variable can have this value No primitive type variable can have this value When trying to dereference null value (i.e. calling method or accessing field), NullPointerException is thrown. Rectangle rectangle = null; int area = rectangle.getArea(); // NullPointerException will be thrown Null value is usually used to determine that the value is not known or unavailable (e.g. dateOfDeath for living person).

Primitive type or wrapper class?

Literals – decimal numbers
Decimal number format decimal number starts with 1 – 9 octal number starts with 0 hexadecimal number starts with 0x binary number starts with 0b underscore can be inserted anywhere Literal type int – by defualt long – L or l suffix (capital L is recommended, because l can be confused with 1) No literals for byte or short // int literals System.err.println(1_023); // decimal System.err.println(01777); // octal System.err.println(0x3FF); // hexdecimal System.err.println(0b ); // binary // long literals System.err.println(4_294_967_296L); System.err.println( L); System.err.println(0x1_0000_0000L); System.err.println(0b L);

Operace s celymi cisly, celociselne deleni
NaN, infinity, … Nepouzivat float a double tam, kde potrebujeme absolutni presnost a kontrolu nad zaokrouhlovanim (napr. Mena) Operator ?

Literals – floating point numbers
Floating point number format Optional + / − sign Number with optional decimal point Optional exponent Optional suffix (see below) must have either decimal point, exponent or suffix to distinguish it from an integer literal underscore can be inserted anywhere Literal type double – by default or D or d suffix float – F or f suffix // double literals System.err.println(1_500.0); System.err.println(1_500D); System.err.println(1.5e3); // 1.5 * 10^3 System.err.println(15_000e-1); // * 10^-1 System.err.println(.15e4); // 0.15 * 10^4 // float literals System.err.println(1_500.0F); System.err.println(1_500F); System.err.println(1.5e3F);

Literals – boolean, char and String
boolean literals true or false char literals single character closed by single quote (apostrophe) characters, e.g. 'a' String literals Sequence of characters closed by double quote characters e.g. "hello" Single quote in character literal or double quote in String literal must be prefixed with backslash (\) // boolean literals boolean b1 = true; boolean b2 = false; // char literals char c1 = 'a'; char c2 = '\''; // char with apostrophe // String literals String s1 = "Hello world"; String s2 = "String with \" character";

Escape sequences and Unicode Escapes
Description \t Insert a tab in the text at this point. \b Insert a backspace in the text at this point. \n Insert a newline in the text at this point. \r Insert a carriage return in the text at this point. \f Insert a formfeed in the text at this point. \' Insert a single quote character in the text at this point. \" Insert a double quote character in the text at this point. \\ Insert a backslash character in the text at this point. Unicode escapes allows to insert any Unicode character into source code \Uxxxx where xxxx is hexadecimal digits for UTF-16 code unit These codes are processed before any other processing Useful for making the source code ASCII-only It was used to make the source code independent on platform encoding. Modern way is to use UTF-8

Autoboxing / Autounboxing
Conversion between primitive type and appropriate object type is done automatically by compiler Integer o = 125; // Boxing int → Integer, equivalent to Integer o = Integer.valueOf(125); int p = o; // Unboxing Integer → int, equivalent to int p = o.intValue(); Only single conversion is performed long l1 = 125; // ok, conversion int → long Long l2 = 125L; // ok, boxing long → Long Long l3 = 125; // compilation fail, double conversion int → long → Long

Enum Enum is type with closed set of possible values
Month, Day of week, Unit, Gender, Marriage status Enum is class with exactly one instance for each possible value Values can be compared with == operator public enum DayOfWeek { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY; } DayOfWeek dayOfWeek = // ...; if (dayOfWeek == DayOfWeek.SATURDAY || dayOfWeek == DayOfWeek.SUNDAY) { System.out.println("Weekend is here!");

Enum Enum can be extended with Custom attributes Custom methods
public enum DayOfWeek { MONDAY(false), TUESDAY(false), WEDNESDAY(false), THURSDAY(false), FRIDAY(false), SATURDAY(true), SUNDAY(true); private final boolean weekend; private DayOfWeek(boolean weekend) { this.weekend = weekend; } public boolean isWeekend() { return weekend; DayOfWeek dayOfWeek = // ...; if (dayOfWeek.isWeekend()) { System.out.println("Weekend is here!");

Array An array is a container object that holds a fixed number of values of a single type. Value can be both primitive or object type It is recommended to use appropriate collection (e.g. List) instead of arrays Encapsulated Dynamic size Safer and more flexible Could be immutable or read-only Various implementations // create new array with size 5 int[] array = new int[5]; // accessing items array[0] = 14; int x = array[1]; // get array length int length = array.length; // initializing array int[] array2 = { 0, 1, 2 }; // array literal someMethod(new int[] { 0, 1, 2 });

Final keyword Variable marked with final modifier can’t change its value Caution! If the variable has object type and referenced object is mutable, the object can still change it’s value. Method marked with final modifier can’t be overriden (will be discussed later) Class marked with final modifier can’t be extended (will be discussed later)

Immutable classes Immutable classes How to make the class immutable
Classes which don’t change the state, state is set only when the instance is created It is safe to share the reference to instance Most of value classes in Java are immutable (String, Integer, LocalDate, etc.) How to make the class immutable Don’t provide any methods allowing to change the state Make all fields final Make the class final Make defensive copies of mutable fields – see Item 15 in Effective Java public final class Rectangle { private final int width; private final int height; public Rectangle(int width, int height) { this.width = width; this.height = height; } public int getWidth() { return width; public int getHeight() { return height; public int getArea() { int area = width * height; return area;

Constants Java does not have special support for constants
Constants are defined as static final fields public class RectangleMain { // Constant with primitive value - safe private static final int MAX_RECTANGLE_WIDTH =100; // Constant with immutable object value - safe private static final String HEADER_ROW = "List of rectangles"; // Constant with mutable object value - not safe ! private static final String[] HEADER_ROWS = { "First header row", "Second header row" }; private static final List<String> HEADER_ROWS_2 = Collections.unmodifiableList(Arrays.asList( "First header row", "Second header row")); }

Program flow control

Condition if if – simple condition
if(<condition>) then { <code> } if(<condition>) then { <code> } else { <code> } if (age < 18) { System.out.println("Person is minor"); } else { System.out.println("Person is adult"); } If the <code> contains only simple command, braces ({}) are not necessary, but still strongly recommended to avoid possible mistakes when changes are done later

Operators Logical operators == != && || !

Condition switch switch – same syntax as C
switch(<variable>) { case <option1>: <code> break; case <option2>: case <option3>: <code> break; default: <code> } switch(month) { case JANUARY: case MARCH: case MAY: case JULY: case AUGUST: case OCTOBER: case DECEMBER: System.out.println("month has 31 days"); break; case APRIL: case JUNE: case SEPTEMBER: case NOVEMBER: System.out.println("month has 30 days"); case FEBRUARY: System.out.println("month has 28 or 29 days"); default: throw new IllegalArgumentException( "Invalid month: " + month); }

Condition switch Switch can be used for these types
byte, short, char, int Byte, Short, Character, Integer Enum , String Common mistake is forgotten break command. Without break command, program execution continues with next lines until end of switch block or next break command is reached. Switch can be often replaced with polymorphism, which is considered as better practice in object oriented programming

Structural versus OOP approach
Switch based (structural) approach Polymorfism based (OOP) approach enum Operation { PLUS, MINUS } public int calculate(Operation operation, int a, int b) { switch(operation) { case PLUS: return a + b; case MINUS: return a - b; default: throw new IllegalArgumentException( "Unknwon operation: ” + operation); enum Operation { PLUS { public int calculate(int a, int b) { return a + b; } }, MINUS { return a - b; }; public abstract int calculate(int a, int b); public int calculate(Operation operation, int a, int b) { return operation.calculate(a, b);

Conditional operator (?)
<condition>?<trueValue>:<falseValue>

Cycles for cycle while cycle do-while cycle
for(int i = 0; i < 10; i++) { System.out.println(i); } int i = 0; while (i < 10) { i++; do { } while (i < 10);

For-each cycle for-each cycle is used for iteration over containers
Can be used for Arrays Classes implementing Iterable interface (e.g. collections; will be discussed later) int[] array = { 0, 1, 2, 3, 4 }; for (int item : array) { System.out.println(item); }

Object oriented programming in Java II.

Invariants Objects have usually some invariants which should be ensured Car must have VIN with valid format Date interval must start before end Items count in order must be > 0 Width or height of rectangle must be >= 0 Which invariants should have our Person class? Let’s change our Rectangle class to ensure mentioned invariant public class Rectangle { private int width; private int height; public Rectangle(int width, int height) { if (width < 0) { throw new IllegalArgumentException( "width is negative: " + width); } if (height < 0) { "height is negative: " + height); this.width = width; this.height = height; public int getWidth() { return width; public int getHeight() { return height; public int getArea() { return width * height;

Encapsulation Encapsulation Protects object from unexpected changes
Protects object from violating invariants Allows to modify implementation of the class without breaking existing code using the class Any change of object state should be done by calling some method public class Rectangle { private int width; private int height; public Rectangle(int width, int height) { if (width < 0) { throw new IllegalArgumentException( "width is negative: " + width); } if (height < 0) { "height is negative: " + height); this.width = width; this.height = height; public int getWidth() { return width; public int getHeight() { return height; public int getArea() { return width * height;

Overloading Class can have more methods with the same name or more constructors, if they have different signature (e.g. different count or type of parameters) Constructor can call another constructor using this keyword (it must be first statement) Java does not support operator overloading, however some operators (+, +=) are overloaded for String manipulation. public class Rectangle { private final int width; private final int height; public Rectangle(int sideSize) { this(sideSize,sideSize); } public Rectangle(int width, int height) { if (width < 0) { throw new IllegalArgumentException( "width is negative: " + width); if (height < 0) { "height is negative: " + height); this.width = width; this.height = height;

Methods of Object class
equals(Object) Creates copy of the object (if the class supports that) Compares this object with another one finalize() For cleaning resources, called automatically when the object is garbage collected hashCode() Hash value of the object, used especially by hash based collections (HashSet, HashMap) Don’t use it, implement explicit close() methods toString() wait(), wait(long), wait(long,int), notify(), notifyAll() String representation of the object getClass() methods of object monitor, related to threads, out of scope of this training Class of the object clone()

Open classes-and-instances project in your IDE Open class Person and implement tasks b1 – b7 according to instructions in comment Open class PersonATest and annotation at a5setName() test method Open class PersonBTest, comment annotation and use this test class to verify is the tasks have been completed correctly.

Interfaces

Interfaces Allows to separate the implementation of the object from the interface Good for defining the type of object We can completely change the class implementing the object without affecting the code which is using the object

Practical exercise: Unary functions
Open unary-functions project in your IDE Follow the instructions attached to the project

Inheritance

Inheritance Inheritance allows to define new class (subclass) by extending existing class (superclass) Subclass is type compatible with the superclass and can substitute superclass anywhere

Wrong or inappropriate use of inheritance
Inheritance should be used only if there is generalization- specialization relationship between the classes Good use of inheritance: Vehicle and Car Wrong use of inheritance: Point and Circle Inheritance is static relationship and should not be used when we need dynamic relationship Inappropriate use of inheritance: person – student – teacher

Method overriding Method overriding
Subclass can change the behavior of the method, which is defined in superclass (as long as it is not final class – will be discussed later)

Abstract classes Abstract class Mark with abstract keyword
Class with incomplete definition The purpose is to provide base for extension Can’t be instantiated Mark with abstract keyword Can have abstract method Method without implementation (like in interface)

Final method and classes
Method marked with final modifier Subclass can’t override such method Private method is automatically final Final class Class marked with final modifier Can’t be extended (it is not possible to create subclasses) Typical for immutable classes

Practical exercise: Graphic shapes
Open graphic-shapes project in your IDE Follow the instructions attached to the project

Unit testing

Unit testing Unit tests Basic rules
Low level components testing Isolated Basic rules Reproducible Deterministic Independent Cheap As good is the decomposition, as easy is to write unit tests

Tools Testing frameworks Assertion libraries Mocking libraries JUnit
TestNG Assertion libraries Hamcrest AssertJ Mocking libraries Mockito Jmock EasyMock

Practical exercise: Unit tests
Open unit-tests project in your IDE Follow the instructions attached to the project

Exceptions

Exceptions Exception is mechanism for handling errors and non-standard situations When anything is going wrong, exception is thrown and it must be somehow handled (explicitly or implicitly) Unlike the return value, it can’t be ignored (until the developer intentionally wants to ignore it, which is not good practice)

Exception types Throwable Error Unchecked Exceptions Exception
Does not need to be caught or propagated general superclass for all exceptions and errors Usually indicates bug in the code, in that case it does not make sense to handle it Error some critical failure, usually thrown by JVM (e.g. out of memory) Unchecked Exceptions Does not make sense to handle Exception Error or Runtime Exception Some error in the program or in the environment Checked Exceptions Could make sense to handle Runtime exception Other Throwable objects Must be caught or propagated Can be thrown anywhere in the code

Exception Creating exception Throwing exception Handling exception
Catching Propagating Cause of the exception Finally block Supressed exceptions Try-with-resources

Practical exercise: Messaging
Open messaging project in your IDE Follow the instructions attached to the project

Basic API

Basic API String manipulation Logging Manipulation with Date and Time
String, StringBuffer, StringBuilder Java.util.logging String internalization Slf4j Manipulation with Date and Time Storing configuration Properties Localization and internationalization Preferences Locale Formatting Message localization

Collections

Collections in Java Generic types in Java Basic collection types
List Set Map Queue Iteration over collection

Practical exercise: Student catalog
Open student-catalog project in your IDE Follow the instructions attached to the project (first part)

Input/Output

Input/Output Binary and Text streams in java Working with files
InputStream OutputStream Reader Writer Working with files Path File Files

Practical exercise: Student catalog
Open student-catalog project in your IDE Follow the instructions attached to the project (second part)

Introduction to functional programming in Java

Introduction to functional programming in Java
Inner classes in Java Lambda expressions Introduction to Streams

Rules for creating well maintainable code

Rules for creating well maintainable code
?

Thank you Petr Adámek petr.adamek@gmail.com + 420 777 336 088

Programovací jazyk Java SE

Similar presentations

Presentation on theme: "Programovací jazyk Java SE"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Programovací jazyk Java SE

Similar presentations

Presentation on theme: "Programovací jazyk Java SE"— Presentation transcript:

Similar presentations

About project

Feedback