Java programming and OOP

Either to revise or as additional sources, the followins resources may help you with Java programming and OOP.

• This YouTube video playlist teaches Java programming with OOP as its main focus ("Early Objects" we could say).
• https://chortle.ccsu.edu/java5/Notes/chap92/ch92_2.html lexicographical order/Java compareTo method
• https://www.youtube.com/playlist?list=PLZPZq0r_RZOMhCAyywfnYLlrjiVOkdAI1 (up to 47 for the whole course; up to 25 for grade 11) ; https://www.youtube.com/watch?v=xk4_1vDrzzo
• https://www.youtube.com/watch?v=eIrMbAQSU34 great for our level and grade 11 IB CS
• https://www.youtube.com/watch?v=j9VNCI9Xo80 another great resource for our level and grade 11 IB CS; up to 02:17:14 - Exercise
• https://www.udemy.com/course/java-tutorial/
• https://www.sololearn.com/learn/courses/java-introduction
• https://www.freecodecamp.org/news/the-java-handbook/ (up to and excluding array lists for grade 11, all but excluding hash maps for grade 12)
• https://www.coursera.org/learn/object-oriented-java
• https://www.youtube.com/codingwithjohn
  

 Hope they will be useful to you!

UML Class Diagrams in a Nutshell

...A really small nutshell.

This webpage contains a nice, short and sweet explanation and side-be-side comparison between a class diagram and its corresponding Java code. Priceless.

Source: http://pages.cs.wisc.edu/~hasti/cs302/examples/UMLdiagram.html

Class Relationships

Please read these two resources to have a better understanding of class relationships

• http://creately.com/blog/diagrams/class-diagram-relationships/ focus on association, composition/aggregation (depends on your IA), multiplicity and inheritance. http://www.infoworld.com/article/3029325/application-development/exploring-association-aggregation-and-composition-in-oop.html (link title explains itself)

For more resources on the principles of OOP and UML diagrams, click here.

OOP Principles and UML

These are my favourite explanations (so far) regarding the principles of OOP: Abstraction, Encapsulation, Inheritance and Polymorphism. They are most important to understand and remember, so study and practice them well. The links have page names (at the end of the link) that are self-explanatory.

• http://codebetter.com/raymondlewallen/2005/07/19/4-major-principles-of-object-oriented-programming
• http://beginnersbook.com/2013/03/oops-in-java-encapsulation-inheritance-polymorphism-abstraction/
• http://www.javaworld.com/article/2076204/core-java/understanding-constructors.html

UML provides so many tools, that it can be overwhelming. So it is always useful to narrow it down and focus on what is useful for a specific task. The following resources are on UML class diagrams. You are also recommended to look into use-case diagrams, which are great for conceptual designs.

• http://pages.cs.wisc.edu/~hasti/cs302/examples/UMLdiagram.html
• http://etutorials.org/Programming/UML/Chapter+4.+Class+Diagrams+The+Essentials/
• http://etutorials.org/Programming/UML/Chapter+6.+Class+Diagrams+Advanced+Concepts/Aggregation+and+Composition/
• http://www.uml-diagrams.org/class-diagrams-overview.html
• http://creately.com/blog/diagrams/class-diagram-relationships/
• http://www.infoworld.com/article/3029325/application-development/exploring-association-aggregation-and-composition-in-oop.html
• http://pages.cs.wisc.edu/~hasti/cs302/examples/UMLdiagram.html
• http://www.tutorialspoint.com/uml/uml_class_diagram.htm
• http://www.ibm.com/developerworks/rational/library/content/RationalEdge/sep04/bell/

In terms of class relationships, you should know (according to the IBO syllabus content)

• dependency (“uses”)
• aggregation (“has a”) and
• inheritance (“is a”).

You may find the following links useful to revise these concepts. Just focus on what IBO requires among all the detailed information provided.

• http://www.conceptdraw.com/How-To-Guide/uml-class-diagram-notation
• https://en.wikipedia.org/wiki/Class_diagram

Static vs Non-static in Java

A really good (and tough!) distinction that everyone coding in Java needs to know: the difference between static and non-static variables in Java.

In my opinion, tutorial4us did a great job explaining it. A very good read indeed.

My understanding is that instance (non-static) variables exist in each object (instance of the class). Each object will have its own value/content for each instance variable. Think of the name in a Person class. We define the name as an attribute or property of a person, and each Person object will have its own name.

Static variables exist only inside the class where they are declared. Some call them "class variables" because they are bound to the class, not the object. They are unique and when a new object is instantiated, the object does not get its own copy of it. Rather than using the dot notation with the object (object.nnnn), you would use it with the class (Class.nnnn).

Note that this also applies to, and is also often used with methods!

Think about these example:

public class Test
{
  public static void main (String args[])
  {
    int[] numbers = {1,2,3,4,5};
    System.out.println( numbers.length ); // =5
    // length (size/number of elements) of the array object
    System.out.println( Math.PI );
    // PI is stored as a static constant inside the Math class
    // we don't need to instantiate a Math object to use PI
  }
}

this Java keyword

A feature of Java that usually confuses beginners is the "this" prefix.

In a nutshell, the this keyword is used to distinguish between parameters of a method and attributes (instance variables) of a class.

The following link will lead you to a web page that does a great job contrasting and explaining this with examples:

• http://www.javatpoint.com/this-keyword

Java programming

Just a couple of great online resources on Java programming:

• http://howtodoinjava.com/2013/06/07/5-class-design-principles-solid-in-java/
• http://www.ntu.edu.sg/home/ehchua/programming/
• http://introcs.cs.princeton.edu/java/home/
• http://nclass.sourceforge.net/downloads.html

Hope this helps!