- __multiple inheritance__: the ability to inherit more than one type.
- Java onnly allows multiple inheritance for interfaces. If java allowed multiple inheritance for classes, the instance variables and methods could become ambiguous.
- some languages allow multiple inheritance from concrete classes. Inheriting from multiple classes called __mixins__.
- These mixin classes aren't meant to be instantiated, only inherited from.
- some languages allow multiple inheritance from concrete classes. Inheriting from multiple classes called __mixins__.
- These mixin classes aren't meant to be instantiated, only inherited from.
- java approximates this with interfaces
- interfaces __extend__ other interfaces, but classes __implement__ interfaces.
- According to the book, "Java interfaces that approximate teh mixin include:"
- According to the book, "Java interfaces that approximate the mixin include:"
-`java.lang.Cloneable`
-`java.lang.Comparable`
-`java.util.Observer` which adds an update feature to a class that whishes to be notified when certain "ovservable" objects change state.
-`java.util.Observer` which adds an update feature to a class that whishes to be notified when certain "observable" objects change state.
- The book doesn't offer much information on how these methods are implemented, just that mixins implement them.
### 2.3.3 Abstract Classes
- abstract classes include teh __abstract__ modifier in their class definition.
- Abstract classes can't be instantiated themselves. They must be overridden to be instanteiated.
- Abstract classes provide a mix between the completely unspecified functionality of an interface, and the completely specified functionality of a concrete class.
- Abstract classes can have abstract methods that also have the __abstract__ modifier, don't have a method body, and must me instantiated by their subclasses.
- Although abstract methods have no body, they can be called from other methods within the abstract class because their subclasses *must* implement them. This is a design pattern known as __template method pattern__
-Syntax:
- Abstract classes can:
- not be instantiated
- inherit and be inherited like a normal concrete class (with extra rules about abstract methods).
- Like a normal class, abstract classes only support single inheritance.
- define __abstract methods__ that don't have a body, like methods of an interface.
- classes that extend abstract classes must implement the abstract methods or be abstract themselves.
- define concrete members (methods and variables) of the class, like a normal class.
- Use abstract methods from concrete methods.
- This is only possible because an abstract class can't be instantiated and the abstract method must be implemented in the class that inherits it; therefore you know that when an object of your subclass uses the abstract method from your abstract class's concrete method, it will be defined.
- This is a design pattern known as __template method pattern__.
- Abstract classes encourage code reuse, robustness and abstraction by:
- Preventing improper instantiation which makes code robust.
- Using abstract methods from a concrete context in your abstract class essentially gives your base class knowledge of its sub-class, which encourages code reuse.
- Giving programmers the ability to define relationships they wouldn't otherwise be able to define. This encourages code reuse.
#### Mechanics of Abstract Classes in Java
- abstract classes and methods include the __abstract__ modifier in their class definition.
```java
//syntax
publicabstractclassExampleAbstract{
publicvoidexampleAbstractMethodCall(){
...
...
@@ -182,4 +198,307 @@ public abstract class ExampleAbstract{
## 2.4 Exceptions
-
- In java, exceptions are *thrown* when an unexpected, possibly dangerous situation occurs.
- When thrown, exceptions will crash your program with an error message unless they are *caught* and handled by the programmer.
- There are different types of exceptions.
### 2.4.1 Catching Exceptions
- uncaught exceptions print the stack trace of the program. The stack trace shows all the nested method calls up to the error.
- at each nesting, a thrown exception can be caught or left uncaught. If uncaught, the exception bubbles up to the next most outer nesting.
- Java uses the *try-catch* catches exceptions thrown in the guarded body of the _try block_, and handles them in the _catch block_. If no exceptions are thrown, the catch blocks are ignored.
```java
//smiple example
try{
//guarded body
}catch(SpecificExceptionTypeexceptionVariable){
//handling block for exceptions of SpecificExceptionType
}catch(GeneralExceptionTypeexceptionVariable){
//a more general catch block
}finally{
//executed after try/catch with or without errors
}
```
- In the above example:
-`SpecificExceptionType` can be any type, and `exceptionVariable` is the exception object that was thrown. These exception objects all ultimately override [Throwable](https://docs.oracle.com/javase/7/docs/api/java/lang/Throwable.html)
- When an exception is caught, the code inside the first catch block who's Throwable parameter is the same type as the exception, or is a subclass of the exception's type, is used to handle the exception.
- In this example, the second catch is of a made-up type, GeneralExceptionType. which is a very general type (high in the exception hierarchy) so it will catch many exception types including SpecificExceptionType. If this block were before the block for SpecificExceptionType, it would never be called.
- Ultimately, Throwable is the most general exception type
- If an exception is thrown in the try that doesn't match any of the catch blocks, the finally block will execute then the exception keeps bubbling up as though the try blocks weren't there.
- The finally block is executed after the try/catch even if no errors occurred.
- The finally block will execute in ]almost all situations](https://stackoverflow.com/questions/7143788/try-catch-finally-in-java)
- After the try-catch-finally is done executing, assuming all errors were caught, execution returns to the statement after the try-catch-finally block.
- Code in catch blocks often:
- prints the error message.
- terminates the program safely
- sometimes do nothing.
- throw a different exception (maybe a custom exception)
- The also book mentions some advanced Java SE 7 features:
-[try with resource](https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html) is a way to automatically close resources after using them.
- You can handle [multiple exception types with the same block](https://docs.oracle.com/javase/7/docs/technotes/guides/language/catch-multiple.html) with the syntax: `catch(FirstExceptionType | SecondExceptionType e)` where the catch block will catch exceptions of type `FirstExceptionType` or `SecondExceptionType` as the variable e, then handle them the same way.
### 2.4.2 Throwing Exceptions
- To generating the exceptions caught in try/catch statements, use the __throw__ keyword followed by an instance of an exception to be thrown. The syntax for this is:
__throw__ __new__ *exceptionType*(*parameters*);
- most exception types offer a constructor that takes an error message String as a parameter which can give more detail when the error is thrown.
#### The Throws Clause
- When methods have a __throws__ clause in their signature that specifies a comma sepparated list of exceptions this method could throw. Methods that call the original method must either:
- catch the error
- have throws in their signature
- Note, having a throws clause doesn't excuse you from having an `@throws` javaDoc tag.
```java
//******syntax********
/**
parses a string to an int
@throws NumberFormatException when s can't be parsed
- As we'll see later, a throws clause is necessary for checked exceptions.
### 2.4.4 Java's Exception Hierarchy
- All java exceptions inherit from Throwable.
- __Error__ and __Exception__ directly inherit from throwable.
- __Error__ is used for serious errors encountered by the JVM that aren't recoverable, like a corrupt .class file or the computer runs out of memory.
- __exceptions__ may be recoverable.
#### Checked and Unchecked Exceptions
- In java, *runtime exceptions* are __unchecked exceptions__ which occur at runtime and are due to mistakes in programming logic (like an out of bounds index)
- These are called unchecked because by the time you get to production, they should no longer exist.
- everything that's not a runtime exception is a __checked exception__. These checked exceptions (like IOException or FileNotFoundException) can't be detected until the program is running so they must be *checked*.
- Methods that could throw a checked exception must have a [throws clause](#The-Throws-Clause) for that exception to compile.
#### Defining New Exception Types
- You can subclass exceptions just like any other class. When you do, be careful about what class you inherit from because it will affect how you [catch the exception](#2.4.1-Catching-Exceptions), and if you inherit an unchecked exception, the rules for unchecked exceptions apply.
## 2.5 Casting and Generics
- This section covers:
-*casting* between reference variables
- defining methods that work with different data types without explicit casting using *generics*
### 2.5.1 Casting
#### Widening Conversions
- Widening conversions allow variables in java to be polymorphic.
- Widening conversions obey the [Liskov substitution principal](#2.2.2-Polymorphism-and-Dynamic-Dispatch).
- widening conversions can be done implicitly and reliably by the compiler.
- common uses of widening conversions:
- Converting an object instance to its superclass type
- converting an object instance to one of its interface types.
- converting an object instance to of a superinterface of one of its interface types.
#### Narrowing Conversions
- Narrowing conversions require an explicit cast by the programmer and is unreliable (can't be verified by the compiler).
StringnarrowerObj=(String)tempStr;//can be re-narrowed explicitly
```
#### Casting Exceptions
- Invalid narrowing casts will throw a `ClassCastException`.
- To prevent the `ClassCastException`, use the `instanceof` test
- instance of syntax: *objectReference* __instanceof__ *referenceType*
-*objectReference* is an expression that evaluates to an object reference (like a variable)
-*referenceType* is the name of a class, interface, or enum.
-`instanceof` returns true if *objectReference* is an instance of *referenceType*, else it returns false.
#### Casting with Interfaces
- Methods in an interface often have general types, then in the interface implementation when you pass an argument to them, they check if that variable with `instanceof` before doing any processing. This makes the interface more reusable.
- Although Object is a class, `Object.equals(Object)` is a good example of a method that takes a general object and can be overridden with a method that performs `instanceof`
### 2.5.2 Generics
- Java supports __generic__ (as of Java SE 5) classes and methods that take a set of __formal type parameters__ upon object initialization and use them in class as variable, parameter, and return types in the object.
- The __composition design pattern__ deals the instance variables of a class.
- Before generics, java programmers relied heavily on the Object superclass to make their code reusable. Unfortunately, this also makes code less robust as it introduces a need for narrowing casts back from the Object type.
#### Using Java's Generics Framework
- formal type parameters are capital letters by convention.
- When declaring a variable that uses generics in its parameterized type, we must explicitly specify __actual type parameters__ that will take the place of the generic formal parameters.
- Note, generics only works with Object types, not base types. However, this is rarely a problem because boxing and unboxing.
- __type inference__: an object's actual type parameters can be inferred from the actual type parameters of the variable they're being assigned to using empty angle brackets known as the "diamond" `<>`.
- These type parameters can also be explicitly stated inside the anble brackets.
- However, if you don't have any angle brackets, all the type parameters are set to Object.
```java
//example
publicclassSimpleVar<A>{
Avar;
publicSimpleVar(AstoredVar){
this.var=storedVar;
}
publicAgetVar(){
returnthis.var;
}
}
SimpleVar<String>myVarStore=new<>SimpleVar("hello");//diamond style (using type inference)
System.out.println(exMyVarStore.getVar());//prints: ex hello
System.out.println(badMyVarStore.getVar());//prints: the object code of the string?
```
#### Generics and Arrays
- Java allows the declaration, but technically not instantiation of arrays using parameterized types.
- 2 examples where this issue occurs (see below for solutions):
1. Storing an array of objects that have generic parameterized types. (obviously outside the class)
2. Initializing an array that holds instances of one of the type parameter's types inside a class with generic type parameters.
##### ex1: outside the class
- In this case, the array can be instantiated with an *unparameterized* type, then cast back to the parameterized type.
```java
SimpleVar<String>[]paragraph;
paragraph=newSimpleVar<String>[10];// compiler error. Can't initialize arrays using parameterized types.
paragraph=newSimpleVar[25];//This is legal because you're not initializing with a parameterized type.
// This will give a compiler warning about an unchecked narrowing cast because the array is cast from <Object> to <String>
paragraph[0]=newSimpleVar<>("hello");//valid assignment after cast
```
##### ex2: inside the class
- In this case, instantiate to `Object`, then cast to the type of the corresponding parameter.
```java
//example
publicclassSimpleVarArr<A>{
A[]varArr;
publicSimpleVarArr(intcapacity){
this.var=newA[capacity];// compiler error. Can't initialize arrays using parameterized types.
this.var=(A[])newObject[capacity];//legal, but compiler warning about unchecked narrowing cast.
}
publicvoidaddVar(Avalue,intindex){
varArr[index]=value;
}
publicAgetVar(intindex){
returnthis.var[index];
}
}
```
#### Generic Methods
- Methods can use generic types. When they do, these types are inferred from their parameter list.
- Methods that take generic type parameters, like classes that take generic types, can use those types as a type (variable type etc.) in the method itself.
- more on these methods [here](https://docs.oracle.com/javase/tutorial/extra/generics/methods.html)
```java
importjavax.swing.JOptionPane;
publicclassMain{
publicstaticvoidmain(String[]args){
printOnScrn("hi");//shows type inference
}
publicstatic<T>voidprintOnScrn(Tvar){
TcopyRef=var;//shows you can use the type T in the method
JOptionPane.showMessageDialog(null,var);
}
}
```
#### Bounded Generic Types
- Use the __extends__ keyword to restrict formal parameter type possibilities to only types that extend (or implement) the specified class (or interface).
- Limiting formal parameters to subclasses (or subinterfaces) ensures the formal prameters have certain methods.
```java
importjavax.swing.JOptionPane;
importjava.util.Arrays;
publicclassMain{
publicstaticvoidmain(String[]args){
printOnScrn("hi");
String[]strArr={"hi","mom","you're","great"};
printLoop(Arrays.asList(strArr));//passing a list, which is an iterable.
