码迷,mamicode.com
首页 > 其他好文 > 详细

继承、抽象类

时间:2017-12-16 00:10:52      阅读:157      评论:0      收藏:0      [点我收藏+]

标签:继承、抽象类


继承

继承:描述的是类与类之间的所属关系,在现有类的基础上去构建一个新的类,这个新的类被称为是子类,现有的类被称为是父类,子类会自动拥有父类中可继承的属性和方法,注意,私有的内容不能继承。

继承需要用到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/2051216

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!