Lecturer

Eric Medvet

• Associate Professor of Computer Engineering at Departmenet of Engineering and Architecture, University of Trieste
• Online at: medvet.inginf.units.it

Research interests:

• Evolutionary Computation
• Machine Learning applications

Labs:

• Evolutionary Robotics and Artificial Life lab
• Machine Learning lab

Materials

Teacher slides:

• available here
• might be updated during the course

Intended usage:

• slides should contain every concept that has to be taught/learnt
• but, slides are designed for consumption during a lecture, they might be suboptimal for self-consumption $\rightarrow$ take notes!

Exam

Two options:

1. project + written test + home assignments
   • grade: weighted average with weights 60%, 30%, 10%
2. project + written test + oral exam
   • grade: weighted average with weights 40%, 30%, 30%

Failed if at least one part is graded <6/10.

Home assignments

Home assignments:

• short exercise assigned during the course
• will start in the classroom, under teacher's supervision
• student's output to be submitted within the deadline, one for each assignment
• grade, for each assignment:
  • 0/10: not submitted or missed deadline
  • up to 5/10: submitted, but not working
  • up to 8/10: submitted and almost working
  • 10/10: submitted and fully working
• grades communicated during the course

More details at first assignment.

List of exercises and home assignements

Just for reference:

1. Anagrams (also assignment)
2. Equivalence (also assignment)
3. File array
4. Compressed file array (also assignment)
5. Word counter server

Project

Project:

• assigned at the end of the course
• student's output: software, tests, brief document
• to be submitted within the exam date
• grade:
  • 0/10: not submitted or missed deadline
  • 5/10 to 10/10: submitted, depending on
  • quality of code
  • software structure
  • document (mainly clarity)
  • test coverage
  • degree of working

More details at project assignment.

Written test and oral exam

Written test:

• a few questions with short open answers and short programming exercises

Oral exam:

• questions and short programming exercises

Course content

In brief:

1. Java as object-oriented programming language
2. Tools and methods for programming
3. Distributed programming

See the syllabus!

Exercises

There we'll be several exercises:

• approx. 20h on 72h
• sofware design and implementation exercises
• bring your own device
• in classroom
  • with the teacher actively investigating about your progresses

Practice is fundamental!

Computational thinking is an outcome of the coding practice. See Nardelli, Enrico. "Do we really need computational thinking?." Communications of the ACM 62.2 (2019): 32-35.

You?

• How many of you already know object-oriented programming?
• How many of you already know Java?

Why Java?

Practical motivations:

• write once, run anywhere
• large community support, solid tools, many APIs
• free

Teaching-related motivations:

• favors abstraction
• realizes many key concepts of programming and languages

Language, platform

Java is both:

• a programming language
• a software platform

We will focus on:

• (mainly) the programming language
• (secondarily) the Java 2 Platform, Standard Edition (J2SE)

Java platform

Mailnly composed of:

• an execution engine
• a compiler
• a set of specifications
• a set of libraries, with Application Program Interfaces (APIs)

Platforms (also called editions) differ mainly in the libraries. Most common editions:

• Java 2 Platform, Standard Edition (J2SE): for general-purpose, desktop applications
• Java 2 Platform, Enterprise Edition (J2EE): J2SE + APIs/specifications for multi-tier client-server enterprise applications

Main tools

What is needed for developing in Java?

• Java Development Kit (JDK), absolutely necessary
• API documentation (briefly javadoc)
• Integrated Development Environment (IDE)
  • many options
  • when used proficiently, makes development more efficient and effective

JDKs

One JDK per (vendor, platform, version, os+architecture).

A few options:

• Oracle JDK
• OpenJDK

JDK versions

We are currently at version 13. History from Wikipedia:

Java IDEs

Many excellent options.

Classic, desktop-based:

• Apache NetBeans
  • the one I know better
• Jetbrains IntelliJ IDEA
• Eclipse IDE

Cloud-based:

• Full: Codenvy, Eclipse Che + OpenShift
  • steeper learning curve
• Light: CompileJava.net, repl.it

IDE: your best friend

Pros:

• makes typing much faster
• greatly helps following conventions
• makes software lifecycle operations faster
• helps finding errors

Cons:

• steep learning curve
• may hide some programming/development concepts

.java vs. .class files

• The source code is in one or more .java files
• The executable code is in one or more .class files

Compilation: obtaining a .class from .java

javac Greeter.java

Class-file

.java contains exactly one class definition (common case)

public class Greeter {
  //...
}

Or it contains more than one class definitions, at most one non-inner has the public modifier (we will see):

public class Greeter {
  //...
}
class Helper {
  //...
}

public class Greeter {
  //...
  public class InnerHelper {
    //...
  }
}

Compilation results always in one .class for each class definition!

Execution

An application is a .class compiled from a .java that has a "special function" main

public class Greeter {
  public static void main(String[] args) {
    \\...
  }
}

An application can be executed:

java Greeter

Or java Greeter.class, or in other ways

Class and the virtual machine

• A .class file contains executable code in a binary format (bytecode)
• The bytecode is interpreted by a program (java) that simulates a machine: the Java Virtual Machine (JVM)

JVM:

• like a real machine, but simulated: it has an instruction set and manages memory
• agnostic with respect to the physical machine
• does not know Java language, knows bytecode

JVM language

An example of the JVM specification, the instruction iadd:

Portability

A .class executable can be executed on any machine for which a program exists that simulates the JVM (i.e., a java).

"One" .java compiled to "one" .class, can be executed:

• on Linux x64, with the java program for Linux x64
• on Solaris SPARC x64, with the java program for Solaris SPARC x64
• Mac OS X, Windows, Android, ...

$\rightarrow$ Write once, run anywhere

Who executes what

Note:

• the OS executes java
• java executes the bytecode
  • simulates the JVM which executes the bytecode
• the OS cannot execute the bytecode!

Where is java?

java is part of the Java Runtime Environment (JRE), which includes also necessary libraries. The JRE is part of the JDK.

The JDK contains (mainly):

• the compiler javac
• the JRE (including java)
• many compiled classes (.class files)
• other development tools

It does not contain:

• the classes source code
• the documentation

Inside the JDK

eric@cpu:~$ ls /usr/lib/jvm/java-11-openjdk-amd64 -la
totale 48
drwxr-xr-x  2 root root  4096 feb  6 12:08 bin
drwxr-xr-x  4 root root  4096 feb  6 12:08 conf
drwxr-xr-x  3 root root  4096 feb  6 12:08 include
drwxr-xr-x  6 root root  4096 feb  6 12:08 lib
...

eric@cpu:~$ ls /usr/lib/jvm/java-11-openjdk-amd64/bin/ -la
totale 632
-rwxr-xr-x 1 root root  14576 gen 15 16:14 jar
-rwxr-xr-x 1 root root  14576 gen 15 16:14 jarsigner
-rwxr-xr-x 1 root root  14560 gen 15 16:14 java
-rwxr-xr-x 1 root root  14608 gen 15 16:14 javac
-rwxr-xr-x 1 root root  14608 gen 15 16:14 javadoc
...

Usually the JDK can be installed on the OS; but it can be simply uncompressed somewhere.

Documentation and source code

Do you need them?

• documentation: yes, in practice
• source code: no, but it can be useful for understanding

How to access the documentation?

• online: https://docs.oracle.com/en/java/javase/13/docs/api/index.html
• through IDE, often deeply integrated with autocompletion and suggestions

How to access the source code?

• download it
• download it in the IDE, access through the IDE (ctrl+click)

Consuming the documentation

Java: interpreted or compiled?

Both!

• .java to .class through compilation
• .class is then interpreted by java for being executed on OS

Actually, things are much more complex:

• on the fly optimization
• recompilation
• compilation to native code
• ...

Intepretation and efficiency

Is intepretation efficient?

• unrelevant question

Relevant question: is my software fast enough?

• it depends: measure!

If not?

1. profile
2. find opportunities for improvement
3. improve

(that is: write good code!)

The problem is rarely in interpretation!

Beyond speed of execution

When choosing a language/platform, speed of execution is just one factor.

Other factors:

• code maintainability
• documentation/support availability
• quality of development tools
• libraries availability
• ...
• previous knowledge
• ...

In general, consider all costs and assess options.

Hello goal!

public class Greeter {
  public static void main(String[] args) {
    System.out.println("Hello World!");
  }
}

Goal: deep understanding of this code

• not just what it "does"
• but the role of every part of the code

Take code highlighting with care!

Objects

"Things" (entities that can be manipulated in the code) are objects

• objects exist
• but do not have a name

The code manipulates objects through references

• references have a symbolic name, called identifier

Both can be created.

Creating objects and references

String s;

String s = new String("Content");

Many references

String s1 = new String("Content");
String s2 = s1;

• create reference s1 and make it reference the new objects
• create reference s2 and make it reference the object referenced by s1

Objects+references diagram: where? when?

• for now: in the memory of the JVM, conceptually.
• at runtime

No references

new String("Content1");
new String("Content2");

• create object of type String and init it with "Content1"
• create object of type String and init it with "Content2"

The two objects are not referenced: they cannot be manipulated!

Changing referenced object

String s1 = new String("Content1");
String s2 = new String("Content2");
s1 = s2;

• create reference s1, create new String inited with "Content1", and make s1 reference it
• create reference s2, create new String inited with "Content2", and make s2 reference it
• make s1 reference the object referenced by s2

Objects+references diagram

String dog1 = new String("Simba");
String dog2 = new String("Gass");
new String("Chip");
String squirrel2 = new String("Chop");
dog1 = dog2;
dog2 = dog1;
squirrel2 = squirrel2;

Manipulating objects

Key questions:

• which operations can be applied on an object?
• how to specify them in the code?
• can operations have parameters?

Manipulating objects

Answers (in brief):

• which operations can be applied on an object?
  • every object is an instance of a type
  • a type defines operations applicable to instances
• how to specify them in the code?
  • with the dot notation: refName.opName()
• can operations have input and output parameters?
  • input parameters can be specified between round brackets: refName.opName(otherRefName1, otherRefName2)
  • output can be referenced: retRefName = refName.opName()

We are just scratching the surface; we'll go deeper ahead.

Classes

A class is a type

• every object is an instance of a class
• (in a Java sofware) there are several classes
  • some are part of the Java language
  • some are part of APIs
• every application includes at least one class, defined by the developer

Classes

Some expressions that are clues of misunderstanding:

• "I wrote the code of an object"
• "X references a class"

Some correct expressions that hide complexity:

• "instantiating a X" (where X is a class)
  • means "creating an object of class X"

Primitive types

Some types are not classes, but primitive types:

• boolean
• char
• byte
• short
• int
• long
• float
• double

We'll discuss them later.

Methods

An operation applicable on a object is a method of the corresponding class.

Every method has a signature, consisting of:

• name
• sequence of types of input parameters (name not relevant)
• type of output parameter (aka return type)
  • possibly void, if there is no output

Examples (class String):

• char charAt(int index)
• int indexOf​(String str, int fromIndex)
• String replace​(CharSequence target, CharSequence replacement)
• void getChars​(int srcBegin, int srcEnd, char[] dst, int dstBegin)

Method invocation

String s = new String("Hello!");
int l = s.length();

• execute (who?) the operation defined by the method lenght() on the object referenced by s
  • briefly: invoke length() on s
• create reference l of type int
• make l reference the object created upon the execution of the operation

Can a method be invoked?

String s = new String("Hello!");
int l = s.length();

The compiler (javac) verifies (also) that:

• the type of s has a method with name length
  • briefly: s has a method length
• the method is used consistently with the signature
  • input and output types are correct

This check:

• is done at compile time (by the compiler)
• is much harder than it appears: we'll see
• is hugely useful for avoiding errors and designing good sofware

Colloquially, Java is said to be strongly typed.

Method overloading

A class can have many methods:

• with the same name
• but different input parameters

From another point of view: at most one method with the same (name, input parameters), regardless of the output type.

String s = new String("Hello!");
PrintStream ps = new PrintStream(/*...*/);
ps.println(s);

How many methods?

A lot of classes, a lot of methods!

You have to:

• use the documentation (briefly: javadoc)
• and/or proficiently use the IDE
  • autocompletion! (Ctrl+space)

Often, the signature alone is sufficient for understanding what the method does (e.g., int length() of String).

This is because who wrote the code for String correcly chose the signature: in particular the name.

There are naming conventions!

Naming conventions

Extremely important!

• code is not just for machines, it's for humans
• with code, a human tells another human about a procedure

Many of them: some just for Java, some broader.

• we'll see part of them, gradually

The degree to which naming conventions are followed concurs in determining the quality of the code.

There are many sources online: e.g., JavaPoint

Classes and methods

Class:

• a noun, a name of an actor: e.g., Dog, Sorter, Tree
• representative of the entity the class represents
• upper camel case (aka dromedary case): HttpServerResponse

Method:

• a verb, a name of an action: e.g., bark, sort, countNodes
  • with acceptable exceptions: e.g., size, nodes
• representative of the operation the method performs
• lower camel case: removeLastChar

References

Reference:

• consistent with the corresponding type
• representative of the specific use of the referenced object:
  • not every String has to be referenced by s
  • specific! e.g., numOfElements is better than n
• lower camel case

God gave us IDEs, IDEs give us autocompletion! Don't spare on chars.

Associative dot operator

String s = new String(" shout!");
s = s.trim().toUpperCase();

• invoke trim() on object referenced by s
• invoke toUpperCase() on the object resulting from trim() invocation
• make s reference the object resulting from toUpperCase() invocation

Objects and references diagram

String s = new String(" shout!");
s = s.trim().toUpperCase();

Constructor

Every class T has (at least) one special method called constructor that, when invoked:

• results in the creation of a new object of class T
• inits the new object

Special syntax for invocation using the new keyword:

Greeter greeter = new Greeter();

There are a few exceptions to this syntax:

• String s = "hi!"; same of String s = new String("hi!");

Initialization

What happens with initialization depends on the constructor.

Class Date: The class Date represents a specific instant in time, with millisecond precision.

Probably two different initialization outcomes:

Date now = new Date();
// some code doing long things
Date laterThanNow = new Date();

Multiple constructors

A class C can have more than one constructors:

• at most one with the same input parameters
• (the name and the return type are always the same)
  • name: the very same name of the class (e.g., Date $\rightarrow$ Date())
  • return type: C (e.g., Date $\rightarrow$ Date)

Class String:

Other example: Socket

Class Socket: This class implements client sockets (also called just "sockets"). A socket is an endpoint for communication between two machines.

Information hiding

The user of a class (that is, a developer possibly different than the one who developed the class):

• can use the class and operates on it
• does not know how it is coded

Class Date:

We can do non-trivial manipulation of dates (meant as entities) through the class Date without knowing its code!

Modularity

The user of a class knows:

• which operations exist, how to use them, what they do

He/she does not know:

• what's inside the object
• how exactly an operation works

The state of the object and the code of the class might change, but the user is not required to be notified of changes!

$\rightarrow$ Modularity: everyone takes care of only some part of the sofware!

Problem: complex numbers

Goal: manipulating complex numbers

By examples (i.e., point of view of the user):

Complex c1 = new Complex(7.46, -3.4567);
Complex c2 = new Complex(0.1, 9.81);
Complex c3 = c1.add(c2);
// same for subtract(), multiply(), divide()
double norm = c2.getNorm();
double angle = c2.getAngle();
String s = c2.toString();
double real = c2.getReal();
double imaginary = c2.getImaginary();

"Solution": Complex.java

public class Complex {
  private double real;
  private double imaginary;
  public Complex(double real, double imaginary) {
    this.real = real;
    this.imaginary = imaginary;
  }
  public double getReal() {
    return real;
  }
  public double getImaginary() { /* ... */ }
  public Complex add(Complex other) {
    return new Complex(
      real + other.real,
      imaginary + other.imaginary
    );
  }
  /* other methods */
}

IDE: code generation, auto formatting.

What's behind the solution?

Domain knowledge:

• what is a complex number? what are its composing parts? (entities)
• what are the required operations?

Knowledge of the programming language:

• how to represent the entities in Java?
• how to perform the operations in Java?

You need both!

• you can rely on external help, but you still need to know what you want to do
  • Google/stackoverflow: how to do X in Java?

Objects+references diagram

Complex c1 = new Complex(7.46, -3.4567);
Complex c2 = new Complex(0.1, 9.81);

Objects+references diagram

Complex c1 = new Complex(7.46, -3.4567);
Complex c2 = new Complex(0.1, 9.81);
Complex c3 = c1.add(c2);
double norm = c2.getNorm();

Field

A field is an object contained in an object:

public class Complex {
  private double real;
  private double imaginary;
  /* ... */
}
Complex c1 = new Complex(1.1, 2.2);

The fields of an object constitute its state.

They are referenced, there is an identifier:

Accessing fields

Can be manipuleted using dot notation, like methods:

public Complex add(Complex other) {
  return new Complex(
    real + other.real,
    imaginary + other.imaginary
  );
}

Access modifiers: private, public

Keywords that specify where an identifier is visible, i.e., where it is lecit to use it for accessing the field or method or other, we'll see.

• private: visible only within the code of its class
• public: visible everywhere

For brevity, we avoid discussing about syntax: but the Java language specification describes exactly where/how every keyword can be used.

private fields

File Complex.java:

public class Complex {
  private double real;
  /* here real can be used */
}
/* here real can not be used */

File ComplexCalculator.java:

public class ComplexCalculator {
  public Complex add(Complex c1, Complex c2) {
    /* here real can not be used */
  }
}

private or public: how to choose?

Ideally, it depends of the nature of the entity that the class represents (domain knowledge!)

But (general rule of thumb):

• fields should be private
  • because they represent the state of the object, and we want to avoid that the state is manipulated from "outside"
• methods should be public
  • because they are operations that can be performed on the object
  • unless we use a method for describing a "partial" operation that is reused frequently by other public operations: in this case, the method should be private

this identifier

It is the identifier of the reference that references the object on which the method, where this is, is being executed.

public class Complex {
  public Complex add(Complex other) {
    return new Complex(
      this.real + other.real,
      this.imaginary + other.imaginary
    );
  }
}

this is a keyword.

Implicit this

Can be omitted:

public class Complex {
  public Complex add(Complex other) {
    return new Complex(
      real + other.real,
      imaginary + other.imaginary
    );
  }
}

real and this.real reference the same object.

this for disambiguation

Sometimes it is necessary for disambiguation:

public class Complex {
  private double real;
  private double imaginary;
  public Complex(double real, double imaginary) {
    this.real = real;
    this.imaginary = imaginary;
  }
}

Before the line, real and this.real do not reference the same object.

This is the typical structure of a constructor: name of input parameters match the name of fields. As usual, the IDE is your friend and can write this code automaticaly!

Exported identifiers

A class (i.e., a .class file) exports some identifiers of:

• class or classes, but one per .class file
• methods
• fields

Access modifier can be omitted: default access modifier:

• private: not visible (~ not exported)
• public: visible
• default: visible

Package

A package is a set of classes with a name

• we'll see how to define it

A package exports the identifiers of its classes:

• private: not visible (~ not exported)
• public: visible
• default: visible only within the package

There are no many reasons for using the default access modifier; please always specify one between public and private (or protected, we'll see...)

Package name

A sequence of letters separated by dots, e.g.:

• it.units.erallab
• java.util
• java.util.logging

There is no formal hierarchy, nor relationship:

• java.util.logging is not a "subpackage" of java.util
• they are just different packages

Why and how?

Why package names?

• to avoid name clash that may be likely for classes representing common concepts
  • e.g., User, Point

How to name packages? (naming conventions)

• usually, (lowercase) reversed institution/company name + product + internal product organization, e.g., it.units.erallab.hmsrobots.objects.immutable
  • it.units.erallab: institution
  • hmsrobots: product
  • objects.immutable: internal organization

Beyond names:

• packages impact on file organization (we'll see, in directories)

Packages and modules

Since Java 9, a new, higher level abstraction for code entities organization has been introduced: Java Platform Module System (JPMS), briefly modules.

• they are interesting and useful, but...
• we'll complitely ignore
• you can build rather complex software without knowing them

API documentation

Fully qualified name

Every class is identified unequivocally by its Fully Qualified Name (FQN):

FQN = package name + class name

• java.net.Socket
• it.units.erallab.hmsrobots.objects.immutable.Component

Everywhere in the code, every* class can be identified by its FQN.

double r = 10;
it.units.shapes.Circle circle = new it.units.shapes.Circle(r);
double area = circle.area();

*: provided it is available; we'll see

The import keyword

Writing always the FQN can make the source code verbose, yet it is necessary, otherwise the compiler does not know which class we are referring to.

Solution (shorthand): import

import it.units.shapes.Circle;
public class ShapeCompound {
  private Circle circle;
  /* ... */
}

"import package.X" means "dear compiler, whenever I write X in this code, I mean package.X"

• the compiler internally always uses the FQN

Star import

It might be useful to "import" all the classes in a package:

• it can be done with import it.units.shapes.*;

Coding conventions suggest not to do it:

• risk: one might import an unneeded class with the same simple name of another class of the same package (e.g., java.awt.Event and it.units.timetable.Event)
• lack of motivation
  • IDEs add imports for you automatically, and can remove them partially automatically (autocompletion!)
  • so don't be lazy and messy

import for the developer

import is an optimization for the developer:

• recall: code is not just for the machine

import does not import code, classes, objects...

Point of view of the compiler

When the compiler processes the source code (.java) and finds a class identifier C:

• it needs to know its methods and fields (name, signature, modifiers)
• to be able to check if their usage is legit

If without FQN, the compiler looks for C definition:

• in the source code (.java)
• in the same package (directory)
• in the packages imported with star import

java.lang package

All classes of the java.lang packages are available by default:

• import java.lang.* is implicitly present in every source code

Syntax of FQNs

Package and class name cannot be identified just by looking at the FQN:

E.g., it.units.UglySw.Point:

• can be the name of a package
• or can be a FQN where:
  • Point is a class
  • or, UglySw.Point and UglySw are classes (we'll see)
  • or, units.UglySw.Point, units.UglySw, and units are classes, but the first is disrespectful of naming conventions!

Common case and convention: package name are all lowercase!

static field

A field of a class C can be defined with the static non-access modifier:

• the corresponding object is unique, that is, the same for every instance of C
• it always exists, even if no instances of C exist
  • if instantiated

From another point of view:

• the reference to a static field is shared (i.e., the same) among the zero or more instances of the class

static field: diagram

public class Greeter {
  public static String msg;
  private String name;
  /* ... */
}
Greeter g1 = new Greeter();
Greeter g2 = new Greeter();

static method

Also a method of a class C can be defined with static:

• when invoked, it is not applied on the instance of C
• can be invoked even if no instances of C exist, with a special syntax

The method code cannot access field or use other methods of C that are not static:

• they might not exist!
• the compiler performs the check (at compile time)

static method: syntax

public class Greeter {
  private static String msg;
  private String name;
  /* ... */
  public static String sayMessage() {
    return msg;
  }
}
String msg = Greeter.sayMessage(); /* OK! */
Greeter greeter = new Greeter();
greeter.sayMessage(); /* Syntax is ok, but avoid this form */

• greeter.sayMessage() is bad because it suggests that the instance greeter is somehow involved in this operation, whereas it is indeed not involved!
• only the "class" Greeter is involved

When to use static for methods?

Conceptually, a method should be static if it represents an operation that does not involve an entity represented by an instance of the class:

public class Dog {
  public static Dog getCutest(Dog dog1, Dog dog2) { /* ... */ }
  public static Dog fromString(String name) { /* ... */ }
}

static should be used also for private method, when condition above is met, even if they are not visible from outside (but other co-developers see it!)

Hello goal!

public class Greeter {
  public static void main(String[] args) {
    System.out.println("Hello World!");
  }
}

Goal: deep understanding of this code

• not just what it "does"
• but the role of every part of the code
  • keywords
  • names

main signature

public class Greeter {
  public static void main(String[] args) {
    System.out.println("Hello World!");
  }
}

• public $\rightarrow$ main has to be invoked "directly" by the JVM upon execution (java Greeter): it has to be accessible
• static $\rightarrow$ invokable without having an already existing instance of Greeter
• void $\rightarrow$ does not return anything

public static void main(String[]) is the signature required by Java if you want to use the method as an execution entry point!

• only the name of the input parameter can be modified

What is System.out?

public class Greeter {
  public static void main(String[] args) {
    System.out.println("Hello World!");
  }
}

• println is a method, since it is invoked ()
• System.out might be, in principle:
  1. the FQN of a class (and hence println is static in the class out)
  2. a field of a class (and hence out is static in the class System)

There is no package System (and out would be a class name out of conventions), hence 2 holds: System is a class

"Where" is System?

public class Greeter {
  public static void main(String[] args) {
    System.out.println("Hello World!");
  }
}

Where is System?

• more precisely, how can the compiler check that we correctly use out field of System?

There is no import, hence it can be:

1. there a System.class in the same directory of this .class, hence we wrote a System.java
2. System is in the java.lang package, that is always imported by default

2 holds: java.lang.System is the FQN of System

"What" is out?

public class Greeter {
  public static void main(String[] args) {
    System.out.println("Hello World!");
  }
}

Look at System class documentation (fields):

$\rightarrow$ out is a field of type PrintStream that represents the standard output.

What's the standard output? "Typically this stream corresponds to display output or another output destination specified by the host environment or user."

What is println()? How is it used?

public class Greeter {
  public static void main(String[] args) {
    System.out.println("Hello World!");
  }
}

Look at PrintStream class documentation (methods):

"Hello World!" is a string literal and corresponds to new String("Hello World!")

• hence println​(String x) is the used method

Involved classes

public class Greeter {
  public static void main(String[] args) {
    System.out.println("Hello World!");
  }
}

"Involved" classes:

• defined here: Greeter
• defined elsewhere, used here: System, String, PrintStream
  • System, String in java.lang; PrintStream in java.io

No import

No need to import PrintStream:

• import does not "load code"
• import says to the compiler that we will use a simple name for FQN in the source code
  • but we do not use PrintStream in the source code
  • there is an import for PrintStream in System.java (or FQN)

import java.io.PrintStream;
/* ... */
public class System {
  public static PrintStream out;
  /* ... */
}

Goal

Write an application that, given a word $w$ and a number $n$, gives $n$ anagrams of $w$.

Natural language and specification

"Write an application that, given a word $w$ and a number $n$, gives $n$ anagrams of $w$."

Natural language is ambiguous: this description leaves a lot of choices (and hence responsability) to the designer/developer:

• "an application": for which platform? are there technological constraints? (tech)
• "given": how? command line? file? standard input? (tech)
• "a word $w$": what is a word? (domain)
• "a number $n$": which kind of number? natural or real? (domain)
• "anagrams": what is an anagram? (domain)
• "$n$ anagrams": what if there are no enough anagrams? which ones, if more than $n$? (domain)

It's up to you to take these decisions!

More precise goal

In this particular case:

• a Java application, i.e., a class with a main()
• $w$ via standard input, $n$ via command line (customer)
• a word is a non-empty sequence of word characters (regex [A-Za-z]+)
• $n$ is natural
• anagram:
  • in general "a word or phrase formed by rearranging the letters of a different word or phrase" (from Wikipedia)
  • here (customer): permutation of multisets with repetitions
• show up to $n$, whichever you prefer

Execution flow control

Usual constructs available:

• if then else
• while
• for*
• switch*
• break
• continue
• return

I assume you know them!

*: with enhanced syntax that we will see later

Basic I/O

Where:

• input from standard input (aka stdin, typically, "the keyboard")
• output to standard output (aka stdout)

Of what:

• String
• primitive types

We'll see later how to do I/O of other things to/from other places

Output to standard output

Use System.out, static field out of class java.lang.System: it's of class java.io.PrintStream

The same for print(), that does not terminate the line.

And a very practical printf(), that we'll discuss later

Input from stdin with BufferedReader

BufferedReader reader = new BufferedReader(
  new InputStreamReader(System.in)
);
/* ... */
String line = reader.readLine();

• readLine() reads one line at once
  • Java takes care of using the proper line termination criterion (\n or \r\n) depending on the host OS how does it know?
• directly reads only strings
• requires adding throws Exception after the () in the signature of main
  • we ignore why, for now

Input from stdin with Scanner

Scanner scanner = new Scanner(System.in);
/* ... */
String s = scanner.next();
int n = scanner.nextInt();
double d = scanner.nextDouble();

• next(), nextInt(), ... do three things:
  1. reads one line from the InputStream it's built on
  2. splits the line in tokens (sep = " ")
  3. converts and returns the first token of proper type
• if the line "has" >1 tokens, they are consumed in subsequent calls of next*()

String to primitive type

Here, useful if you use BufferedReader for input.

String line = reader.readLine();
int n = Integer.parseInt(line);

Class Integer

Similar for other primitive types:

• Float.parseFloat(String)
• Double.parseDouble(String)
• ...

Arrays

Array: fixed-length sequence of objects of the same type

• each object is accessed with the operator [] applied to the reference to the array
• 0-based indexing

String[] firstNames;
String[] lastNames = new String[3];
lastNames[1] = new String("Medvet");

• Creates a reference firstNames to String[]; does not create the array; does not create the elements
• Creates a reference lastNames to String[]; create an array of 3 elements; does not create the elements
• Creates a String and makes lastNames[1] (2nd in the array) reference it

Diagram

String[] firstNames;
String[] lastNames = new String[3];
lastNames[1] = new String("Medvet");

Conventions

Name of arrays (i.e., identfiers of references to arrays):

• plural form of the corresponding reference
  • Person[] persons, Person[] employees, ...

Definition:

• Person persons[] is the same of Person[] persons, but the latter is much better:
  • it makes evident that the type is an array, rather than the identifier

Array creation

String[] dogNames = {"Simba", "Gass"};
//same of new String[]{"Simba", "Gass"}

is the same of

String[] dogNames = new String[2];
dogNames[0] = "Simba"; //same of = new String("Simba");
dogNames[1] = "Gass";

Array lenght

The type array has a field length of type int that contains the array size:

• never changes for the a given array
• cannot be written

String[] dogNames = {"Simba", "Gass"};
System.out.println(dogNames.length); //prints 2
dogNames = new String[3];
System.out.println(dogNames.length); //prints 3

dogNames.length = 5; does not compile!

Iterating over array elements

"Traditional" for syntax:

String[] dogNames = {"Simba", "Gass"};
for (int i = 0; i<dogNames.length; i++) {
  System.out.println("Dog " + i + " name is " + dogNames[i]);
}

Enhanced for (or for-each) syntax:

String[] dogNames = {"Simba", "Gass"};
for (String dogName : dogNames) {
  System.out.println("A dog name is " + dogName);
}

• the index is not available inside the loop
• can be applied to other types too (we'll see)

Varargs

In a signature of a method, the last input parameter, if of type array, can be specified with the ... syntax instead of []:

public static double max(double... values) { /* 1 ... */}

From the inside, exactly the same of []:

public static double max(double[] values) { /* 2 ... */}

From the outside, i.e., where the method is invoked, ... enables invokation with variable number of parameters (of the same type):

double max = max(4, 3.14, -1.1); //values ≅ double[3]; OK for 1
max = max(); //values ≅ double[0]; OK for 1
max = max(new double[2]{1, 2}); //Ok!; OK for 1 and 2

Since Java 5.0. Mathematically speaking, varargs allows to define variadic functions.

About modifiers

public static double max(double... values) {
  double max = values[0];
  for (int i = 1; i<values.length; i++) {
    max = (max > values[i]) ? max : values[i];
  }
  return max;
}

condition ? expr1 : expr2 is the ternary operator.

• Of which class might be a method?
• Why static?
• What happens with max()?

Why only last input parameter?

// does NOT compile!
public static int intersectionSize(String... as, String... bs) {
  /* ... */
}
intersectionSize("hello", "world", "cruel", "world");

What is as and what is bs?

• undecidable!

Java designers could have allowed for some exceptional case that, under some conditions, are not misinterpretable:

• method(ClassA..., ClassC)
• method(ClassA..., ClassB...)

But they opted for clarity at the expense of expressiveness.

Command line arguments

Available as content of main only arguments:

public class ArgLister {
  public static void main(String[] args) {
    for (String arg : args) {
      System.out.println(arg);
    }
  }
}

eric@cpu:~$ java ArgLister Hello World
Hello
World

Possible limitations and syntax variations depending on the host OS

Diagram

public class ArgLister {
  public static void main(String[] args) {
    for (String arg : args) {
      System.out.println("Arg: " + arg);
    }
  }
}

java prepares args before invoking main()

At the beginning of main() after java ArgLister Hello World What inside the 1st and 2nd iteration of the for loop?

Operating with Strings

Creation (String constructors):

• empty: String s = new String();
• specified: String s = new String("hi!");
  • the same of String s = "hi!";
• same of another: String s = new String(otherString);
• ...

String methods

Many!

A few examples from the javadoc of String

String.format()

See also Formatter class and printf() in PrintStream class; here the syntax.

String reference = String.format(
  "FPR=%4.2f\tFNR=%4.2f%n",
  fp / n,
  fn / p
);
//results in FPR=0.11 FNR=0.10

We'll se why Object...

Strings are immutable

1st sentence of the 2nd para of String docs: "Strings are constant; their values cannot be changed after they are created."

Apparently the docs are self-contradictory:

Apparently!

String.concat()

Immutable Strings: diagram

String s1, s2;
s1 = "hamburger";
s2 = s1.substring(3, 7);
System.out.print("s1 = ");
System.out.println(s1);
s1 = s1.replace('a', 'b');
String[] names ={ "John", "Fitzgerald", "Kennedy"}
String firstInit, middleInit, lastInit;
firstInit = names[0].substring(0, 1);
middleInit = names[1].substring(0, 1);
lastInit = names[2].substring(0, 1);
firstInit.concat(middleInit).concat(lastInit);

Concatenation

Besides concat(), + operator (alternative syntax):

String s1 = "today is ";
String s2 = s1.concat(" Tuesday").concat("!");

2nd line is the same of:

String s2 = s1 + " Tuesday" + "!";

+ is associative on the left:

• "today is Tuesday" is obtained before "today is Tuesday!"

String + other type

If one of the operands of + is of type String then, at runtime:

• a String representation of the operand is obtained
• the concatenation of the two Strings is done

int age = 41;
String statement = "I'm " + age + " years old";

What are the String and the non-String operands?

For the case when the non-String operand is not a primitive type, we'll see the underlying mechanism in detail.

Primitive types

A few differences with respect to classes:

• they are not created with new
• they do not have methods (no constructors) and fields
  • no dot notation

They can be operands of (binary) operators.

int n = 512;
double d = 0d;
char a = 'a';
boolean flag = false;
flag = flag || true;
double k = 3 * d - Math.sqrt(4.11);

sqrt() modifiers?

Initialization of primitive types

If not explicitly initialized:

• if field of an object, initialized to default value
  • 0 for numbers, false for boolean
• if local variable, code does not compile

Initialization of arrays of primitive types

Consistently, for arrays:

• elements of primitive type arrays are initialized to default value

int[] marks;
double[] ages = new double[3];

Inline field initialization

Fields can be initialized inline:

public class Greeter {
  private String greet = "Hello";
  public void greet() {
    System.out.println(greet + " World!");
  }
}

Field initialization is executed before the first statement of any constructor.

Field initialization

public class Greeter {
  private String greet = "Hello";
  private String target;
  private int n;
  public void greet() {
    System.out.println(greet + " " + target);
    System.out.println(n);
  }
}

= on primitive types

Assign operator = copies the content, instead of referencing the same object.

String s1 = "hello!";
String s2 = s1;

double d1 = 3.14;
double d2 = d1;

Things are a bit more complex, we'll see...

null

A special "value" that can be referenced by a reference of any non-primitive type.

Fields:

• non-primitive fields are implicitly set to null
• recall: primitive fields are set to their default values

Local variables:

• if not initialized, compilation error!

Referencing null

A reference referencing null is (approx.) not referencing anything.

String s1 = "hi";
String s2 = null;
String s3 = null;

public class Greeter {
  private String s1 = "hi";
  private String s2 = null;
  private String s3;
  private int n;
}

Dereferencing

String s1 = "hi";
String s2 = s1;
s1 = null;
boolean isNull = s1 == null;

Onlide IDE repl.it

• register
• enjoy compilation (javac) and execution (java)
  • note the run button

Code neatly!

Your code is your representation of a problem and its solution.

When someone looks at your code, she/he is entering your mind:

• messy code $\rightarrow$ messy representation $\rightarrow$ messy mind $\rightarrow$ messy you!
• do you want to look messy?
  • to your collaborator, your boss, your employee
  • to your teacher

Code review

At least 4 sources of mess (increasingly harder to spot):

• code formatting
• naming
• implementation of algorithm
• algorithm

Code review $\rightarrow$ the process of checking the code by looking at the source code:

• routinely performed within big tech companies
• there is a "IEEE Standard for Software Reviews and Audits" (IEEE 1028-2008)
• not cheap!

Printing a Date

import java.util.Date;
public class Greeter {
  public static void main(String[] args) {
    System.out.print("Hello World! Today is: ");
    System.out.println(new Date());
  }
}

eric@cpu:~$ java Greeter
Hello World! Today is: Mon Mar 16 10:36:13 UTC 2020

It works!

println and Date

PrintStream class:

No println for Date!

• why does the code compile?
• why and how does it execute?
  • what println is invokated at runtime?
  • why the printed string makes sense? (Mon Mar 16 10:36:13 UTC 2020 is actually a date!)

Similarly

import java.util.Date;
public class Greeter {
  public static void main(String[] args) {
    System.out.println("Hello World! Today is: " + new Date());
  }
}

eric@cpu:~$ java Greeter
Hello World! Today is: Mon Mar 16 10:36:13 UTC 2020

+ operator on String and Date:

• why does it compile?
• why and how does it execute?

Inheritance

It is static property of the language

• it has effect at compile-time

It allows to define a new type A starting from existing type B:

• only new or changed parts (methods/fields) are defined

Syntax

public class Derived extends Base {
  /* ... */
}

We (the developer) mean: "Dear compiler":

• this Derived class is identical to the Base class
• I'll define new fields and methods
  • methods and fields cannot be hidden (or "removed")
• I'll redefine existing fields and methods
  • for methods, by re-using the very same signature

We say that Derived extends (or inherits from, or derives from) Base.

Object

Every class implicitly derives Object (when not explicitly deriving from another class):

• every class has the methods and fields of Object

public class Greeter {
  /* ... */
}

is the same of:

public class Greeter extends Object {
  /* ... */
}

"Surprisingly", Object is a class, not an object...

Inheritance tree

A class can inherit from another class, that inherits from another class, ...

public class EnhancedGreeter extends Greeter { /* ... */ }

public class Greeter { /* ... */ }

EnhancedGreeter has methods and fields of Greeter and of Object.

Since a class can be derived from many classes, inheritance relationships form a tree.

Inheritance in the documentation

What methods are inherited?

Specified in the doc ("methods declared in class ..."):

Point of view of Base developer

public class Base {
  /* my stuff! */
}

I do not need to know if, how, when, who, where, (and why) will derive Base!

But still write clean code!

E.g., Object developers did not know we would have been writing some Java code right now

Point of view of Derived developer

public class Derived extends Base {
  /* my incremental stuff! */
}

I do not need to have the source code of Base

• to compile, nor to execute
• I need the .class, though

E.g., "no one" needs the source code of Object!

Constructor and inheritance

public class Derived extends Base {
  public Derived() {
    /* init things */
  }
}

• Who (which code) initializes inherited fields (those of Base)?
• When?

Note (before the answers) that:

• Base fields might be private: what code other than that of Base can operate on them?
• suppose that a Derived method is called within the Derived():
  • it can use Base methods (it's legit)
  • those methods can use Base fields: who should be the responsible for their initialization?

Constructor derived class

public class Derived extends Base {
  public Derived() {
    Base();
    /* init things */
  }
}

The compiler inserts an (implicit, wrt to code) call to derived class constructor Base()!

• Who (which code) initializes inherited fields (those of Base)?
  • Base()
• When?
  • before any statement of Derived()

Many constructors/no default constructor

What if Base does not have the no-args constructor?

The compiler requires the developer to specify which Base constructor to use

• and its parameters

Syntax: super(...)

super() constructor

public class Greeter {
  public Greeter(String name) {
    /* init things */
  }
}

public class EnhancedGreeter extends Greeter {
  public EnhancedGreeter(String firstName, String lastName) {
    super(firstName + lastName);
    /* init things */
  }
}

Ok!

• code compiles

super() constructor: not working

public class Base {
  public Base(int n) { /* ... */ }
  public Base(double v) { /* ... */ }
}

public class Derived extends Base {
  private int m;
  public Derived() {
    m = 0;
    super(5);
    /* ... */
  }
}

Not ok!

• does not compile: super() has to be invoked first

super() constructor: not working

public class Base {
  public Base(int n) { /* ... */ }
  public Base(double v) { /* ... */ }
}

public class Derived extends Base {
  private int m;
  public Derived() {
    m = 0;
    /* ... */
  }
}

Not ok!

• does not compile: super() with no args does not exist

super() constructor: working

public class Base {
  public Base(int n) { /* ... */ }
  public Base(double v) { /* ... */ }
  public Base() { /* ... */ }
}

public class Derived extends Base {
  private int m;
  public Derived() {
    m = 0;
    /* ... */
  }
}

Ok!

• code compiles

Which constructor of Base is invoked?

Inheritance and inline initialization

public static class Base {
  public int n = 1;
}

public static class Derived extends Base {
  public int m = n + 1;
}

Derived derived = new Derived();
System.out.printf("m=%d%n", derived.m); // -> m=2

"Field initialization is executed before the first statement of any constructor." $\rightarrow$ any of this class!

• super() is executed before any inline initialization

What is derived.n?

Reference type and inheritance

public class Derived extends Base { /* ... */ }

Any code that works with a Base can work also with a Derived.

• more formally: a reference to type Base can (i.e., the compiler says ok) reference an object of type Derived

public void use(Base base) { /* ... */ }

Base base = new Derived(); // OK!!!

use(new Base()); // OK, sure!
use(new Derived()); // OK!!!

Using Derived

public void use(Base base) { /* ... */ }

use(new Derived()); // OK!!!

Why does it compile? (use() was written to work with a Base)

• Derived has all fields and methods of Base
  • maybe with different behaviors (methods, but signature is exactly the same)
  • maybe it has also other methods/fields
• $\rightarrow$ any dot notation valid on a Base is also valid on a Derived!

"has all fields", but recall visibility!

Inheritance, philosophycally

Derived has all fields and methods of Base.

Syllogism: anything being a Derived is also a Base

public class LivingBeing { /* ... */ }

public class Animal extends LivingBeing { /* ... */ }

public class Mammal extends Animal { /* ... */ }

public class Dog extends Mammal { /* ... */ }

public class Chihuahua extends Dog { /* ... */ }

A Chihuahua is a Dog, a Mammal, ..., and an Object.

But, please, avoid over-using inheritance.

There's a debate about inheritance being good or bad. Indeed, this is not the most appropriate example of using inheritance...

Be general

Rule: use the most general definition!

public void putLeash(Dog dog) { /* ... */ }

is better than:

public void putLeash(Chihuahua dog) { /* ... */ }

even if in your code you will putLeash() only on Chihuahuas (but provided that you have the inheritance Dog $\rightarrow$ Chihuahua).

... but not too much

Similarly:

public Milk milk(Mammal mammal) { /* ... */ }

is better than:

public Milk milk(Cow cow) { /* ... */ }

However:

public Milk milk(Animal animal) { /* ... */ }

is wrong!

• but (as is here) compiles!
• wrong, because conceptually you cannot milk every animal

Removing methods?

public class Derived extends Base { /* ... */ }

Why cannot Derived remove some methods/fields of Base?

• more specifically, why the language does not even have a construct for doing this?

Why cannot Derived reduce visibility of methods/fields of Base?

• more specifically, why the compiler does not accept it?

Because otherwise "Derived has all fields and methods of Base" would not be true!

• so we could not write use(new Derived()), nor println(new Date()), and inheritance would be useless!

Same code, difference behavior

public void greet(Person person) {
  System.out.println("Hi, " + person.getFullName());
}

public class Person {
  /* ... */
  public String getFullName() {
    return firstName + " " + lastName;
  };
}

public class Doc extends Person {
  /* ... */
  public String getFullName() {
    return "Dr. " + firstName + " " + lastName;
  };
}

Outcome is different with the same greet() and same fields content!

Polymorphism

It is a dynamic consequence of inheritance:

• it has effect at runtime

It results in the same code to have different behaviors depending on the type of the parameter.

Different behavior

public class Derived extends Base { /* ... */ }

public void use(Base base) { /* ... */ }

Base base = new Derived();

Outcome might be "different" than that with = new Base().

use(new Base()); // OK, sure!
use(new Derived()); // OK!!!

Outcomes might be "different".

Developer of use() did not know that someone would have derived Base:

• they knew how to use a Base
• who wrote Derived decided that any Derived is a Base

Not the opposite!

Obviously...

public Base createBase() { /* ... */ }

Derived derived;
derived = createBase();

1. Derived derived: developer $\rightarrow$ compiler
   • please, take note (and make sure) that with any operation defined in Derived can be applied to object referenced by derived
2. derived = createBase(): compiler $\rightarrow$ developer
   • no! I cannot meet the requirement ("make sure that") because the object returned by createBase() might not be a Derived

It might also be a Derived, but cannot guarantee...

Might be...

public Base createBase() {
  if (System.currentTimeMillis() % 2 == 0) {
    return new Base();
  }
  return new Derived();
}

(Purely evil! Don't do it at home!)

Derived derived;
derived = createBase();

createBase() can really return a Derived...

What if I (developer) am sure that it is a Derived?

Downcasting

Derived derived;
derived = (Derived) createBase();

What if I (developer) am sure that it is a Derived?

Syntax: (Derived) base

• "changes" type of downcast reference
• works only if Derived derives (directly or indirectly) from the class of base

Why "works only..."?

• because return in createBase() must take a Base, so there's no reason to accept something that cannot happen!

Still, at runtime, there is a check at every invokation.

instanceof

Binary operator (keyword) for checking the type of a object at runtime:

• evaluates to boolean

boolean isString = ref instanceof String;

Formally, a instanceof B evaluates to true if and only if object referenced by a might be legitimately referenced by a reference b to objects of type B.

public class Derived extends Base { /* ... */ }

Derived derived = new Derived();
boolean b1 = derived instanceof Object; // -> true
boolean b2 = derived instanceof Base; // -> true
boolean b3 = derived instanceof Derived; // -> true

Typical usage

Object obj = someOddMethod();
if (obj instanceof String) {
  String string = (String) obj;
  System.out.println(string.toUpperCase());
  // obj.toUpperCase() would not compile!
}

Since JDK 14 (March 2020):

Object obj = someOddMethod();
if (obj instanceof String string) {
  System.out.println(string.toUpperCase());
}

Just a language shorthand! Called Pattern matching with instanceof

Why?

import java.util.Date;
public class Greeter {
  public static void main(String[] args) {
    System.out.print("Hello World! Today is: ");
    System.out.println(new Date());
  }
}

• Why does the code compile?
• Why and how does it execute?
  • What println is invokated at runtime?
  • Why the printed string makes sense?

Why does it compile?

PrintStream class:

Date extends Object and there is a PrintStream.println(Object)!

• a Date has everything an Object has
• println() says it knows how to print on Object

Ok, but then?

toString()

Object class:

Hence:

• every object has a toString() method
• every object can be represented as string

Overriding toString()

The developer of a class may (and should!) redefine (= override) toString():

• returns a string that "textually represents" this object
• concise but informative
• easy for a person to read

IDEs have an option for writing a decent toString() for you (Alt+Ins in Netbeans)

toString() of Date

Why does it work?

import java.util.Date;
public class Greeter {
  public static void main(String[] args) {
    System.out.print("Hello World! Today is: ");
    System.out.println(new Date());
  }
}

In PrintStream:

public void println(Object x) {
  if ( x == null ) {
    println("null");
  } else {
    println(x.toString());
  }
}

Delegation and information hiding

public void println(Object x) {
  if ( x == null ) {
    println("null");
  } else {
    println(x.toString());
  }
}

The developers of PrintStream just took care of how to print an Object

• check for null inside println()
• delegation to Object toString() for the rest

No need for knowledge about if, how, when, who, where, (and why) would have derived Object!

Why?

System.out.println("Now is " + new Date());

Why does the code compile?

• because + with a String as 1st operand "accepts" anything as 2nd operand

Why and how does it execute?

• because the compiler translated + ref to something like

  (ref == null) ? "null" : ref.toString()

  (if ref is not a reference to primitive type)

Own class "field"

At runtime, every object o has a description of its class:

• it is an object of class Class
• it is "shared" among all instances of the class of o
  • approx. like a static field

It can be obtained with the getClass() method of Object:

• hence, since it is in Object, every o has getClass()
  • since every object has all the methods declared in Object

Object class:

Ignore the <?> for now; we'll see it later

Diagram

What's inside the description?

Conceptually, inside the Class of a class X:

• methods of X (i.e., declared in X)
• fields of X
• ...

We'll see later more about this!

public class Base {
  public void doBase() { /.../ }
}

public class Derived extends Base {
  public void doDerived() { /.../ }
}

Derived d  = new Derived();

Reference to superclass

• and the class of the base type, possibly Object

• methods of d.getClass() contains doDerived
• methods of d.getClass().superclass contains doBase
• methods of d.getClass().superclass.superclass contains toString, getClass, ...

Approximately: types and names of fields/methods are different

Which method?

System.out.println(derived); // -> derived.toString()

public void println(Object x) {
  if ( x == null ) {
    println("null");
  } else {
    println(x.toString());
  }
}

Conceptually:

1. get Class c of derived
2. get methods of c
3. do methods contains toString()
   • yes, use that method
   • no, set c to c.superclass and go back to 2

In the worst case, c is eventually the Class describing Object

Class and Object

Class is a class; Object is a class.

• you can use object as identifier of a reference to objects of class Object
• you cannot use class as identifier of a reference to objects of class Class
  • because class is a keyword

Many developers and examples use clazz...

Methods of Object

Object class:

equals(): indicates whether some other object is "equal to" this one.

What's the difference with respect to ==?

== (and !=)

a == b

• if a and b of different primitive types**, or of primitive and non-primitive**, or of non compatible* non-primitive types, then code does not compile
• else if a and b of same primitive type, then evaluates to boolean true iff a and b have the same value, otherwise evaluates to false
• else evaluates to boolean true if a and b reference the same object or both do not reference any object (i.e., they "are" null), otherwise evaluates to false

a != b

• if it compiles, evaluates to the negation of a == b

*: "compatible" means that types are the same or one derives from the other

Same object!

String s1 = "hi!";
String s2 = "hi!";
String s3 = s2;
boolean b;
b = s1 == s2; // -> false
b = s2 == s3; // -> true
b = s1.length() == s2.length(); // -> true

equals()

Object: "indicates whether some other object is "equal to" this one".

Actual meaning depend on the type, that possibly overrides equals()

• String: "true if and only if [...] represents the same sequence of characters [...]"
• Date: "true if and only if [...] represents the same point in time, to the millisecond [...]"
• PrintStream: does not override equals()
  • the developers of PrintStream decided that the "equal to" notion of Object hold for PrintStreams

equals() documentation in Object

Two things in this documentation:

• what's the general semantics of equals()
• how does the specific implementation in Object work

equals() in Object

"the most discriminating possible equivalence relation":

public class Object {
  /* ... */
  public boolean equals(Object other) {
    if (other == null) {
      return false;
    }
    return this == other;
  }
}

Note: this cannot be null!

Overriding equals

Semantics level requirements:

• equivalence conceptually sound for the specific case
• reflexivity, symmetry, transitiveness, consistency, null

Syntax level requirement:

• comply with the signature

  public boolean equals(Object other)

  • the argument is of type Object also for the deriving type!

The compiler:

• does check fulfillment of syntax requirement
• cannot check fulfillment of semantics requirements
  • big responsability of the developer

Implementing equivalence

It depends on the case, i.e., on the type; it should correspond to equivalence of the represented concepts.

Given type X, should answer the question:

• are x1 and x2 the same X?

E.g., equivalence of persons: are two persons the same?

• in the real world:
  • formed by the same atoms? (probably too strict)
  • same first and last name? (probably too loose)
• in the application:
  • depends of what aspects of real world are modeled

Equivalent persons

public class Person {
  private String firstName;
  private String lastName;
  private Date birthDate;
}

This class models a person by her/his first name, last name, and birth date:

• it's a developer's decision

At most (in strictness), equals() can say that "two persons are the same iff they have the same first name, same last name, and same birth date".

• what if two "different" persons has the same name and birth date? (Marco Rossi!)
• what if a person changes name?

Equivalent persons with fiscal code

public class Person {
  private String firstName;
  private String lastName;
  private Date birthDate;
  private String fiscalCode;
}

This class models a person with [...] and fiscal code.

By domain knowledge, the developer can decide that "two persons are the same iff they have the same fiscal code".

Simple Person.equals()

public class Person {
  private String firstName;
  private String lastName;
  private Date birthDate;
  public boolean equals(Object other) {
    if (other == null) {
      return false;
    }
    if (!(other instanceof Person)) {
      return false;
    }
    if (!firstName.equals(((Person) other).firstName)) {
      return false;
    }
    if (!lastName.equals(((Person) other).lastName)) {
      return false;
    }
    if (!birthDate.equals(((Person) other).birthDate)) {
      return false;
    }
    return true;
  }
}

• (Person) to downcast other as Person
• assumes fields are not null

Person.equals() with fiscal code

public class Person {
  private String firstName;
  private String lastName;
  private Date birthDate;
  private String fiscalCode;
  public boolean equals(Object other) {
    if (other == null) {
      return false;
    }
    if (!(other instanceof Person)) {
      return false;
    }
    if (!fiscalCode.equals(((Person) other).fiscalCode)) {
      return false;
    }
    return true;
  }
}

We (the developers) decided that two persons are the same if they have the same fiscal code, regardless of name and birth date!

IDEs and equals()

As for toString(), IDEs have an option for writing equals() for you (Alt+Ins in Netbeans). E.g., outcome with fiscalCode:

public boolean equals(Object obj) {
  if (this == obj) {
    return true;
  }
  if (obj == null) {
    return false;
  }
  if (getClass() != obj.getClass()) {
    return false;
  }
  final Person other = (Person) obj;
  if (!Objects.equals(
    this.fiscalCode,
    other.fiscalCode
    )) {
    return false;
  }
  return true;
}

Objects

A class with utility methods, static by design.

Objects class:

"deeply equal": equal, but also with arrays.

Many other similar classes in and out the JDK, e.g., Arrays:

• static fill(), sort(), ...

instanceof vs. getClass()

a instanceof B

• true iff object referenced by a might be legitimately referenced by a reference b to objects of type B

a.getClass() == b.getClass():

• true iff at runtime class of object referenced by a is exactly the same (==) of class of object referenced by b

a.getClass() == B.class

• X.class is (approx.) an implicit static reference to the object representing the class X
• true iff at runtime class of object referenced by a is exactly B

instanceof vs. getClass(): example

public class Person { /* ... */ }

public class Employee extends Person { /* ... */ }

Person p = new Person( /* ... */ );
Employee e = new Employee( /* ... */ );
boolean b1 = e instanceof Person; // -> true
boolean b2 = p.getClass() == e.getClass(); // -> false

Is an employee equal to the person being the employee? Big question: it depends on how you model the reality.

equals() on complex types

equals() should represent the equivalence that is inherently defined by the representation defined by the type.

public class BagOfInts {
  private int[] values;
}

public class SequenceOfInts {
  private int[] values;
}

$X$ "is" the class, $x \in X$ is the object
$\mathcal{M}(A)$ is my notation for the set of multisets built with elements of the set $A$.

Everything in the name!

class BagOfInts {
  private int[] values;
}

class SequenceOfInts {
  private int[] values;
}

Exactly the same code, different models!

Difference in models should be captured by the name of the type!

Multiple inheritance

public class Vehicle { /* ... */ }

public class MotorVehicle extends Vehicle {
  public void startEngine() { /* ... */ }
}

public class Motorboat extends MotorVehicle {
  public void startEngine() { System.out.println("bl bl bl"); }
  public void turnPropeller() { /* ... */ }
}

public class Car extends MotorVehicle {
  public void startEngine() { System.out.println("brum brum"); }
  public void turnWheels() { /* ... */ }
}

• Every MotorVehicle is a Vehicle
• Every Motorboat is a MotorVehicle, thus also a Vehicle
• Every Car is a MotorVehicle, thus also a Vehicle.
• In general, a Car is not a Motorboat!

Here comes the amphibious!

public class AmphibiousVehicle extends Motorboat, Car { // NOOOO!
  public void doAmphibiousFancyThings() { /* ... */ }
}

Does not compile! No multiple inheritance!

Why not?

public class AmphibiousVehicle extends Motorboat, Car { // NOOOO!
  public void doAmphibiousFancyThings() { /* ... */ }
}

AmphibiousVehicle fiat6640 = new AmphibiousVehicle();
fiat6640.startEngine();

Should it result in bl bl bl or in brum brum?

• it's certain that there is a startEngine(), since both Motorboat and Car extends MotorVehicle: which one should be invoked? same for equals(), toString(), ...
• same for fields