Final Exam Review Flashcards
Why Java?
- well documented and standardised across platforms
- OOP concepts have simple and easy to understand behaviour
- great libraries for handling basic collections
- easy to manage multiple threads
- garbage collector (no delete)
Java references
all object variables, refer to data in memory (pointers in C++)
Classes consist of…
member variables, constructors, methods
What is an object?
an instance of some class
extends
Java keyword to express one class is a child of another class (inherits member variables and methods)
method overriding
if a child class has identical method signature as parent class, child class method overrides parent class method
super
keyword used to access resources from parent class
structure of a method signature
access-modifier return-type name input-arguments
protected (access modifier)
can be accessed internally and within child classes
polymorphism
when parent class reference refer to a child class object
method overloading
two methods have same name but different signatures so no conflicts occurr
what does an interface and a class that implements that interface look like?
// Interface
interface Animal {
public void animalSound(); // interface method (does not have a body)
public void sleep(); // interface method (does not have a body)
}
// Pig “implements” Animal interface
class Pig implements Animal {
public void animalSound() {
// The body of animalSound() is provided here
System.out.println(“The pig says: wee wee”);
}
public void sleep() {
// The body of sleep() is provided here
System.out.println(“Zzz”);
}
}
abstract class
partially specified class that cannot be instantiated (but can be extended by a child class)
abstract method
method that is declared without implementation
what are the differences between an abstract class and an interface?
- polymorphism works with both
- a class can implement multiple interfaces but can extend one abstract class
- abstract classes can include some implemented methods
primitive data vs objects
primitive data types are predefined and stored in the stack
objects are created by users (value stored in stack, the real variable in heap)
process
ongoing execution of a computer program (don’t share resources with each other)
thread
a means to split execution into multiple simultaneous executions
code multithread in Java
// Make a subclass of thread
class MultithreadingDemo extends Thread {
public void run()
{
try {
// Displaying the thread that is running
System.out.println(
“Thread “ + Thread.currentThread().getId()
+ “ is running”);
}
catch (Exception e) {
// Throwing an exception
System.out.println(“Exception is caught”);
}
}
}
ORR
// Implement Runnable interface
class MultithreadingDemo implements Runnable {
public void run()
{
try {
// Displaying the thread that is running
System.out.println(
“Thread “ + Thread.currentThread().getId()
+ “ is running”);
}
catch (Exception e) {
// Throwing an exception
System.out.println(“Exception is caught”);
}
}
}
synchronised *Java keyword
prevents method from being executed until the previous call to the same method ends
why separate design and implementation?
interfaces and abstract classes are used for design, you can change implementation independently of interface
static *Java keyword
static member variables can be accessed without creating object, static resources are shared with objects of same class
git init
turn local directory into git repository
.gitignore
lists files that cannot be committed
staging
git add <file>
#prepare file to be committed
git reset</file>
git stash
stores temporary changes for later
git stash pop
git checkout – <file></file>
branching
allows you to track multiple versions of the files in your repo
master is the primary branch
git branch (list branches)
git branch <name> (create branch)
git checkout <name> (switch branch)
git merge <name> (merge branch with current branch)</name></name></name>
git remotes
allow you to have multiple copies of your repo on different computers and servers
origin – name of primary remote
git remote -v (list remotes)
git remote add <remote_name> <url>
git pull <remote_name> <branch>
git push <remote_name> <branch></branch></remote_name></branch></remote_name></url></remote_name>
How do you share updated code with teammates in git?
- save changes
- add/stage changes
- commit changes
- pull
- resolve merge conflicts
- push
How do you resolve a merge conflict on git?
- manually fix all files
- git commit
- save log file and exit text editor
How do you safely merge feature branch to team’s development branch?
- checkout feature branch
- merge with development branch
- resolve merge conflicts, commit
- checkout development branch
- merge with feature branch
When should you create an issue on GitHub?
you encounter bug, you see ugly code, you want to optimise existing code, you want to add a new feature, you want to build a test for an existing feature
