Exceptions in Java:
Object
Throwable
Error Exception
RuntimeException …..
There are two types Exception:
1. Checked Exception , we need to declare ‘throws’ in mehtod if there maybe exception be thrown out, and must be catch or throw it if we use the method.
2. UnChecked exception(RuntimeExcepiton), will be thorwed in runtime, no need to declare them in the method.
1. UnChecked Exception:
public class TestException {
public void test() throws NullPointerException{
System.out.println("Test OK");
}
public static void main(String[] args) {
new TestException().test();
}
}
output: “Test OK”
2. Checked Exception:
public class TestException {
public void test() throws IOException{
System.out.println("Test OK");
}
public static void main(String[] args) {
new TestException().test(); // Can not compile: surround with try/catch or add throws declaration
}
}
3. Overriding:
Access modifier can be enlarged, but exception only can be less or specialized.
package scjp.liguoliang.com;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestException {
public void test() throws IOException{
System.out.println();
}
}
class TestExceptionSub extends TestException {
public void test() throws FileNotFoundException{ // FileNotFoundException extends IOException
}
}
This can work fine, but if we let TestExceptionSub to implement an Interface, like:
package scjp.liguoliang.com;
import java.sql.SQLException;
public interface ITestException {
void test() throws SQLException;
}
package scjp.liguoliang.com;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestException {
public void test() throws IOException{
System.out.println();
}
}
class TestExceptionSub extends TestException implements ITestException{
public void test() throws FileNotFoundException{ //Can not compile!
}
}
Multiple markers at this line
– overrides scjp.liguoliang.com.TestException.test
– Exception FileNotFoundException is not compatible with throws clause in
ITestException.test()
for test() in TestExceptionSub , If we want to throw any checked exception, we need get the sub class from ‘IOException’ and ‘SQLException’., or just remove throws declaration.
but for un-checked exception, you can throw any, and no matter with the super class declaration.
4. Catch sequence: the specification exception need catched before it’s super exception, otherwise:
“Unreachable catch block for Exception. It is already handled by the catch block for Throwable”
public static void main(String[] args) {
try{
throw new SQLException();
}catch (SQLException e) {
System.out.println("SQLException catched!");
return;
}catch (Throwable e) {
System.out.println("Exception Catched!");
return;
}
finally {
System.out.println("Finally");
}
}
Overloading method will be determined by reference type, but override method will be determined by the actual object tyep.
property is determined by reference type too.
package newjob.guoliang.corejava;
public class ReferenceTypeTest {
public static void main(String[] args) {
AClass a = new BClass();
new ReferenceTypeTest().printClassDesc(a);
}
protected void printClassDesc(AClass a) {
System.out.println("A_" + a.desc);
}
protected void printClassDesc(BClass b) {
System.out.println("B_" + b.desc);
}
}
class AClass {
String desc = "ClassA";
}
class BClass extends AClass{
String desc = "ClassB";
}
Output is:
A_ClassA
MethodClassB_ClassB
Static block / variable;
Instance block / variable;
Constructor;
public class StaticTest {
public static void main(String[] args) {
// System.out.println(B.a);
// System.out.println(C.c);
StaticTest staticTest = new StaticTest();
staticTest.printName();
}
static {
System.out.println("Static_block_Main");
}
public StaticTest() {
System.out.println("Consturctor_Main");
}
private void printName() {
System.out.println("InstanceMethod");
}
{
System.out.println("Instance_block_Main");
}
}
Output is:
Static_block_Main
Instance_block_Main
Consturctor_Main
InstanceMethod
package scjp.liguoliang.com;
/**
* I'm try to see the static block run rules,
* B extends A, A has a static a, when we use B.a, class B did not loaed, just Class A loaded.
* If B also has a static a, A and B will be loaded.
* If a is finle, A and B will not be loaded both.
* @author Li Guoliang
*
*/
public class TestClassLoading {
public static void main(String[] args) {
System.out.println(B.a);
System.out.println(C.c);
}
}
class A {
static String a = "A.a"; // how about if this is final
static {
System.out.println("Static_A_Class");
}
{
System.out.println("Instance_A");
}
}
class B extends A{
// static String a = "B.a";
static {
System.out.println("Static_B_Class");
}
}
/**
* This class is designed for test the squence of static variable and block.
* They run by the sequence of the code.
* @author Li Guoliang
*
*/
class C {
static {
System.out.println("Static_C");
}
static C c = new C();
public C() {
System.out.println("Constructor_C");
}
}
Output
Static_A_Class
A.a
Static_C
Constructor_C
scjp.liguoliang.com.C@161f10f
Here are two class: Animal and Dog, Dog extends from Animal:
package scjp.liguoliang.com;
public class Animal {
private String type = "Dog";
public String name = "Animal";
public String getType() {
return type;
}
public void eat() {
System.out.println(name + ", Animal eat...");
}
}
package scjp.liguoliang.com;
public class Dog extends Animal {
private String type = "Dog";
public String name = "Dog";
public String getType() {
return type;
}
public void eat() {
System.out.println(name + ", Dog eat...");
}
}
And here is the test codes:
public static void main(String[] args) {
Dog dog = new Dog();
Animal animalDog = new Dog(); // New dog, but type is Animal.
System.out.println(dog.name);
System.out.println(dog.getType());
dog.eat();
System.out.println(animalDog.name);
System.out.println(animalDog.getType());
animalDog.eat();
System.out.println("\nWe are going to test overloading:");
OverLoadingTest overLoadingTest = new OverLoadingTest();
overLoadingTest.testEat(animalDog);
overLoadingTest.testEat(dog);
}
public void testEat(Animal animal) {
System.out.println("Test Animal eat");
}
public void testEat(Dog dog) {
System.out.println("Test Dog eat");
}
Here is the output:
Dog
Dog
Dog, Dog eat...
Animal // Get the property by reference Type, so print the name of ‘Animal’
Dog // Polymorphism, call the method of the instance in run time;
Dog, Dog eat...
We are going to test overloading:
Test Animal eat // Compiler will decide which method will be called by reference type when compiling.
Test Dog eat
In summary:
1. overriding: Polymorphism is for instance method, so an animal type reference to a dog Object will call dog’s method; but for properties, will use animals.
2. overloading: which method will be called has been determined when compiling by the reference type.
// Proudly powered by Apache, PHP, MySQL, WordPress, Bootstrap, etc,.