Java 异常处理、继承、重写/重载

一、java异常处理：

三种类型的异常：检查性异常、运行时异常、错误。

所有的异常类是从java.lang.Exception类继承的子类。Exception类是Throwable类的子类。除了Exception类外，Throwable还有一个子类Error。

异常类有两个主要的子类：IOException 类和 RuntimeException 类。

Java非检查性异常：

Java检查性异常：

Throwable 类 异常方法：

捕获异常：使用try和catch关键字可以捕获异常。try/catch的语法：

try{

    // 程序代码

}catch(ExceptionName e1){

    //Catch 块

}

    catch不能独立于try存在；在try/catch后面添加finally块并非强制要求；try代码后不能及没有catch块也没有finally块；try、catch、finally块之间不能添加任何代码。

在Java中，throw和throws关键字用于处理异常。throw关键字用于在代码中抛出异常，而throws关键字用于在方法声明中指定可能会抛出的异常类型。

public void checkNumber(int num) {
  if (num < 0) {
     throw new IllegalArgumentException("Number must be positive");
   }
}

finally关键字用来创建在try代码块后面执行的代码块。无论是否发生异常，finally代码块中的代码都会被执行。

Java新增try-with-resource语法来打开资源，并且可以在语句执行完毕后确保每个资源被自定关闭。try-with-resource是一种异常处理机制，可以简化资源管理代码的编写。try-with-resource语句可以声明多个资源，方法是使用分号“；”分隔各个资源。

二、Java 继承：

继承是Java面向对象编程技术的一块基石，继承允许创建分等级层次的类。

继承是子类继承父类的特征和行为，使得子类对象具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的。类的继承格式：

class 父类 {

 }

class 子类 extends 父类 {

}

继承类型：Java不支持多继承，但支持多重继承。

继承的特性：

◆ 子类拥有父类非 private 的属性、方法。

◆ 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

◆ 子类可以用自己的方式实现父类的方法。

◆  Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继 承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类， 所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

◆ 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联 系越紧密，代码独立性越差）。

继承的关键字：继承可以使用extends和implements两个关键字实现继承。

1、extends关键字：

  extends 只能继承一个类。

public class Animal {

private String name;

private int id;

public Animal(String myName, int myid) {

//初始化属性值

}

public void eat() {

//吃东西方法的具体实现

}

 public void sleep() {

//睡觉方法的具体实现

}

}

public class Penguin extends Animal{

}

2、implements关键字：

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {

public void eat();

public void sleep();

}

 public interface B {

public void show();

 }

public class C implements A,B {

}

3、super和this关键字：

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。this关键字：指向自己的引用。

class Animal {

void eat() {

System.out.println("animal : eat");

}

}

class Dog extends Animal {

void eat() {

System.out.println("dog : eat");

 }

void eatTest() {

this.eat(); // this 调用自己的方法

super.eat(); // super 调用父类方法

}

}

public class Test {

public static void main(String[] args) {

Animal a = new Animal();

1. eat();

Dog d = new Dog();

d.eatTest();

}

}

4、final关键字：

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。final 含义为 "最终的"。使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写。

三、Java Override/Overload：

重写是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。重写的好处在于子类可以根据需要，定义特定于自己的行为。重写方法不能抛出新的检查异常或者比被重写方法申明更加款发的异常。示例：

class Animal{

public void move(){

 System.out.println("动物可以移动");

}

}

class Dog extends Animal{

public void move(){

System.out.println("狗可以跑和走");

}

public void bark(){

System.out.println("狗可以吠叫");

}

}

public class TestDog{

public static void main(String args[]){

Animal a = new Animal();

Animal b = new Dog();  

a.move();

b.move();

b.bark();

}

 }

方法的重写的规则：

◆ 参数列表与被重写方法的参数列表必须完全相同。

◆ 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值 的派生类。

◆ 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类 的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。

◆ 父类的成员方法只能被它的子类重写。

◆ 声明为 final 的方法不能被重写。

◆ 声明为 static 的方法不能被重写，但是能够被再次声明。

◆ 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明 为 private 和 final 的方法。

◆ 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public  和 protected 的非 final 方法。

◆ 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。 但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的 更广泛的强制性异常，反之则可以。

◆ 构造方法不能被重写。

◆ 如果不能继承一个类，则不能重写该类的方法。

重载是在一个类里面，方法名字相同，但参数不同，返回值可以相同也可以不同。每个重载的方法都必须有一个独一无二的参数类型列表。重载的规则：

◆ 被重载的方法必须改变参数列表(参数个数或类型不一样)；

◆ 被重载的方法可以改变返回类型；

◆ 被重载的方法可以改变访问修饰符；

◆ 被重载的方法可以声明新的或更广的检查异常；

◆ 方法能够在同一个类中或者在一个子类中被重载。

◆ 无法以返回值类型作为重载函数的区分标准。

重载和重写的区别：