DSA Quiz 2
Restrictions for defining abstract classes and methods
- A class has to be declared abstract if it contains any abstract methods - Abstract methods cannot be private or static - A constructor cannot be abstract
Conditions for polymorphism
- Classes are in the same hierarchy - All subclasses override the same method - Subclass reference is assigned to superclass reference - Superclass object reference is used to call the method
What should you do if you get a run time error?
- Look at the stack trace
Using print statements in debugging
- Put before, in, or after method call - Use boolean debug statements to turn off and on - Use logger class
What should you do if you get a syntax error?
- Read compiler message - Look for red lines
What should you do if you get a logic error?
- Use print statements or the debugger
How to figure out if an algorithm is a certain time complexity
1. Put in terms of f(n) <= c*g(n) for n >= n_0 (plug in f(n) and g(n)) 2. Simplify 3. Pick c and n_0
Abstract classes
A class that cannot be instantiated (can't use new on it). It can only be extended and is used to define base classes.
Analysis of algorithms
A measure of the amount of resources necessary to execute a section of code. The efficiency or running time of an algorithm stated as a function relating the input size/length to the number of steps (time complexity) or storage locations (space complexity).
.equals()
A method used to check equality of two Objects.
.toString()
A method used to return a text version of an Object. The .toString() method in the Object class returns the class name and the memory address of the object (Class@32134af, for instance)
protected access modifier
Access is restricted to the containing class and to any class that is derived directly or indirectly from the containing class.
Logic error
An error in a program that makes it do something other than what the programmer intended.
Syntax error
An error in a program that makes it impossible to parse — and therefore impossible to interpret.
Runtime error
An error that does not occur until the program has started to execute but that prevents the program from continuing.
Big Omega
Best case (lower bound)
Pros and cons of protected
Can be accessed directly by subclasses, but subclasses also need to enforce validation rules. Only use protected when you need high performance and avoid setting values of protected fields in subclasses
Overriding methods
Changing the definition (body) of an inherited method to suit the subclass.
Highly cohesive
Code for any given state or behavior is only located where it is necessary for the definition of that (inheritance is one way Java enables this, as it allows subclasses to specify the code from the superclass further in a way that is appropriate only to their definitions)
shallow copy
Copying only the reference to an object.
.clone()
Creates and returns a SHALLOW copy of an object (i.e., if something is set equal to a clone, and the original or copy is changed, both are changed)
Subclass constructor
Default constructor of subclass automatically calls that of superclass. super(argument list) explicitly calls the superclass's constructor (has to be the first statement in the subclass constructor)
Writing your own .equals()
Default equals method is probably not going to work. Your equals method should be (5): - Reflexive (a.equals(a) == true) - Symmetric (a.equals(b) == b.equals(a)) - Transitive (a.equals(b) && b.equals(c)) == a.equals(c)) - Consistent - Null-check
final modifier
Does not allow the method to be overridden
Object (the class) inheritance
Every object inherits from the Object class
Object default constructor
Has no arguments, allocates memory (on the heap) and returns reference
Subclass substitution rule
If a superclass object is called for in an expression, a subclass may be substituted
Finding Big O
Ignore constants and low-order terms
Choosing an algorithm
In general, choose the asymptotically superior algorithm. For lower inputs, it doesn't really matter
Loosely coupled
Modules that are relatively independent. Loosely coupled modules are easier to maintain and modify, because the logic in one module does not affect other modules.
Child of an abstract class
Must override all of the abstract methods, or it will be abstract itself
Rank the common complexity classes from lowest growth to highest
O(1), O(log n), O(n), O(n log n), O(n^2), O(2^n), O(n!)
Complexity classes
O(1), O(log n), O(n), O(n log n), O(n^2), O(n^3),..., O(2^n)
Constant time
O(1). An operation whose runtime does not depend on the size of the data structure.
Exponential time
O(2^n). Example: Towers of Hanoi, recursive Fibonacci implementation, etc.
Logarithmic time
O(log n). Usually base 2, meaning the algorithm divides some space in half repeatedly. Example: binary search
Log-linear time
O(n log n). Example: best sorting algorithms (quicksort and mergesort)
Quadratic time
O(n^2). the number of steps is proportional to the square of the input size. Example: worse sorting algorithms, pretty much anything with nested for loops
.hashCode()
Returns a unique int for the object
T(n) = O(f(n))
T(n) is the time for algorithm on input size n. f(n) is a simpler function that grows at about the same rate
instanceof
The Java language provides the ________ keyword to determine an object's class type at run time
f(n) is O(g(n))
The growth of f(n) must be less than or equal to the growth of g(n). The function with higher growth goes in the O( ), as the function with lower growth is included in the set of functions whose worst case is the higher growth.
extends keyword
The keyword the specifies that a class inherits data and functionality from an existing class. A class can only extend at most 1 other class
Object class
The name of the Java class that is the "mother" of all objects. All other Java class automatically inherit the Object class as the top-level parent class in the hierarchy. This class provides basic methods such as the toString, hashCode, and equals methods.
Overloading
The process of creating multiple methods of the same name but with different signatures
Inheritance in Java
The relationship between a more general superclass and a more specialized subclass
abstract modifier
This modifier indicates that the thing being modified has a missing or incomplete implementation. This modifier can be used with classes, methods, properties, indexers, and events.
Shadowing variables
When a child class declares a variable with the same name as one that is inherited from the parent. Should be avoided
Method overriding
When a child class overwrites a method inherited from a parent class.
Widening conversion
When java converts a lower-ranked value to a higher-ranked type, it is called a
Big O is what case
Worst case (upper bound)
Can you declare an abstract class?
Yes, but you cannot instantiate one.
this keyword
a keyword used to refer to the current object in a method or constructor
Big O
an abstracted function that describes the amount of computer time or memory space required by an algorithm, as a function of problem size. For problems larger than a certain size, the actual time or space required will be less than the Big O multiplied by some constant.
super reference
can be used to refer to the parent class, and often is used to invoke the parent's constructor
A deep copy of an object:
is an operation that copies an aggregate object, and all the objects it references
static keyword
is used to declare members that do not belong to individual objects but to a class itself.
Dynamic binding
making a run time decision about which instance method to call.
Getters and Setters
public method of accessing private members. Important to validate input in setter
Basic operation
the operation that contributes most towards the running time of the algorithm
Big theta
tight bound