Java继承——抽象类与接口的比较以及内部类、匿名类、异常类......

壹、抽象类与接口的比较

1、抽象类与接口都可以有抽象方法；
2、接口中只可以有常量，不可以有变量；而抽象类中既可以有常量也可以有变量；
3、抽象类中可以有非抽象方法，而接口不可以（因为接口中的方法默认为abstract）；

在这两者中，通常什么时候使用抽象类，什么时候使用接口呢？

这两者本质上~~都是让设计忽略细节，将重心放在整个系统的设计上面 。
抽象类除了提供抽象方法外，还为子类提供非抽象方法和变量。如果某个问题需要利用继承才能更好的解决，如子类除了需要父类的抽象类，还需要从父类中继承一些变量或者非抽象方法，则选择抽象类。
反之，如果某个问题不需要继承，只需要利用一些方法来实现的话，就选择接口。

贰、内部类

我们知道一个类中由两部分构成——成员变量与方法，本章节所学的内部类，也可以作为其中的成员。
1、定义：所谓内部类，简单点来说，就是在一个类中，再构造一个类。此时最外面的类我们称为外部类（或外嵌类），那么在外部类中的，我们称为内部类（或内嵌类）。
2、格式：

class Outer
{
class Inter
{}
}
1
2
3
4
5

3、规则：
（1）内部类与外部类可以方便的访问彼此的私有域（包括私有方法、私有属性）。
（2）内部类是另外一种封装，对外部的其他类隐藏。（这里我们后面会讲到其他外部类如何访问内部类方法）
（3）内部类打破了java的单继承局限，可以实现多继承；
注意：内部类也有缺点，设计起来比较繁琐，不便于大项目的对接工作。

4、代码展示

class A
{
    public void tell1()
    {
        System.out.println("I am A.");
    }
}
class B
{
    public void tell2()
    {
        System.out.println("I am B");
    }
}

class Outer{
    private String str ="外部类中的字符串";
    //定义一个内部类
    class Inner1 extends A{
        private String inStr= "内部类中的字符串";
        public void print(){
            //调用外部类的str变量
            System.out.println(str);
        }
    }
    //定义另一个内部类
    class Inner2 extends B{
        public void print1()
        {
            //调用外部类的str变量
            System.out.println(str);
        }
    }

    //在外部类中定义一个方法，该方法负责产生内部类对象并调用print()方法
    public void fun(){
        //内部类对象
        Inner1 inner1 = new Inner1();
        Inner2 inner2 =new Inner2();
        //内部类1对象提供的print
        inner1.print();
        inner1.tell1();
        //内部类1对象提供的print
        inner2.print1();
        inner2.tell2();
    }
}
public class Test{
    public static void main(String[] args)
    {
        //创建外部类对象
        Outer out = new Outer();
        //外部类方法
        out.fun();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

结果展示

外部类中的字符串
I am A.
外部类中的字符串
I am B
进程已结束,退出代码0

1
2
3
4
5
6

叁、匿名类（匿名内部类）

1、定义：匿名内部类也就是没有名字的内部类正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写，但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口，但最多只能继承一个父类，或实现一个接口。
2、几点说明：
（1）匿名类不能时abstract类，因为系统在创建内部类的时候，会立即创建出一个相关内部类对象。
（2）匿名内部类不等定义构造器（构造方法），因为匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以定义实例初始化块。
3、格式

abstract class Father{...}

public class Test{
 Father H1=new Sonone(){
 匿名类类体
}
1
2
3
4
5
6

4、（1）和子类有关的匿名类
这个格式很多人应该时有点懵的，new出一个“Father”，后面跟的不是分号，竟然是大括号。
让我来为大家解释一下，一个抽象类是不能直接new 的，必须先有实现类了,才能new出它的实现类这里的“Father”是类名，而这里的实现类即为匿名类。看下面一段代码：

class SonOne extends Father{
  ...       //这里的代码和上面匿名内部类，大括号中的代码是一样的
}
public class Test{
   Father f1 = new SonOne() ;
} 
1
2
3
4
5
6

简单点来说，匿名类就是作为子类继承了某一个父类。
（2）和子类有关的匿名类
只需要把接口换成子类即可。

肆、异常类（Exception）

1、所谓异常，就是当你允许代码时候，中间由于某些原因，导致无法正常运行。

Exception in thread “main” java.lang.NoClassDefFoundError: org/a......
1

异常对象可以调用以下几种方法来获取异常信息：

public String getMessage();
public void printStackTrace();
public String toString();
1
2
3

2、处理异常的几种机制
（1）try-catch语句：Java内处理异常，通常会把会发生异常的语句放在try后面；

try{
	包含可能发生异常的语句
}
catch(ExceptionSubClass1 e){
	...
}
catch(ExceptionSubClass2 e){
	...
}

1
2
3
4
5
6
7
8
9
10

看下面的例子

public class Example3_1 {
    public static void main(String[] args) {
        int n = 0, m = 0, t = 1000;

        try {
            m = Integer.parseInt("8888");
            n = Integer.parseInt("ab89"); //发生异常,转向catch
            t = 7777;  //t没有机会被赋值
        } catch (NumberFormatException e) {
            System.out.println("发生异常:" + e.getMessage());
        }
        System.out.println("n=" + n + ",m=" + m + ",t=" + t);

        try {
            System.out.println("故意抛出I/O异常！");
            throw new java.io.IOException("我是故意的");
            //System.out.println("这个输出语句肯定没有机会执行,所以必须注释掉，否则编译出错");
        } catch (java.io.IOException e) {
            System.out.println("发生异常:" + e.getMessage());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（2）try-catch-finally

try{ }
catch(ExceptionSubClass e){ }
finally{}

1
2
3
4

其执行机制是在执行try~catch语句后，执行finally 子语句，也就是说，无论在try部分是否发生过异常，finally 子语句都会被执行.