Classes

• Objects fall into different categories or classes
  • E.g. my bank account and yours belong to the same class: both are bank accounts
  • E.g. System.out belongs to the java.io.PrintStream class
  • E.g. System.in belongs to the java.io.InputStream class
• We say that an object is an instance of its class
  • E.g. you are an instance of the student class
  • E.g. System.out is an instance of the java.io.PrintStream class
• Objects in the same class have the same interface
  • an object's interface is the set of services it provides to its 'clients' – essentially, its methods
  • the interface can be discovered from the online documentation – the API (application programmer's interface)
    • https://docs.oracle.com/javase/8/docs/api/

Class definitions

• For each class, Java has a class definition
  • a kind of 'blueprint' that specifies how to create new instances of that class
• We can ask Java to create a new object from the class definition, e.g.

  sc = new java.util.Scanner(System.in);

  • it fetches the blueprint and builds the new object
  • the new object will have the same interface as other objects in the class because they were all built from the same blueprint
  • Q: What is the interface for the sc object that we created above? How will you find out?

Another example of objects and classes

• In Python, one way to get a random integer is to use the choice function, e.g.

  from random import choice
  
  num = choice( range( 1, 101 ) )
  print( num )

  – generates a random integer between 1 and 100 inclusive, stores it, prints it
• In Java, one way to do the same is to use an object that is an instance of java.util.Random
  • there is no 'predefined' object for doing this
  • so we'll have to create one using new
  • then we can look at its interface and choose which method to use

  class PrintRandom {
         
      public static void main(String[] args) {
          java.util.Random randy = new java.util.Random();
          int num = randy.nextInt(101);
          System.out.println(num);
      }             
  }

import statements

• Classes in Java often have long cumbersome names
• Java's import statement allows us to 'abbreviate' the names, e.g.

  import java.util.Random;
  
  class PrintRandom {
         
      public static void main(String[] args) {
          Random randy = new Random();
          int num = randy.nextInt(101);
          System.out.println(num);
      }             
  }

• You don't need import statements for anything from java.lang
  • This is why we could use System.out without an import

Conditional statements

if x < y:
    print('x is smaller than y')
elif x == y:
    print('x is equal to y')
else:
    print('x is larger than y')
 

if (x < y) {
    System.out.println('x is smaller than y');
} else if (x == y) {
    System.out.println('x is equal to y');
} else {
    System.out.println('x is larger than y');
}

In the Java, note:

• the round parentheses for the Boolean expression;
• the curly braces;
• the fact that elif does not exist

Another example of objects and classes

• Strings of characters such as "Hello" are objects
• They are instances of the String class (java.lang.String)
• To create new String objects:

  String s1;
  s1 = new String("Hello");
  
  String s2 = new String("Bye");

• String objects are so common that their creation has a short-cut:

  String s1;
  s1 = "Hello";
  
  String s2 = "Bye";

String objects

• Strings in Java always use double-quotes
• Characters within the string are indexed from 0:

  	0	1	2	3	4
  "	H	e	l	l	o	"

  its length is 5
• Contrast s3 which is the empty string (length 0) with s4, which is not empty:

  String s3 = "";
  String s4 = " ";

String interface

• How would you know what its interface is?
• Part of its interface:
  • public int length()
  • public String concat(String str)
  • public int indexOf(String str)
  • public String toLowerCase()
  • public String toUpperCase()
  • public String substring(int beginIndex)
  • public String substring(int beginIndex, int endIndex)
• ...and many more

String methods

• What do these produce?

  String s5 = "John";
  String s6 = " and ";
  String s7 = "Edward";
  
  String s8 = s7.substring( s7.indexOf("war") );
  
  String s9 = s7.concat(s6).concat(s5);

Concatenation using +

• If you mix Strings and other values in a concatenation expression, Java converts the other values to Strings, e.g.

  String s12 = "This is CS" + 2514;

  (whereas Python would need to use str(2514) )
• Very useful when calling println, e.g.:

  int age = sc.nextInt();
  System.out.println("Are ye really " + age + " years old?");

• But be careful! Java evaluates multiple + operators from left-to-right unless parentheses dictate otherwise...

...So what do these produce?

int x = 25;
int y = 14;

System.out.println("My favourite number is " + x + y);

System.out.println(x + y + " is my favourite number");

Advanced point

• If you're doing a lot of concatenation (e.g. each time round a loop), it's therefore costly in time and memory to use Strings

  String s = "";
  while (...) {
      String input = sc.readLine();
      s = s + input;
  }

• Use objects of class StringBuilder. They are mutable: their append method modifies the object

  StringBuilder sb = new StringBuilder();
  while (...) {
      String input = sc.readLine();
      sb.append(input);
  }