The repository contains the projects I built as exercises for the Helsinki Java MOOC Java Programming 1 and Java programming 2. 
The course can be found here: https://java-programming.mooc.fi/
My answers page for the course can be found here: https://tmc.mooc.fi/participants/1019229
My certificate of completion for Java 1 can be found here: https://certificates.mooc.fi/validate/25k0ctlmgg3

Contents - 

Java Programming 1 - 

Part 1 - 

1. Getting started with programming 
	- intro to programming and setting up the IDE
2. Printing 
	- printing 
	- program boilerplate 
	- printing multiple lines
	- terminology and code comments 
3. Reading input 
	- reading input 
	- fundamentals of strings 
	- concatenation
	- reading strings 
	- input string as a part of output
	- program execution waits for input
4. Variables
	- variables 
	- changing a value assigned to a variable
	- varaible's type persists
	- naming variables 
	- the type of the variable informs of possible variables
	- reading different variable types from user
5. Calculating with numbers
	- precedence and parentheses
	- calculating and printing
	- division
	- misunderstandings related to the value of a variable
6. Conditional-statements and conditional operation
	- code indentation and block statements
	- comparison operators
	- else
	- else if 
	- order of execution for comparisons
	- conditional statement expression and the boolean variable
	- conditional statements and comparing strings
	- logical operators
	- execution order of conditional statements
7. programming in our society 
	- discussion of programming in our society

Part 2 -  

1. Recurring problems and patterns to solve them
	- reading user input
	- calculating
	- conditional logic
2. Repeating functionality
	- loops and infinite loops
	- ending a loop
	- returning to the start of the loop
	- calculation with loops 
3. More loops
	- while loop with a condition
	- for loop
	- on stopping a loop execution
	- repeating functionality
	- on the structure of programs using loops
4. Methods and dividing the program into smaller parts
	- custom methods
	- method parameters
	- multiple parameters
	- parameter values are copie in a method call
	- methods can return values	
	- defining varibales inside methods
	- calculating the return value inside a method
	- execution of method calls and the call stack
	- call stack and method parameters
	- call stack and returning a value from a method
	- method calling another method

Part 3 - 

1. Discovering errors
	- a programmer blind to their own code
	- commenting the source code
	- searching for errors with print debugging
2. Lists
	- using and creating lists
	- defining the type of values that a list can contain
	- adding to a list and retrieving a value from a specific place
	- retrieving information from a "non-existant" place
	- iterating over a list
	- iterating over a list continued
	- iterating over a list with a for-each loop
	- removing from a list and checking the existence of a value
	- list as a method parameter
	- on copying the list to a method parameter
	- a summary of list methods
3. Arrays
	- creating an array
	- assigning and accessing elements
	- size of an array and iterating
	- type of the elements
	- array as a parameter of a method
	- the shorter way to create an array
4. Using strings
	- reading and printing strings
	- string comparisons and "equals"
	- splitting a string
	- data of fixed format
	- using diverse text

Part 4 - 

1. Introduction to object-oriented programming
	- classes and objects
	- creating classes
	- defining a constructor
	- defining methods for an object
	- changing an instance variable's value in a method
	- returning a value from a method
	- a string representation of an object and the toString-method
	- method parameters
	- a parameter and instance variable having the same name
	- calling an internal method
2. Objects in a list
	- adding object to a list
	- adding user-inputted objets to a list
	- multiple contructor parameters
	- filtered printing from the list
3. Files and reading data 
	- reading from the keyboard
	- files and the filesystem
	- reading from a file
	- reading data of a specific format from a file
	- reading objects from a file

Part 5 - 

1. Learning object-oriented programming
	- what is object-oriented programming
	- object
	- class
2. Removing repetitive code(overloading methods and constructors)
	- constructor overloading
	- calling your contructor
	- method overloading
3. Primitive and reference variables
	- primitive variables
	- reference variables
	- primitive and reference variables as method parameters
4. Objects and references 
	- assigning a reference type variable copies the reference
	- null value of a reference variable
	- object as a method parameter
	- object as object variable
	- object of same type as method parameter
	- comparing the equality of objects (equals)
	- object equality and lists
	- object as a method's return value

Part 6 - 

1. Objects on a list and a list as part of an object
	- objects in an instance variable list
	- printing an object from a list
	- clearing an object's list
	- calculating a sum from objects on a list
	- retrieving a specific object from a list
2. Seperating the user interface from program logic
	- looping and quitting
	- storing relevant information
	- combining the solutions to sub-problems
	- objects as a natural part of problem solving
	- changing the implementation of a class
	- programming tips
	- from one entity to many parts
	- program logic
	- user interface
3. Introduction to testing
	- error situations and step-by-step problem resolving
	- stack trace
	- checklist for troubleshooting
	- passing test input to scanner
	- unit testing
	- test-driven development
4. Complex programs
	- talks about complex programs

Part 7 - 

1. Programming paradigms
	- object-oriented programming
	- procedural programming
2. Algorithms
	- sorting information
	- selection sort
	- built-in sorting algorithms in Java
	- information retrieval
	- linear search
	- binary search
3. Larger programming exercises
	- selection of large programming exercises to complete

Java Programming 2 - 

Part 8 - 

1. Short recap 
	- some exercises reminding self of java1 course
2. Hash Map
	- what a hash map is
	- hash map keys correspond to a single value at most 
	- a reference type variable as a hash map value
	- when should hash maps be used
	- hash map as an instance variable 
	- going through a hash map's keys
	- going through a hash map's values 
	- primitive variables in hash maps 	 
3. Similarity of objects
	- method to test for equality - "equals"
	- approximate comparison with HashMap
4. Grouping data using hash maps
	- grouping data using hash maps
5. Fast data fetching and grouping information
	- summary of part8

Part 9 - 

1. Class inheritance
	- class inheritance
	- access modifiers private, protected, and public
	- calling the constructor of the superclass
	- calling a superclass method 
	- the actual type of an object dictates which method is executed
	- when is inheritance worth using 
	- abstract classes
2. Interfaces
	- interfaces
	- interface as variable type 
	- interface as method parameters
	- interface as a return type of a method
	- built-in interfaces 
		- the list interface
		- the map interface
		- the set interface
		- the collection interface
3. Object polymorphism
	- what is object polymorphism

Part 10 - 

1. Handling collections as streams
	- streams
	- labda expressions
	- stream methods
	- terminal operations
	- intermediate operations
	- objects and stream
	- files and streams
2. The Comparable Interface
	- the comparable interface 
	- sorting method as a lambda expression
	- sorting by multiple criteria
3. Other useful techniques
	- StringBuilder
	- regular expressions
		- alternation |
		- affection part of a string (parentheses)
		- quantifiers
		- charater classes (square brackets)
	- enumerated type - Enum
		- object references in enums
	- iterator

Part 11

1. Class diagrams
	- Describing class and class attributes 
	- Describing class constructor
	- Describing class methods 
	- Connections between classes
	- Describing inheritance
	- Describing interfaces

2. Packages 
	- Directory structure in a file system
	- Packages and access modifiers
	- A large example: flight control
		- classes that represent concepts of the problem domain
		- Application logic
		- Text user interface
3. Exceptions 
	- Handling exceptions
	- Exceptions and resources
	- Shifting the responsibility
	- Throwing exceptions
	- Exceptions and interfaces
	- Details of the exception
4. Processing files 
	- Writing to a file

Part 12 

1. Type parameters 

	You know what is meant with the concept of a generic type parameter.
	You are familiar with already existing Java classes that make use of generic type parameters.
	You can create classes of your own that make use of generic type parameters.

2. ArrayList and hash table 

	You know how to implement a generic list that has changing size.
	You know of one possible method to implement a class like Java's ArrayList.
	You know how to implement a hash table.
	You are aware of one possible method to implement a class like Java's HashMap.

3. Randomness 

	Know how to generate random numbers, and know some situations where random numbers are needed.
	Can use Java Random class to generate random numbers.

4. Multidimensional data 

	Know ways to represent multidimensional data
	Can create and use multidimensional arrays

Part 13 

1. Graphical user interfaces 

	You know what user interfaces (UIs) consist of and know how to launch a graphical user interfaces (GUIs).

2. UI components and their layout

	You are aware of some interface components and know how to add them to a user interface.
	You're familiar with methods for configuring user interface components.

3. Event Handling 

	You're familiar with the concept of an event handler and are able to handle user interface events.

4. Application's launch parameters

	You know how to pass parameters to a graphical user interface.

5. Multiple Views

	You practice adding multiple views to a graphical interface.
	You know methods for changing the view.
	You know methods for separating the application logic and the user interface logic