Chapter 2 - Object Orientation Flashcards
To answer all the Object Oriented questions on the exam
Encapsulation
helps hide implementation behind an interface or API.
Encapsulation code has 2 features
- ) Instance variables are kept protected - usually with the private modifier
- ) Getter and setter methods provide access to instance variables
IS-A
Refers to inheritance or implementation
IS-A
is expressed with the keyword extends
HAS-A
means an instance of one class “has a” reference to an instance of another class or another instance of the same class.
Polymorphism means
many forms
A reference variable
is always of a single, unchangeable type, but it can refer to a subtype object.
A single object can be referred to by reference variables of many different types
as long as they are the same type or supertype of the object.
The reference variables type (not the object type)
determines which methods can be called
Polymorphic method invocations
apply only to overridden instance methods
Methods can be overridden or overloaded
constructors can be overloaded but not overridden
Abstract methods
must be overridden by the first concrete (non-abstract) subclass
An overriding method
- must have same arg list
- must have same return type, the return type can be a subclass - known as a covariant return
- must not have a more restrictive access modifier
- my have a less restrictive access modifier
- Must not throw new or broader checked exceptions
- May throw fewer or narrower exceptions or any unchecked exception
final methods
cannot be overridden
Only inherited methods
may be overridden… private methods are NOT inherited
overloading means
reusing a method name, but with different arguments
Overloaded methods
- must have different argument lists
- May have different return types, if arg lists are also different
- May have different access modifiers
- May throw different exceptions
Methods from a superclass
can be overloaded in a subclass
Polymorphism applies to overriding
not to overloading
Object type (not the reference variables type)
determines which overriding method is used at runtime
Reference type determines
which overloaded method will be used at compile time
Two types of reference variable casting
downcasting and upcasting
Downcasting
Reference variables of subtypes must be explicitly cast, resulting in access to the subtypes members with this new reference variable.
Upcasting
can be done explicitly or implicitly.
When you are implementing an interface
you are fulfilling its contract
You implement an interface properly when…
you concretely override all of the methods defined by the interface
A single class can implement
many interfaces
Overloaded methods can change return types
overridden methods cannot, except in the case of covariant returns
An array is a legal return type
both to declare and return as a value
Methods with primitive return types
any value that can be implicitly converted to the return type can be returned
Nothing can be return from a void
but you can return nothing by simply saying return
Methods with an object reference return type
can return a subtype
Methods with an interface return type
can return any implementer
A constructor is always invoked
when a new object is created
Each superclass in an objects inheritance tree
will have a constructor called
Every class,even abstract class
has at least one constructor
Constructors must have the same name
as the class
Constructors don’t have a return type
If you see a return type, its a method with the same name as the class, its NOT a constructor
Constructors can use
any access modifier (even private!)
The compiler will create a default constructor
if you don’t create one in your class
The default constructor
is a no-arg constructor, if you don’t create any constructors in your class
The first statement in a constructor MUST
call either this()… an overloaded constructor
or
super()
Instance members are accessible only
after the superclass constructor runs
Abstract classes have constructors
that are called when a concrete subclass is instantiated
Interfaces do not have
constructors
If your superclass does not have a no arg constructor
you MUST create a constructor and insert a call to super() with args matching those of the superclass
Constructors are never inherited
thus they cannot be overloaded
A constructor can be directly invoked only by another constructor
using a call to super() or this()
this
- may appear only as the first statement in a
constructor - the arg list determines which overloaded constructor is called
constructors can call constructors, can call constructors …
sooner or later a call to super() or the stack will explode
calls to this() and super()
cannot be in the same constructor
use static methods
to implement behaviors that are not affected by the state of any instances
use static variables to hold data
that is class specific, there is only one copy of static variables
All static variables belong to the class
not to an instance
A static method cant access
instance variables directly
Use the dot operator
to access static members
static methods
can’t be overridden, but they can be redefined
coupling
refers to the degree to which one class knows about or uses members of another class
lose coupling
is the desirable state of having classes that are well encapsulated
tight coupling
is the undesirable state
cohesion
refers to the degree in which a class has a single, well defined role or responsibility
Hi cohesion is desirable
members support a single, well-focused responsibility
low cohesion is undesirable
whose members support multiple, unfocused roles or responsibilities
