标签：继承、抽象类
继承：描述的是类与类之间的所属关系，在现有类的基础上去构建一个新的类，这个新的类被称为是子类，现有的类被称为是父类，子类会自动拥有父类中可继承的属性和方法，注意，私有的内容不能继承。
继承需要用到extends关键字，具体如何继承如下代码：
l 员工类
package cn.itcast.extends继承;
/*
* 员工类（父类），定义了姓名和功能
* 要实现继承成员变量和方法不能私有，否则不能实现继承
*/
public class Employee {
//定义姓名变量
String name;
//定义方法
public void work(){
System.out.println("员工在工作");
}
}l 研发部员工类
package cn.itcast.extends继承;
/*
* 研发部员工类（子类），他的属性有员工类的属性和方法
* 他的属性extends继承员工类就可以了，不用重复定义
*/
public class Developer extends Employee {
//实验在子类中不用定义姓名是否可以打印出父类中的姓名
public void getName(){
System.out.println(name);
}
}l 测试类
package cn.itcast.extends继承;
/*
* 测试类，测试Developer类是否继承了Employee类中的属性
*/
public class Test {
public static void main(String[] args) {
//创建Developer类的对象
Developer s = new Developer();
//给姓名赋值
s.name = "张三";
//通过Developer类的对象调用Employee类中的方法
s.work();
//调用Developer类中的对象
s.getName();
}
}1、 继承的实现提高了代码的复用性
2、 继承使类与类之间产生了联系，为多态提供了前提。
1、 java中只支持单继承，不支持多继承，下面这种情况是不允许的
public class A{}
public class B{}
public class C extends A,B{}
2、 多个类可以继承同一个父类，如：
public class A{}
public class B extends A{}
public class C extends A{}
3、 Java中可以多重继承，也就是说一个类的父类可以去继承另一个类的父类，如：
public class A{}
public class B extends A{}
public class C extends B{}
前提：该成员变量不能是私有的，子类父类中变量名重名。
创建子类对象，如果想要使用子类的成员变量，这时方法中的局部变量名字也一样，想要使用成员变量在变量名前面加上this.即可。如果想要使用父类中的成员变量，在变量名前面加上super.即可。
this. 访问本类中的成员变量
super. 访问父类中的成员变量
前提：该成员方法不能是私有的，子类父类中方法名相同。
创建子类对象，调用方法时，如果子类有就会使用子类自己的，子类没有，就会使用父类的方法。子类父类中的方法名相同，调用子类方法，该方法会重写父类方法，运行的方法还是子类中的方法。
以前的手机的功能有打电话，发短信，显示来电号码，现在需要加入新的功能，在来电显示号码中加入显示姓名和头像，如果在原来的代码中重新改功能的话，会遇到许多不可预知的后果，这是就需要用到继承的用法，不需要直接改原来的功能，只需要在来电显示的功能中进行方法的重即可，下面对这个需求进行代码的演示：
l 手机类
package cn.itcast.phone继承;
/*
* 手机类
* 功能：打电话、发短信、来电显示号码
*/
public class Phone {
//打电话的功能
public void callNumber(){
System.out.println("打电话功能");
}
//发短信功能
public void sendMessage(){
System.out.println("发短信功能");
}
//来电显示号码功能
public void showNumber(){
System.out.println("来电显示号码功能");
}
}l 新手机类
package cn.itcast.phone继承;
/*
* 新手机类，加入了来电显示姓名和头像功能
* 继承Phone类，重写callNumber功能即可
*/
public class NewPhone extends Phone{
//重写来电显示功能
public void showNumber(){
//调用原来的来电显示功能
super.showNumber();
System.out.println("显示姓名");
System.out.println("显示头像");
}
}l 测试类
package cn.itcast.phone继承;
/*
* 测试类，测试手机功能
*/
public class Test {
public static void main(String[] args) {
//创建Phone对象
Phone p = new Phone();
p.callNumber();
p.sendMessage();
p.showNumber();
//创建NewPhone对象
NewPhone newp = new NewPhone();
//调用showNumber方法
newp.showNumber();
}
}方法重写时，子类的方法权限必须要大于等与父类的方法权限否则编译失败。
四大权限：public(公共的) protected(受保护的权限) default(默认的) private(私有的)
什么是抽象类呢？比如研发工程师和维护工程师他们都有工程师，有自己的工作的内容，我们需要抽取他们的共性内容，他们都会工作，但是具体的工作内容并不知道，向上抽取后，只抽取了他们会工作，但是具体的实现细节并没有抽取，这就是抽象方法，抽取后的类（工程师）也就是抽象类。
抽象类必须用一个关键字加以修饰，abstract
抽象类的定义格式：修饰符 abstract 类名{}
抽象方法的定义格式：修饰符 abstract 返回值类型 方法名();
接下来用一段代码来演示抽象类的定义：
package cn.itcast.abstract抽象类;
/*
* 开发工程师类：
* javaEE开发工程师
* Android开发工程师
* 他们都属于开发工程师，他们的共性内容就是开发，抽取后并不清楚他们开发的实现细节，所以开发功能是抽象方法，
* 该方法没有方法主体，直接以分号结束即可，类也要定义成抽象类
*/
public abstract class Developer {
public abstract void develop();
}需要注意的是抽象类不能实例化对象，也就是说，不能创建抽象类的对象，因为它没有方法主体，调用它的方法并不能运行，那么为什么要定义抽象类呢？抽象类都是其他具体的类向上抽取而来，不能实例化抽象类，我们可以创建子类的对象，来重写抽象类的抽象方法，具体的代码演示如下：
l 开发工程师父类
package cn.itcast.abstract抽象类;
/*
* 开发工程师类：
* javaEE开发工程师
* Android开发工程师
* 他们都属于开发工程师，他们的共性内容就是开发，抽取后并不清楚他们开发的实现细节，所以开发功能是抽象方法，
* 该方法没有方法主体，直接以分号结束即可，类也要定义成抽象类
*/
public abstract class Developer {
public abstract void develop();
}l JavaEE开发工程师子类
package cn.itcast.abstract抽象类;
/*
* JavaEE开发工程师，继承父类，重写父类Develop的方法
*/
public class JavaEEDeveloper extends Developer{
public void develop(){
System.out.println("JavaEE开发工程师正在开发B/S软件");
}
}l Android开发工程师子类
package cn.itcast.abstract抽象类;
/*
* Android开发工程师类：继承父类，重写父类Developer的方法
*/
public class AndroidDeveloper extends Developer{
public void develop(){
System.out.println("Andriod开发工程师正在开发手机软件");
}
}l 测试类
package cn.itcast.abstract抽象类;
/*
* 测试类
* 测试抽象类的方法是否被子类重写
*/
public class Test {
public static void main(String[] args) {
//创建JavaEE的对象
JavaEEDeveloper ee = new JavaEEDeveloper();
//调用重写方法
ee.develop();
//创建Andriod对象
AndroidDeveloper android = new AndroidDeveloper();
//调用重写方法
android.develop();
}
}1、 抽象类中的抽象方法必须被abstract修饰，抽象类的前面也必须加上abstract
2、 抽象类不能被实例化对象，因为它没有方法体，调用它没有意义
3、 抽象类的子类必须把抽象类中的方法全部重写，如果只重写一部分，这个子类还是抽象类，不能创建子类对象。
保证功能的完整性，强制子类重写父类中的方法。
JavaEE工程师、Android工程师属于研发部，网络维护工程师、硬件维护工程师属于维护部。
公司的每名员工都有他们自己的员工编号、姓名，并要做它们所负责的工作。
l 工作内容
n JavaEE工程师：员工号为xxx的 xxx员工，正在研发淘宝网站
n Android工程师：员工号为xxx的 xxx员工，正在研发淘宝手机客户端软件
n 网络维护工程师：员工号为xxx的 xxx员工，正在检查网络是否畅通
n 硬件维护工程师：员工号为xxx的 xxx员工，正在修复打印机
请根据描述，完成员工体系中所有类的定义，并指定类之间的继承关系。进行XX工程师类的对象创建，完成工作方法的调用。
分析：我们需要对这四个职位进行共性的抽取，JavaEE工程师、Android工程师属于属于研发部，向上抽取，网络维护工程师、硬件维护工程师属于维护部，向上抽取，研发部、维护部都属于员工类，可以继续向上抽取。
代码实现：
l 员工类
package cn.itcast.abstract抽象类演示;
/*
* 员工类：对每个职位的共性内容进行抽取
* 共性内容：工号、姓名
* 工作
*/
public abstract class Employee {
//定义抽取的姓名
private String name;
//定义抽取的工号
private String ID;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
//定义抽取的方法
public abstract void work();
}l 研发部类
package cn.itcast.abstract抽象类演示;
/*
* 研发部员工类，继承员工类
* 以后可以定义研发部员工自己特有的功能
*/
public abstract class Developer extends Employee{
}l 维护部类
package cn.itcast.abstract抽象类演示;
/*
* 维护部员工类，继承员工类
* 以后可以定义维护部员工自己特有的功能
*/
public abstract class Maintainer extends Employee{
}l JavaEE工程师类
package cn.itcast.abstract抽象类演示;
/*
* JavaEE研发类:继承研发部类
* 属性：工号、姓名
* 方法：工作
*/
public class JavaEE extends Developer{
//重写父类的功能
public void work(){
System.out.println(super.getName()+"..."+super.getID()+"..."+"JavaEE工程师正在研发淘宝网站");
}
}l Andriod工程师类
package cn.itcast.abstract抽象类演示;
/*
* Android研发类，继承研发部类
*/
public class Android extends Developer{
//重写父类中的方法
public void work(){
System.out.println(super.getName()+"..."+super.getID()+"Android研发人员正在研发淘宝手机客户端软件");
}
}l 网络维护部类
package cn.itcast.abstract抽象类演示;
/*
* 网络维护工程师类，继承维护部类
*/
public class Network extends Maintainer{
//重写父类方法
public void work(){
System.out.println(super.getName()+"..."+super.getID()+"..."+"网络维护工程师正在检查网络是否畅通");
}
}l 硬件维护部类
package cn.itcast.abstract抽象类演示;
/*
* 硬件维护工程师类，继承维护部类
*/
public class Hardware extends Maintainer{
//重写父类方法
public void work(){
System.out.println(super.getName()+"..."+super.getID()+"硬件维护工程师正在修复打印机");
}
}l 测试类
package cn.itcast.abstract抽象类演示;
/*
* 测试类
*/
public class Test {
public static void main(String[] args) {
//创建个工作人员 的对象
JavaEE ee = new JavaEE();
Android and = new Android();
Network net = new Network();
Hardware hard = new Hardware();
//调用方法
ee.setName("张三");
ee.setID("研发部001");
and.setName("李四");
and.setID("研发部002");
net.setName("王五");
net.setID("维护部001");
hard.setName("马六");
hard.setID("维护部002");
ee.work();
and.work();
net.work();
hard.work();
}
}
标签：继承、抽象类
原文地址：http://blog.51cto.com/13502869/2051215
