Lecture 1

Introduction to Software
Construction
 Overview
 In earlier courses, you learned how to write programs to solve
small problems.
 In this course we teach programming “in the large”.
 Large software systems have many stakeholders.
 What will its users want?
 Can we describe user requirements, accurately and succinctly?
 Large software systems are very complex.
 Can we describe the design of a complex software system, accurately
and succinctly?
 Can we be sure that a complex system will do what it is designed to do,
and that it will not do anything unintended?
 In this course you will learn some incomplete answers to these
difficult questions.
 I will also attempt to teach you how to “learn how to learn” the technical
skills you will need in the future – as a competent computer
professional.
2
 Syllabus
 Four Themes:
 The object-oriented programming paradigm
 Object-orientation, object-oriented programming concepts and programming
language constructs – because, for many important problems, OO design is a
convenient way to express the problem and its solution in software.
 Frameworks
 Inversion of control, Abstract Window Toolkit (AWT) Swing, Google Web Toolkit
(GWT), Flutter, ReactNative, Laravel and many more – because many
important “sub-problems” have already been solved: these solutions should
be re-used!
 Software quality
 Testing, inspection, documentation – because large teams are designing,
implementing, debugging, maintaining, revising, and supporting complex
software.
 Application-level concurrent programming
 Multithreading concepts, language primitives and abstractions – because
even our laptops have multiple CPUs. Dual-core smartphones are now
available...
3
Agenda & Reading
 Topics:
 Review (or learn for the first time?)
 What is Object-Oriented Programming?
 Classes & Objects
 Variables & Methods
 Introduction to OO Design
 A process of determining what the stakeholders require,
designing a set of classes with objects which will meet these
requirements, implementing, and delivering.
 Structure Diagrams: high-level design
 Use Cases: high-level requirements
 Other concerns: implementation, quality assurance

4
Software Design
 Communication:
 identify stakeholders, find out what they want and need.
 Planning:
 list tasks, identify risks, obtain resources, define milestones, estimate
schedule.
 Modeling:
 develop structure diagrams and use cases, maybe some other UML
artifacts.
 Construction:
 implement the software, with assured quality.
 Deployment:
 deliver the software, then get feedback for possible revision.
To learn more:
R. Pressman, Software Engineering: A Practitioner’s Approach, 7th Ed.,
2010, pp. 14-15.
5
 What is Object-Oriented Design?
 In OO design, a system is a
 collection of interacting objects.
 Each object should have simple attributes Program
and behaviours. object 2 object 1
 Each object should have simple relations to
other objects.
object 3 object 4
 In procedural design, a system is a
 collection of basic blocks.
 Each basic block should have a simple effect
on local and global variables.
 Basic blocks are linked by control-flow arcs:
if/then/else, call/return, while/loop, for/loop,
case, goto, …
 In data architecture, a system is a
 collection of data structures, with access
and update methods.
 6Each data structure should have simple
relations to other data structures.
 What is an Object?
 A building block for OO development
 Like objects in the world around us
 Objects have state and behaviour
 Examples:
 Dog
 State/field/attribute: name, colour, isHungry, …
 Behaviour: bark(), fetch(), eat(), …
 Bicycle
 State: gear, colour, …
 Behaviour: brake(), turn(), changeGear(), …
 VCR
 State: brand, colour, isOn …
 Behaviour: play(), stop(), rewind(), turnOn(), …
7
 Classes & Objects
 Class
 A set of objects with shared behaviour and individual state
 Individual state:
 Data is stored with each instance, as an instance variable.
 Shared behaviour:
 Code is stored with the class object, as a method.
 Shared state may be stored with the class object, as a class
variable.
 Object
 Objects are created from classes at runtime by instantiation
 usually with New.
 There may be zero, one, or many objects (instances) of a class.
 Instantiated objects are garbage-collected if no other
user-defined object can reference them.
8
 Imagine a world of communicating objects
 Object
 An object remembers things (i.e. it has a memory): its state.
 An object responds to messages it gets from other objects.
 It performs the method with the given parameters, then sends a
response.
 An object that receives a strange message may throw an exception.
Be careful!
 An object’s method may “ask for help” from other objects.
 It sends a message to an object, and waits for a response.
 A method may send a message to itself! This is called recursion.
Be careful.
 Messages between objects
 Usually: method calls and method returns, sometimes
exceptions.
9
Information Hiding
 The implementation details of a method should be
of no concern to the sender of the message.
 If a JavaKid tells a JavaDog to fetch(), the dog
might run across a busy street during its fetch().
 Parameterised methods allow the senders to have
more control over object behaviour. For example, a
JavaDog might have a parameterised fetch() method:
ball = dog.fetch(SAFELY);
 Note: in these lecture slides, the word “should”
indicates an element of style.
 You should write Java code that is understandable to
other Java programmers.

10
 Example 1: Ball
 Attributes
Example:
 Represent the internal state of Ball.java
public class Ball
an instance of this class. {
 Constructor public final static int SIZE = 20;
private int xPos;
 Creates the object private int yPos;
private Color color;
 Methods public Ball(int x, int y, Color c) {
xPos = x;
 Implement the processing yPos = y;
performed by or to an object, color = c;
often updating its state. }
public void move(int deltaX, int deltaY) {
 If there are read and write xPos += deltaX;
methods for an attribute x, yPos += deltaY;
}
these should be called getX() public void paint(Graphics g) {
and setX(). g.setColor(color);
 You should learn Java’s g.fillOval(xPos,yPos,SIZE,SIZE);
}
conventions for capitalisation
}
11 and naming.
 Object Instantiation
 When a constructor method is called, a new instance is
created.
Ball b = new Ball( 10, 20, Color.Red ); b: Ball c: Ball
Ball c = new Ball( 0, 10, Color.Blue );
xPos = 10 xPos = 0
yPos = 20 yPos = 10
Color = Red Color =
Blue

 If a class definition doesn’t include a constructor method,

the Java
public classcompiler
Class1 {
private int x;
inserts a default constructor with default
Class1 d = new Class1();
initialisations.
// Note no explicit constructor
public int increment() { d: Class1
++x;
} x=0
} // is this good
12 code?