1 类的继承：
(1)Java只支持单继承，不允许多重继承。
(2)可以有多层继承，即一个类可以继承某一个类的子类，如类B继承了类A，类C又可以继承类B，那么类C也间接继承了类A。
(3)子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法。在子类的构造方法中可使用语句super(参数列表) 调用父类的构造方法。
(4)如果子类的构造方法中没有显式地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则在产生子类的实例对象时，系统默认调用父类无参数的构造方法。
extends关键字用于继承类。
声明一个继承父类的类的通常形式如下：
class subclass-name extends superclass-name {
//类体
}
(1)没有extends，默认父类为Object
(2)一个类只能有一个父类，即单继承
(3)子类继承父类的全部成员
如：class Employee {
String name;
Employee(String n){
name = n;
}
public void setName(String name) {this.name=name }
public String getName(){ return name;}
class Worker extends Employee {
Worker(String s){
This.name=s;
}
}
class Text{
public static void main(String args[]) {
Worker w = new Worker("M.John",'M','B',true);
System.out.println("姓名 ： "+w.getName());
2 final 关键字
final 修饰符可应用于类、方法和变量。
final在应用于类、方法和变量时意义是不同的，但本质是一样的：final表示不可改变。
声明为final的类不能被继承。
如：final class TestFinal {
int i = 7;
int j = 1;
void f() {}
}
class Further extends TestFinal {} //是错误的，final不能被继承
在方法声明中使用 final 关键字向编译器表明子类不能覆盖(override)此方法。在声明类中，一个 final 方法只被实现一次。如果一个类为 final 类，那么它的所有方法都为隐式的 final 方法。如：class TestFinal {
final void f() {}
}
class Further extends TestFinal {
final void f(){}方法不能被覆盖//
}
抽象类
(1) 定义：一种类型，只提供部分方法的具体实现。
(2)语法：abstract class 类名{….}
(3)一般情况下，抽象类既包含具体方法，又包含抽 象方法。
(4)具体方法：既有方法的声明，又有方法的实现（即有方法体)。
(5)抽象方法：只有方法的声明，而没有方法的实现（即没有方法体)。语法：
abstract 返回类型 方法名(参数列表)
(6)抽象类不能被实例化。
(7)子类必须为抽象类中的所有抽象方法提供具体实现，否则，子类也将是一个抽象类
如：abstract class Employee {
int basic = 2000;
abstract void salary();//抽象方法
}
class Manager extends Employee{
void salary() {
System.out.println("薪资等于 "+basic*5);
}
}
class Worker extends Employee{
void salary() {
System.out.println("薪资等于 "+basic*2);
}
}
接口
如果一个抽象类中的所有方法都是抽象的，我们就可以将这个类用另外一种方式来定义，也就是接口定义。接口是抽象方法和常量值的定义的集合，从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
(1)接口中的成员都是public访问类型的。接口里的变量默认是用public static final标识的 。
(2)我们可以定义一个新的接口用extends关键字去继承一个已有的接口
(3)我们也可以定义一个类用implements关键字去实现一个接口中的所有方法，我们还可以去定义一个抽象类用implements关键字去实现一个接口中定义的部分方法。
(4)一个类可以继承一个父类的同时，实现一个或多个接口，extends关键字必须位于implemnets关键字之前 。
语法：public interface 接口名{…}
例如：interface A { //定义一个接口A
double g=9.8;
void show( );
}
class B implements A { //B继承了接口A
public void show( ) {
System.out.println(“g=“+g);
}
}
class InterfaceTest { //测试函数
public static void main(String args[ ]){
B b=new B( );
b.show( );
}
}
多态性
(1)应用程序不必为每一个派生类（子类）编写功能调用，只需要对抽象基类进行处理即可。这一招叫“以不变应万变”，可以大大提高程序的可复用性。
(2)派生类的功能可以被基类的引用变量引用，这叫向后兼容，可以提高程序的可扩充性和可维护性。以前写的程序可以被后来程序调用不足为奇，现在写的程序（如callA方法）能调用以后写的程序（以后编写的一个类A的子类， 如类D）就了不起了。
6 异常
定义：是指尽管已经正确编程，但在运行过程中因种种原因而发生的意外错误，所有异常类都是Exception类的子类。
解决办法
try{
// 可能产生异常的程序部分
}catch(Exception类1 e){
// Exception类1处理异常部分
}catch(Exception类2 e){
// Exception2处理异常部分
}finally｛
//无论异常是否发生，都要处理的部分
}
异常的例子：public class Test {
public static void main(String[] args) {
int i=0 ;
try {
while(true) {
System.out.println(i +": "+ args[i]);
i++;
}
} catch ( Exception e ){
System.out.println("再也没有已知数");
}
}
}
