Chapter 3: Object-orientated programming Flashcards
Object
An entity that can take on a data-type value.
An instance of a data type.
Data abstraction
The ability to define new data types and to manipulate objects holding data-type values.
8 Primitive data types
- boolean
- byte
- char
- double
- float
- int
- long
- short
Data type
A set of values and a set of operations defined on those values.
API
Application programming interface
A document whose purpose is to provide the information needed to write programs using the data type.
Constructor
Creates an object and returns to the client a reference to the object, not the object itself.
Identity
The memory space associated with the object.
Pointer
An object whose value refers directly to another value stored elsewhere in the computer memory using its address.
Uninitialized variable
A variable that has been declared of a reference type but has not been assigned a value.
3 Essential properties of objects:
- state
- behavior
- identity
State of an object
A value from its data type.
Behavior of an object
Defined by the data type’s operations.
Identity of an object
The place where the object is stored in memory.
What is used to create objects in OOP?
constructors are invoked
How are object states modified in OOP?
instance methods are invoked
Assignment statement
A statement that creates a second copy of a reference.
It does not create a new object, just another reference to an existing object.
Aliasing
The situation where assignment statements don’t create a new object, but rather another reference to an existing object.
Both variables refer to the same object.
Immutable
A data type that has no methods that can change an objects’ value.
public entity
An entity that is accessible by clients
private entity
An entity that is not accessible by clients
final modifier
A modifier that indicates that the value of the variable will not change once it is initialized.
Convention to using public and private
public - Used for all methods and constructors in the API
private - everything else
Typical private methods
Helper methods, used to simplify code in other methods in the class.
Local variables
Variables to which there is just one value corresponding to each one at a given time
Instance variable
Variables to which to which there are numerous values corresponding to each one at a given time (one for each object that is an instance of the data type).
The process behind invocation of a constructor:
Java automatically:
- Allocates memory space for the object
- Invokes the constructor code to initialize the instance variables
- Returns a reference to the object
3 Types of variables
- Argument variables
- Local variables
- Instance variables
Encapsulation
The process of separating clients from implementations by hiding information.
3 Reasons for encapsulation
- Enables modular programming
- Facilitates debugging
- Clarifies program code
Wide interface
An interface with an excessive number of methods.
Techniques to reduce the effective width of an interface
- Use overloading to provide implementations of basic methods for all types of data
- Include methods that are orthogonal in functionality
Basic mantra for data types
Whenever possible, clearly separate data and associated operations within a program.
Primary value of API
They allow client code to ignore a substantial amount of detail found in the standard representations of these abstractions.
Java support for enforcing encapsulation
The private visibility modifier
Value of encapsulation enabling modular programming
Allows us to:
- Independently develop of client and implementation code
- Substitute improved implementations without affecting clients.
- Support programs not yet written
Value of encapsulation isolating data-type operations:
Leads to the possibility of:
- Adding consistency checks and other debugging tools in implementations
- Clarifying client code
Immutable data type
The property that the value of the object never changes once constructed.
Mutable data type
Manipulates object values that are intended to change.
Purpose of immutable types
To encapsulate values that do not change so they behave in the same way as primitive types.
We can use them without having to worry about their values changing.
Purpose of mutable types
To encapsulate values as they change.
Advantages of immutability
- Easier to use
- Less misuse (smaller scope of code to change their values)
Cost of immutability
A new object must be created for every type.
Java support for enforcing immutability
The final modifier
Final modifier
The object can only be assigned a value once, either in an initializer or in the constructor.
Inheritance
Support for defining relationships among objects.
Interfaces
Provide a mechanism for specifying a relationship between otherwise unrelated classes, by specifying a set of common methods that each implementing class must contain.
Subtyping
A powerful technique that enables a programmer to change the behavior of a class and add functionality without rewriting the entire class. This is done by defining a subclass.
Subclass
A Class that inherits instance variables and instance methods from another class - its superclass. The subclass contains more methods than its superclass.
Two reasons subtyping makes modular programming difficult:
- Any change in the superclass affects all subclasses - the fragile base class problem
- Subclass code - having access to instance variables - can subvert the intention of the superclass code.
Fragile base class problem
A state where the subclass cannot be developed independently of the superclass as it is completely dependent on its superclass.
Data mingin
The process of searching through the massive amounts of information now accessible to every user on the web.
Assertion
A boolean expression that you are affirming is true at that point in the program.
If the expression is false, the program will terminate and report an error message.
Purpose of assertions
They are widely used to detect bugs and gain confidence in the correctness of programs.
They also serve to document the programmer’s intent.
Design-by-contract programming model
The designer expresses a: - precondition - postcondition - invariats - side effects During development, these conditions can be tested with assertions (which can be used to aid in debugging).
Precondition
The condition that the client promises to satisfy when calling a method.
Postcondition
The condition that the implementation promises to achieve when returning from a method.
Invariants
Any condition that the implementation promises to satisfy while the method is executing
Side effects
Any other change in state that the method could cause.
