继承抽象类

Posted 2020-10-17

继承

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

继承需要用到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();
      
      
   }
}