面对对象下

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("再也没有已知数");

    }

  }

}