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