Programming in Java

1
Programming in Java

• CSE301 Half Lecture
• Harry Erwin, PhD
• University of Sunderland

2
Object-Orientation and Complexity

• As an experienced software architect (who could
  earn 90,000 per year if I were willing to die
  before I am 60), I will give you my perspective
  on object-orientation.
• No person can understand the simultaneous
  interactions involving even a small number of
  objects.
• For example, 16 objects have 240 potential
  interfaces, if all are active. Balancing that
  many interactions is beyond your skill.

3
Managing Complexity

• The novice programmer will often generate
  enormous class and object diagrams with
  potentially hundreds of interactions.
• Dont go there.
• Use packages (subsystems) rather than classes in
  your top-level diagram. Between 5 and 15
  subsystems and a few more interfaces.
• Then drill down to produce class/object/package
  diagrams at the next level. Iterate this process
  until you can define the major classes.
• Document class interfaces and inheritance on
  separate UML diagrams.

4
Complexity and Encapsulation

• Finding a system design is not a simple task.
  This year, we will learn a number of principles
  you can use.
• Encapsulation is the first such principle.
• Strive for a design that consists of tightly
  bound subsystems that connect via a small number
  of narrow interfacesAPIs.
• GUI design is not a good model for this, so
  forget what youve learned about using visual
  tools until you understand how your design
  choices affect the way your GUI interfaces to
  your software.

5
Using Packages

• To specify the package a class belongs to, use
  the package keyword. Note that classes belong
  to an unnamed package by default. This can be
  very convenient, but is also bad form. Eclipse
  will help you here.
• To load a class or interface Name from a package,
  P, use the following directive
• import P.Name
• Note that the standard java class libraries live
  in a number of packages like
• java.lang
• java.io
• java.util
• javax.swing

6
Writing a Java File

• A Java file consists of
• An optional package directive
• Zero or more import directives
• One or more class or interface definitions. (At
  most one is allowed to be public.)
• Interspersed with comments
• When ClassName is a public class defined in the
  file, the name of the file must be
  ClassName.java.
• Eclipse will help you here.

7
Defining a Java Program

• A Java program has to have a class with a method
  with the following signature
• public static void main(String args)
• Assuming a public class exists with class name
  (e.g., CN) containing a method with the
  appropriate signature, it can be run by the
  following command
• java CN list of arguments.
• Eclipse allows you to set the arguments as run
  properties.

8
Using Libraries

• Java has thousands of utility classes organized
  into libraries. We will be using some of them,
  for example
• java.io. for input/output
• java.lang. for standard features and threads
• java.text. for string processing
• java.util. for utilities and collection classes
• java.awt. for the abstract windowing toolkit
• javax.swing. for the swing classes.
• etc

9
Class or Instance Methods?

• Instance methods require an instance. If you find
  yourself frequently creating instances as
  temporary variables for use with some method, you
  should define a class (static) method to do the
  same thing.
• Similarly, you might find class methods useful
  for doing comparisons among individual instances,
  since the class method can access the private
  fields of the instances passed to it as arguments.

10
Chaining Constructors

• Its often convenient to chain constructors,
  calling one from another using the this(argument
  list) syntax.
• This is especially frequent in the input/output
  library.
• The BankingDataReader gives some good examples of
  this.

11
Memory Leaks

• Memory leaks can occur in Java if a valid but
  unused reference to an object is left in scope
• int big_array new int100000
• int result foo(big_array)
• // big_array is no longer needed but remains in
• // scope.
• big_array null // dumps it to avoid a leak
• for()handle_input() // loops forever
• Hash tables can also be a source of memory leaks.

12
Interfaces

• Interface Dig_up
• Object find(String name)
• Any class with a find function of the correct
  signature can claim to implement the Dig_up
  interface. Note that you can do this in C as
  well, but its much rarer there.

13
Constructors

• Assume Foo is a class with a default constructor
  (Foo()) and an int member field, val. The
  following is good Java coding style for a second
  constructor
• Foo(int val)
• this() // default constructor
• this.val val // Works!
• // sets the member field to val

14
Role of this

1. Used as a reference to the current object, much
   as in C.
2. this.bar is a reference to the bar field of the
   current object. Ditto for this.bar()
3. this() is used in initialization, much like
   super().