Java继承、多态和接口

浏览数：102 / 时间：2015年06月08日

继承

含义：可以通过扩展一个已有的类，并继承该类的属性和行为，来创建一个新的类

优点：

1）代码的重用性

2）子类扩展父类的属性和方法

3）父类的属性和方法可用于子类

4）设计应用程序变得更加简单

继承的实现：

　　关键字extends：用于继承其他类（extends出现在类声明类名后，extends后接要继承的类名）

访问修饰符 class 子类名 extends 父类名(){};

1 public class Employee (){}  //  父类
2 public class Salary extends Employee (){} // 子类

单继承与多继承、Object类：

在Java中一个类只能有一个父类，多继承在Java中是不被允许的，但并不意味一个类没有祖父等往上的类。Object类是所有类的祖类，任何类都可以可以继承Object类(不是直接父类就是间接父类)

1 public class Employee (){}  //  父类
2 public class Salary extends Employee (){} // 子类
3 public class  Emp   extends Salary (){} // 子类

方法重写（子类对父类方法的重写）：子类可以重写父类继承的方法，从而允许子类添加或者改变父类中方法的行为

　　　　>子类的方法返回值的类型、方法名、和形式参数列表必须和父类一致

　　　　 >子类访问修饰符不能比父类严格

　　　　 >子类抛出的异常不能多于父类

super关键字：调用父类中重写的方法

　　调用父类构造器：

　　　　>调父类构造器是第一句可执行语句

　　　　>默认情况下子类会调用父类的无参构造

　　　　>做子类构造器初始化要先做父类构造器初始化

　　格式： super.方法名（）

final关键字

　　1)修饰类：不能被继承

　　 2）修饰方法：最终方法不能被重写

　　 3）修饰变量：变量值不能被修改

类的高级概念

静态成员：

　　关键字static 允许成员变量和方法不于类的特定实例关联，通过关键字static 声明的成员变量和方法可以被认为是全局的，任何其他类可以直接访问静态成员和调用静态方法，而不需要该类的一个实例

实例初始化块

在类的对象每次实例化时执行一次，在构造器之前执行

　　执行顺序：1）子类中相应的构造器被调用

　　　　　　　2）执行对super的调用，控制流程跳转回子类构造器

　　　　　　　3）父类构造器执行完，控制流程跳转回子类构造器

　　　　　　　4）在该子类构造器中的super（）后面的任何语句执行前，实例化初始化块执行

　　　　　　　5）执行子类构造器中super（）后面的语句

内部类：

　　静态内部类：

class Outer{
    static class Inner{
    }

 }

成员内部类：

class Outer{
    class Inner{
    }
}

局部内部类：

void f(){
    class Inner{
        void g(){
        }
    }
}

匿名内部类：
　　

 1 public class Outter {
 2     
 3     public void print(Inter inter){
 4         inter.printfInterface();
 5     }
 6 }
 7 
 8 interface Inter{
 9     void printfInterface();
10 }
11 public class Test {
12 
13         outter.print(new Inter(){
14             @Override
15             public void printfInterface() {
16                 System.out.println("匿名内部类打印");
17             }
18         });
19     }
20 }

多态和抽象

多态：不同情形下的多种状态

　　分类：

　　　　>静态多态（方法重载）

　　　　>动态多态（在运行中系统才能确定方法所指对象）

　　步骤：1）编写父类派生子类

　　　　　2）子类当中重写父类方法

　　　　　3）使用多态（用父类数据类型引用子类对象）

　　　　　4）调用子类重写方法实现

　　instanceof关键字：用于判断运行时对象的真正类型

抽象

　　abstract关键字：　放于class之前（抽象类），不能实例化父类对象，需要被继承后才能实现

　　抽象方法：只有方法签名，没有方法主体,类也必须声明为抽象类,任何子类必须重写抽象方法，除非子类本身也是抽象

public abstract class Pet {
    private String name;        //名字
    
    public Pet() {}

    public Pet(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Pet [name=" + name + "]";
    }
    public abstract show();
}

接口:不能被实例化,不包含任何构造器,所有方法都是抽象的,不能包含实例成员变量,不能被一个类继承，只能被一个类实现,能够继承多个接口

接口声明

　　关键字：interface

public interface Board {
 public String Manufacturer(); //生产商
}

　　接口性质：

　　　　>接口默认是抽象的

　　　　>接口中的每一个方法默认也是抽象的

　　　　>默认访问级别是public

接口实现

　关键字：implements

 1 public class Nboard implements Board {
 2     private String Manufacturer; //生产商
 3     
 4     public Nboard(String manufacturer) {
 5         super();
 6         this.Manufacturer = manufacturer;
 7     }
 8 
 9     public Nboard() {
10         super();
11 
12     }
13 
14     public String Manufacturer() {
15 
16         return Manufacturer;
17     }
18 
19 }

　　接口与接口之间可以多重继承，只能继承一个父类

　　使用接口原则：1）使用接口解决多继承

　　　　　　　　　2）为外部类添加功能

　　　　　　　　　3）以面向对象角度考虑，将一个类与自身的特征和行为依赖于外部的可选的特征和行为分离，让类尽可能单纯

　　接口优点：将设计和实现相分离，对外（调用者)隐藏实现（而通常调用者也不需要关心实现）；面向接口编程是oop的核心

接口继承

public class Nboard  extends Pet implements Board {}

多重继承

public interface HockeyListener extends SportsListener{
    //实现接口中的所有方法
}
public class SportsListener implements HockeyListener {
    //也需实现六个方法
}
public interfasce HockeyListener extends SportListener,EventListener{
    //需要实现三个接口中的方法
}