Browse by Tags: java

Up a level
Export as [feed] Atom [feed] RSS 1.0 [feed] RSS 2.0
Number of items: 36.
  1. collection
    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!

    Shared with the World by
  2. [img]
    Preview
    Event Driven Programming in Java
    Event driven programming is a way of writing a program that works by responding to things happening (rather than executing a preplanned series of tasks). It is most often used to manage more advanced user interactions, such as GUI programs. In this session we look at how event driven programming works in Java GUIs, as both an introduction to events (using MouseListeners), and also to the way that GUI programs are constructed.

    Shared with the World by
  3. [img]
    Explaination of ArrayList remove() Methods
    In the example code you can see that when the remove(Object o) method is called the Integer is not cast to an int and the matching is done using the object's .equals() method rather than using ==

    Shared with the World by
  4. [img] [img]
    How to import files from your J drive into Teamsite
    An update to Java meant that you can only import files into Teamsite from your 'My Documents' folder, which isn't much use if they are all stored on your J drive. This video shows you how to fix the problem.

    Shared with the University by
  5. [img]
    Preview
    [img]
    Introduction to JavaScript Programming
    These are the resources for an introductory lecture in JavaScript programming. Exercises are provided to practice simple JavaScript programming, including a template for a DHTML implementation of Conway's Game of Life (with encrypted solution).

    Shared with the World by
  6. [img]
    Java path setting batch file
    This is a batch file written to help students on ECS' Programming 1 course (COMP1202) using iSolutions machines which have the JDK, but do not add it to the PATH variable, making compilation from the command line difficult. It attempts to find the JDK directory and add it to the Windows PATH. The code is as follows: @SET JAVA_HOME=C:\Program Files\Java @FOR /F %%G IN ('DIR /B "%JAVA_HOME%\JDK*"') DO @SET JDK_HOME=%JAVA_HOME%\%%G @SET PATH=%JDK_HOME%\bin;%PATH% @javac -version @echo. @echo %JDK_HOME%\bin successfully added to Windows PATH @echo. @echo Now type 'javac'. @echo. @echo. @echo. @CMD

    Shared with the World by
  7. [img]
    Preview
    [img]
    Preview
    Lecture 1 - Starting out
    What is Programming? A useful definition Object Orientation (and it’s counterparts) Thinking OO Programming Blocks Variables Logic Data Structures Methods

    Shared with the World by
  8. [img]
    Preview
    [img]
    Preview
    Lecture 2 - Java
    Programming Overview The JVM (The Java Virtual Machine) A brief look at Structure Class Method Statement Magic incantations main() output Coding a Dog Programming Principle(1) If and Boolean operations Coding a Bank Account Quick look at ToolBox

    Shared with the World by
  9. [img]
    Preview
    [img]
    Preview
    Lecture 3 - Objects Ahoy
    Variables - Objects and Primitives, Quick look at scope

    Shared with the World by
  10. [img]
    Preview
    [img]
    Preview
    Lecture 4 - Methods and Stuff
    Banking Parameters and arguments Passing Objects Primitives Returning Getters and Setters

    Shared with the World by
  11. [img]
    Preview
    [img]
    Preview
    Lecture 5 - Constructors
    Constructors With one parameter With two parameters Overloading Constructors and methods

    Shared with the World by
  12. [img]
    Preview
    [img]
    Preview
    Lecture 7 - Going Loopy
    Looping while do while for Arrays indexes For each loop

    Shared with the World by
  13. [img]
    Preview
    [img]
    Preview
    Lecture 8 - über-Arrays
    ArrayList ArrayList vs Array Declaration Insertion Access Removal Wrapper classes Iterator object

    Shared with the World by
  14. [img]
    Preview
    [img]
    Preview
  15. [img]
    Preview
    [img]
    Preview
    Lecture 12 - Scope
    Instance Variables Local variables Cool 3D Modelling! “this” keyword

    Shared with the World by
  16. [img]
    Preview
    [img]
    Preview
    Lecture 13 - It runs in the family
    Inheritance Code duplication Super classes Constructors Polymorphic collections “Anywhere a super class is, a sub class can go” Casting A great deception

    Shared with the World by
  17. [img]
    Preview
    [img]
    Preview
    Lecture 14 - Exploring Polymorphism
    Which methods are where? Overriding Calling super’s methods Coupling and cohesion

    Shared with the World by
  18. [img]
    Preview
    [img]
    Preview
    Lecture 15 - Interface this
    A quick word about abstract How a class interfaces Making Pets The Deadly Diamond of Death Interfaces (not interfaces)

    Shared with the World by
  19. [img]
    Preview
    [img]
    Preview
    Lecture 16 - I can't hear you through the static
    Static Types of methods Instance Static Example Calling Static methods Why Static Final

    Shared with the World by
  20. [img]
    Preview
    [img]
    Preview
    Lectures 17 and 18 - Exceptions - when it all goes wrong
    Exceptions An Example The Throws keyword Try and Catch The flow Multiple exceptions Finally How exceptions are thrown What the complier checks Handle or Defer Recovery Writing your own

    Shared with the World by
  21. [img]
    Preview
    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
  22. [img]
    Preview
    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
  23. [img]
    Preview
    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,

    Shared with the World by
  24. [img]
    Preview
    [img]
    Preview
    Programming Principles: Conclusions
    This is the revision session for our Programming Principles course. We take a whistle-stop tour of the topics covered in the course, look at the three pillars of object oriented programming, and look ahead to the exam.

    Shared with the World by
  25. [img]
    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 University by
  26. [img]
    Preview
    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
  27. [img]
    Preview
    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
  28. [img]
    Preview
    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
  29. [img]
    Preview
    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
  30. [img]
    Preview
    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
  31. [img]
    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
  32. [img]
    Preview
    Programming Principles: Starting Out
    In this lecture we describe the structure of the Programming Principles course at 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
  33. [img]
    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 University by
  34. [img]
    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
  35. [img]
    Preview
    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
  36. [img]
    Preview
    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
This list was generated on Tue Oct 17 11:29:17 2017 UTC.