Java07-异常、抽象类和接口以及总结

1 异常

用来封装错误信息的对象

1.1 异常的继承结构

Throwable - 顶级父类
– Error：系统错误，无法修复
– Exception：可修复的异常

具体见下图:

1.2 异常处理

程序中遇到了异常，通常有两种处理方式：捕获或者向上抛出

捕获异常

try{
    需要捕获的代码
}catch(异常类型  异常名){
    处理方案
}

抛出异常

在会发生异常的方法上添加代码：throws 异常类型

 public static void main(String[] args)  throws Exception{}

2 抽象类

2.1 概念

Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。抽象类可以理解为是一个只有方法声明没有方法体的特殊类

修饰符 abstract 返回值 方法名(参数列表);
abstract class C{
              public abstract void eat();
}

2.2 特点

1、 通过java关键字abstract实现
2、 可以修饰方法或者类
3、 抽象类中可以没有抽象方法（由子类去实现）
4、 如果类中有抽象方法，那该类必须定义为一个抽象类
5、 子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
6、 多用于多态中
7、 抽象类不可以被实例化

2.3 抽象类的用法

2.3.1 构造函数

抽象类也有构造方法，但是不能本身实例化。
那抽象类的构造函数有啥用？一般用于给子类实例化。

abstract class Animal{
    //抽象类可以有构造方法，但是无法实例化
    //用于子类实例化
    public Animal(){
           System.out.println("父类构造方法");
    }
}

class Zi extends Animal{
}

public class TestAnimal{
    public static void main(String[] args) {
//        Animal2 a2 = new Animal2();//抽象类无法实例化   
//        Zi2 z=new Zi2();//创建子类实例化对象
           Animal a = new Zi();//抽象类多用于多态    
    }
}

打印结果:父类构造方法

2.3.2 抽象类的成员变量

既可以有变量，也可以有常量

abstract class Animal3{
       private String name;  //3
       public final int age = 10;
}

2.3.3 抽象类的成员方法

抽象类里，既可以有普通方法，有可以有抽象方法

abstract class Animal4{
       //抽象类中的普通方法
       public void speek(){
              System.out.println("fu...speak()");
       }
       //抽象类里的抽象方法
       public abstract void study();
}

3 接口

2.1 概念

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法

2.2 特点

1、 接口中都是抽象方法
2、 通过interface关键字创建接口
3、 通过implements让子类来实现
4、 可以理解成，接口是一个特殊的抽象类
5、 接口突破了java的单继承的局限性
6、 接口和类之间可以多实现，接口和接口之间可以多继承
7、 接口是对外暴露的规则，是一套开发规范
8、 接口提高了程序的功能扩展，降低了耦合性

2.3 接口的用法

2.3.1 构造方法

接口里是没有构造方法的。
在创建实现类的对象时默认的super()，是调用的默认Object的无参构造

2.3.2 成员变量(常量)

接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：
public static final

public interface Kaaa {
		int a=10;
}

class Z implements Kaaa{
	
}

class Test{
	public static void main(String[] args) {
		Z z = new Z();
		System.out.println(z.a);
	}
}

2.3.3 接口的成员方法

接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会默认自动补齐

public abstract void save();

interface Inter2{    
    //public abstract void update() ; // 简写，接口会为方法自动拼接 public abstract
    void update() ; // 简写，接口会为方法自动拼接 public abstract
    void get() ;
}

2.3.4 接口的复杂用法(继承&实现)

Java中单继承的局限性通过接口可以解决。
接口可以多继承也可以多实现，甚至可以继承的同时多实现

1. 接口之间可以多继承，多个接口之间逗号隔开

interface Interface3 extends Interface1,Interface2{
    void add();
}

2. 接口可以多实现，只不过接口之间逗号隔开

class ManyImpl implements  Interface1,Interface2{
    public void save() {}
    public void update() {}
    public void get() {}
    public void delete() {}
}

3. 接口可以继承的同时，多实现

class MoreImple extends ManyImpl  implements Interface1,Interface2  {

}

4. 实现类要重写接口所有的父接口的所有方法

4 关系总结

4.1 类和类的关系

继承 extends / 单继承 / 单根继承
– 继承的意义：为了提高代码的复用性，减少了代码的编写提高开发效率。
– 方法重写的意义：在不修改父类源码的前提下，在子类中重写业务，从此使用的就是重写后的功能。
– 要求子类的方法声明和父类一样，只要改方法体。
– 有了继承有了重写就产生了多态，多态的意义：为了统一程序的调用标准，标准就是父类。
– 多态 也就是向上转型/向上造型。
– 向下造型的意义：很少用，相当于想要使用子类的特殊功能，还不如直接创建子类对象简单。
– class A extends B
– 其中，A和B都是类，A是子类，B是父类，A就拥有了B的所有功能(除了私有的和构造方法)
– 其他知识点：this 和super ，构造方法，各种代码块…

4.2 类和接口关系

实现 implements / 单实现 / 多实现
– class A implements B,C
– 其中，A是实现类,B和C是接口
– 要求A 可以把 B 和C 接口里的所有 抽象方法 都重写掉，否则 A 就是抽象类
– 接口不能创建对象
– 接口里没有构造方法，接口里都是常量，接口里都是抽象方法

4.3 接口和接口关系

继承 extends / 单继承 / 多继承
– 接口的多继承的关系，打破了java单继承的局限性
– interface A extends B,C
– 其中，A B C 都是接口，A是子接口，同时拥有B和C接口里的所有功能
– class AImpl implements A
– 要求AImpl需要重写A接口里的所有方法(是包含B和C接口的所有方法)，否则就是抽象类

4.4 接口和抽象类的区别

1、抽象类和接口都不能实例化
2、抽象类要被子类继承，接口要被类实现。
3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量public static final类型的 ，抽象类中的变量可以是各种类型的
5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类
6、 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法
7、抽象类里可以没有抽象方法，接口都是抽象方法
8、如果一个类里有抽象方法，那么这个类只能是抽象类
9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
10、接口可继承接口，并可多继承接口，但类只能单根继承。