COMP1004 Programming Principles

Collection items

[img]
Preview
[img]
Preview
04 - Programming Principles: Computational Thinking
In this session we look at how to think systematically about a problem and create a solution. We look at the definition and characteristics of an algorithm, and see how through modularisation and decomposition we can then choose a set of methods to create. We also compare this somewhat procedural approach, with the way that design works in Object Oriented Systems. We also have a brief look at codings style in Java, with the help of the Google Java Style Guide: https://google.github.io/styleguide/javaguide.html

Shared with the World by
Prof David Millard
[img]
11 - Programming Principles: Polymorphism
In this session we build on inheritance and look at overriding methods and dynamic binding. Together these give us Polymorphism - the third pillar of Object Oriented Programming - and a very powerful feature that allows us to build methods that deal with superclasses, but whose calls get redirected when we pass in sub-classes.

Shared with the World by
Prof David Millard
[img]
Preview
[img]
Preview
Programming I - Starting Out
In this lecture we describe the structure of the Programming I module at the University of Southampton, look at the definitions and paradigms of programming, and take a look ahead to the key things that we will be covering in the weeks ahead.

Shared with the World by
Prof David Millard
[img]
Preview
05 - Programming Principles: Encapsulation and Constructors
In this session we look at the public and protected keywords, and the principle of encapsulation. We also look at how Constructors can help you initialise objects, while maintaining the encapsulation principle.

Shared with the World by
Prof David Millard
[img]
03 - Programming Principles: Methods
In this session we look at how to create more powerful objects through more powerful methods. We look at parameters and call by value vs. call by reference; return types; and overloading.

Shared with the World by
Prof David Millard
[img] [img]
Preview
06 - Programming Principles: Loops and Arrays
In this session we look at the different types of loop in the Java language, and see how they can be used to iterate over Arrays.

Shared with the World by
Prof David Millard
[img] [img]
12 - Programming Principles: Testing and Debugging
In this session we look at the sorts of errors that occur in programs, and how we can use different testing and debugging strategies (such as unit testing and inspection) to track them down. We also look at error handling within the program and at how we can use Exceptions to manage errors in a more sophisticated way. These slides are based on Chapter 6 of the Book 'Objects First with BlueJ'

Shared with the University by
Prof David Millard
[img]
Preview
[img]
Preview
01 - Programming Principles: Introduction to Java
In this lecture we look at key concepts in Java: how to write, compile and run Java programs, define a simple class, create a main method, and use if/else structures to define behaviour.

Shared with the World by
Prof David Millard
[img] [img]
Preview
08 - Programming Principles: The Java Library
In this session we point you at the Java Library, and go into some more details on how Strings work. We also introduce the HashMap class (a very useful type of collection).

Shared with the World by
Prof David Millard
[img] [img]
Preview
15 - Programming Principles: Designing Applications
In this session we look at the how to use noun verb parsing to try and identify the building blocks of a problem, so that we can start to create object oriented solutions. We also look at some of the challenges of software engineering, and the processes that software engineers use to meet them, and finally we take a look at some more Design Patterns that may help us reuse well known and effective solutions in our own designs.

Shared with the World by
Prof David Millard
[img] [img]
13 - Programming Principles: Software Design
In this session we look at some of the basics of good code design, including avoiding duplication and designing for loose coupling and high cohesion.

Shared with the University by
Prof David Millard
[img] [img]
Preview
07 - Programming Principles: Collections and Iterators
In this session we look at how we can use collection objects like ArrayList as a more advanced type of array. We also introduce the idea of generics (forcing a collection to hold a particular type) and see how Java handles the autoboxing and unboxing of primitives. Finally we look at Iterators, a common design pattern for dealing with iteration over a collection.

Shared with the World by
Prof David Millard
[img]
02 - Programming Principles: Variables, Primitives, Objects and Scope
In this session we look more closely at the way that Java deals with variables, and in particular with the differences between primitives (basic types like int and char) and objects. We also take an initial look at the scoping rules in Java, which dictate the visibility of variables in your program

Shared with the World by
Prof David Millard
[img]
Preview
Programming Principles: Conclusions
This is the revision session for our Programming Principles course. We remind ourselves of the three pillars of object oriented programming, look ahead to the exam, and share some parting advice.

Shared with the World by
Prof David Millard
[img]
10 - Programming Principles: Super and Sub-classes
In this session we introduce inheritance - one of the cornerstone concepts of object oriented programming. We look at how to define super and sub-classes, how to maintain encapsulation using the super() constructor, and why it is useful to use substitution to hold references to sub-classes in references typed as their super-class.

Shared with the World by
Prof David Millard
[img]
14 - Programming Principles: Abstract Classes and Interfaces
In this session we look at how to use Abstract Classes and Interfaces in Object Oriented Design - especially as a way to get all the advantages of multiple inheritance without any of the problems.

Shared with the World by
Prof David Millard
[img]
Programming Principles: The Strategy Pattern
Slides for COMP1004 Lecture on the Strategy Pattern

Shared with the University by
Dr Julian Rathke
[img]
Programming Principles: Statics
Slides for COMP1004 Lecture on Statics

Shared with the University by
Dr Julian Rathke
[img]
Programming Principles: Exceptions
Slides for COMP1004 Lectures on Exceptions

Shared with the University by
Dr Julian Rathke

COMP1004 Programming Principles

These are the resources used for the Computer Science course Programming Principles, designed to teach students the fundamentals of computer programming and object orientation via learning the Java language. We also touch on some software engineering basics, such as patterns, software design and testing. The course assumes no previous knowledge of programming, but there is a fairly steep learning curve, and students are encouraged to practice, practice, practice!

View Item

Toolbox

There are no actions available for this resource.