1302 test 2

Java’s way of casting types back and forth automatically between primitive and object based types (of wrapper classes) using the valueOf method to box

Creating new classes based on the definition of other classes. Great for avoiding redundant/tedious reuse. “IS A” relationship

Arrowhead points to superclass/parent class/supertype from subclass/child class/subtype

• public class Subclass extends Superclass {
• // implement Dog class
• }

Public constructors and methods of a superclass. Can use with any method that’s exists in superclass by matching appropriate method signatures.

• Use @Override before a subclass method that matches a superclass method exactly.
• For example a toString method that you want to return a different thing from the superclass than the subclass

• Java will execute all default constructors up the extends chain. ie, it will create a default superclass object for each subclass object that’s instantiated.
• For example- super(); is AUTOMATICALLY done when Dog() is invoked

Memory location? idk it is the parent class of all java classes

• Overriding- same name and method signature,
• Overloading- same name but different parameter list and return type

• Allows you to refer to a subclass using its super class type or vice versa (any subclass can be passed through a super class reference variable)....
• public void adopt(Animal a)—
• Good for flexibility

The process through which the Jvm decides at runtime what the actual type of an object is and uses the appropriate implementation. Declared type is dynamically binded with actual type.

When a dealing with polymorphic objects we can use instanceof with a super class instance to see if it’s an instance of a certain subclass

• Declared type is variable type declared, matches at compile time.
• Actual type is type of variable matched at runtime

• Implicit: Object o = new Student(); (can only cast DOWN to subtypes, up wouldn’t make sense to compiler. ie Student o = new Object();)
• Explicit: Student b = (Student) o; (can only cast UP, tells compiler that supertype is a subtype object. ie object is a student)

• To tell compiler that a subtype is an instance of a supertype so we can treat it like its actual type within a general polymorphic collection.
• Football is an instance of a sport —— Football fb2 = (Football)sp3; —-We do this because not all sports are football

(Overriding) equals() method inherited from Object class then seeing if the supertype is an instanceof another subtype, then checking if their data members are the same with return dataMember == explicitCast.dataMember

• ArrayList class stores unlimited number of OBJECTS whereas standard arrays are fixed size (can’t primitive types but can hold wrapped primitives)
• Must import java.util.ArrayList
• ArrayList cities = new ArrayList<>();
• Much more useful and flexible

• Collections.sort/shuffle/min/max(list);
• Create ArrayList from existing object array- new ArrayList(Arrays.asList(oldArray));

That’s how they work

• public Object pop() {
• Object o = list.get(getSize()-1);
• list.remove(getSize()-1);
• return o;
• }

• It groups classes
• package p1;

• Private->default->PROTECTED->public
• # in UML
• Grants access to any class in the same package and any subclass regardless of package.
• Different to default in that default is package private

Public

Public, protected

Public, protected, default

Public, protected, default, private

• Final on variables are constants
• Final on classes cannot be extended
• Final on methods cannot be overridden

• Objects created from impossible actions that terminate program execution unless handled.
• Gives us information about our programs
• Allows us to preform exception handling

• Exception handling code that can throw an exception.
• When an exception occurs- throw is called and “calls” catch
• If exception is thrown, execution goes immediately to catch block- nothing in try block executes

• System errors- (Error class) thrown by JVM, very rare (unchecked).
• Exceptions - (Exception class) thrown by your program, can be caught/handled (checked except for runtimes).
• Runtime exception - (RuntimeException class) thrown by programming errors (unchecked)

Declaring throwing and catching exceptions

• Checked- must be dealt with through try catch or declared in method header, customs? (exception)
• Unchecked - usually just a logic error (error, RuntimeException)

• throw new Exception();
• Exception ex = new Exception();
• throw ex;

throws declares exceptions while throw throws exceptions

• ArrayIndexOutOfBoundsException
• InputMismatchException
• NullPointerException
• Exception

Executed regardless of exception after catch clause

• If you want it processed by the caller, create an exception object and throw it
• If you can handle the exception in the method where it occurs, there is no need to throw it

• try {
• statements;
• } catch(Exception ex) {
• perform operations;
• throw ex;
• }.
• Do when throwing to a new method

Make a new class for it that extends Exception (checked because they extend exception)

All of try and finally are executed, execution starts after try-catch-finally

Skip rest of try, execute appropriate catch only, execute finally

Skip rest of try, skip all catch, execute finally, pass exception to calling method

• new File(“src/a.txt”);
• Always use relative paths and forward slashes, avoid absolute paths whenever possible (ie “home/me/src/a.txt”)
• Can’t read or write data from/to a file

• PrintWriter output = new PrintWriter(file); (sane methods as System.out.*)
• same thing with scanner.
• Must close the file with output.close(); for the file to be written

• Automatically closes object(s) after try block.
• try ( new PrintWriter object ) { code }
• Multiple resources can be declared inside parenthesis.
• Catch block can be omitted or used to catch exceptions

• Print stack trace shows: name of exception-message of exception- stack trace
• To string shows: name of exception- message of exception
• Get message shows: message of exception

Exceptions forced by the compiler used to indicate exceptions out of control of the program

By creating URL object and a scanner object with new Scanner(url.openStream()); to open an input stream