Summary
Summary Programming (FEB22012X)
- Course
- Institution
Comprehensive summary of Programming (econometrics EUR)
[Show more]
Seller
Follow
LeonVerweij
Reviews received
Content preview
Week 1Primitive types
The eight primitive types are: byte, short, int, long, float, double, char and boolean
All other types are non-primitive types
Automatic conversion is only possible if the conversion goes from a more specific to a more
general type
Non-primitive types
String, Scanner and arrays are examples of non-primitive types. Classes created yourself
result in new non-primitive types. For every primitive type there is an associated non-
primitive type. Java supports autoboxing of primitive types, so these types are automatically
converted to the right type
Objects
Objects hold data in their instance variables, the configuration of these instance variables is
the state of the object. Objects do things when methods are called on the object.
Every object (instance of a class) has its own copy of the non-static instance variables
Public/private
Public instance variables can be accessed from anywhere, private ones only within the same
.java file as where they are defined
Method
A method operates on the object we call it on, can use the current instance variables of the
object and can modify the state of the instance variables of the object if it is mutable
Class variables
Class variables are static, final values, such as Math.PI
Static/non-static
Static methods are not associated with an object and cannot access instance variables.
A static variable belongs to and class and not to an object. Static methods can access only
static variables. A not-static method can access both static and non-static variables
Objects and references
Variables of a primitive type store a value and variables of a non-primitive type store a
reference. So, when a non-primitive type is copied, it means it just has the same reference
Immutable objects
Immutable objects never change their state, they hold values just as primitive types.
Non-primitive versions of primitive types are all immutable
Immutable class
When making an immutable class, make all the instance variables final, and let the methods
return new instances instead of change the current instance
Week 2
‘this’ keyword
When instance variables are used in methods and constructors, we implicitly assume they
refer to the current or local instance. We can refer to the current or local instance explicitly
with the keyword this. So, that will be this.instanceVariable = …
Null
The null reference is used to indicate that there is no object. Instance variables with a non-
primitive type always get ‘null’ as the default value. If we try to call a method on a variable
that is null, we will get a ‘NullPointerException’ and the program will stop. When concerned
a variables is ‘null’, you can do a ‘null’ check. It is important to initialize your non-primitive
instance variables in your constructor, or you will run into the risk of getting
‘NullPointerExceptions’. ‘null’ can also be used to return if for example no object was found.
, Random numbers
Since computers words deterministically, generating random numbers is not easy. The idea
to get a pseudo random number is to define an extremely long sequence of numbers, then
start at a point in this sequence, the seed, and use the following numbers in the sequence as
your random values. The seed can be picked randomly by using current time for example.
Errors
- Syntax errors: grammatical error, program will not run
- Type error: error when wrong type is used, program will not run
- Structural error: error concerning the structure of the code, program will not run
- Semicolon on the wrong spot
- Wrong mathematics
- ‘ArrayIndexOutOfBoundException’: the index is not existing in the array
- ‘OutOfMemoryError’: loop goes on too long
- ‘StackOverFlowError’: method refers to itself, memory is stored at stack and fits no more
Types of errors
- Compiler errors: syntax, types, structure
- Runtime errors: something unexpected happens during execution
- Logical errors: program executes fine but gives wrong answer/behaviour
Exception handling
Java has special features incorporated into the language that can pass control from the point
a runtime error was detected to a handler. You can raise an exception with the ‘throw’
keyword. After a ‘throw’ action, the method will stop. You can put ‘throws’ in the method
header to indicate that the method might throw an exception. An exception is an object
Exception types
Exceptions that may be caught:
- IllegalArgumentException
- NumberFormatExcteption
- IllegalStateException
Exceptions that must be caught or declared in the method header using ‘throws’:
- IOException
- FileNotFoundException
Some problems are so severe that you should stop your program if occur, these are errors:
- OutOfMemory Error
- StackOverflowError
‘finally’
‘finally’ can also be used with ‘try’. The ‘finally’ block is always executed as soon as the try
block is exited, no matter for what reason. Try to avoid finally.
Design principles
Exceptions are meant to deal with exceptional situation, they should not be used for regular
control flow. Throwing and handling of exceptions is not optimized.
You should throw early and catch late. Check the input of a method before you start doing
computations. If the input is not okay, throw an exception. If an exception can occur within a
method that is not able to provide a good solution to the problem, the exception should be
thrown to the caller. And never use return in a finally block.
Week 3
Polymorphism
Treating objects of completely different classes in a uniform way.
The benefits of buying summaries with Stuvia:
Guaranteed quality through customer reviews
Stuvia customers have reviewed more than 700,000 summaries. This how you know that you are buying the best documents.
Quick and easy check-out
You can quickly pay through credit card or Stuvia-credit for the summaries. There is no membership needed.
Focus on what matters
Your fellow students write the study notes themselves, which is why the documents are always reliable and up-to-date. This ensures you quickly get to the core!
Frequently asked questions
What do I get when I buy this document?
You get a PDF, available immediately after your purchase. The purchased document is accessible anytime, anywhere and indefinitely through your profile.
Satisfaction guarantee: how does it work?
Our satisfaction guarantee ensures that you always find a study document that suits you well. You fill out a form, and our customer service team takes care of the rest.
Who am I buying these notes from?
Stuvia is a marketplace, so you are not buying this document from us, but from seller LeonVerweij. Stuvia facilitates payment to the seller.
Will I be stuck with a subscription?
No, you only buy these notes for $7.60. You're not tied to anything after your purchase.
Can Stuvia be trusted?
4.6 stars on Google & Trustpilot (+1000 reviews)
64438 documents were sold in the last 30 days
Founded in 2010, the go-to place to buy study notes for 14 years now