21.8.12-Java中对象的多态性、抽象类、接口

1. 对象的多态性

1.1 对象多态性前提

• 必须有继承或者是接口实现
• 必须有方法的重写

多态的语法规则: 父类或者接口的引用指向自己的子类的对象

父类 变量(对象名)  =  new 子类对象(); //多态写法

对象调用方法,执行的子类的方法重写

1.2 多态中成员的特点

• 多态中成员变量的特点

  • 编译 : 父类中没有成员变量,编译失败
  • 运行 : 运行父类中的成员变量

• 多态中成员方法的特点

  • 编译 : 父类中没有成员方法,编译失败
  • 运行 : 运行子类的方法重写

• 简练 : 成员方法编译看左边,运行看右边.成员变量都是左边

  Person p = new Student();

public class Person {
   String s = "父类成员";

   public void eat(){
       System.out.println("人在吃饭");
   }
}

public class Student extends Person {
    String s = "子类成员";

    public void eat(){
        System.out.println("学生吃饭");
    }
}

    public static void main(String[] args) {
        Person p = new Student();
        //对象p,子类对象,调用成员变量s
        System.out.println(p.s);
        //子类对象调用方法
        p.eat();
    }

1.3 多态的转型

多态的程序中,不能调用子类的特有成员!!

只能调用子类父类的共有成员!!

转后类型 变量名 = (转后类型)要转的数据; //公式

 public static void main(String[] args) {
     //创建对象,多态性
     //父类 = new 任意子类对象() 扩展
     Animal animal = new Cat();
     animal.eat();
     //Cat类的特有功能 catchMouse()方法
     //类型转换,强制
     //Cat提升为了Animal,转回Cat类型
     Cat c = (Cat)animal;
     c.catchMouse();
 }

1.4 多态中的转型异常

异常ClassCastException 类型转换异常,在多态中经常发生.

是在进行类型的强制转换的时候发生,我们现在的案例是Dog不能转成Cat.

需要解决这个异常 : 对象是Cat转Cat,是Dog换Dog

运算符 : 比较运算符,结果是boolean类型

运算符是关键字 instanceof

instanceof的语法格式:

对象名 instanceof  类的名字
解析: 比较这个对象,是不是由这个类产生的
c instanceof Cat  解释: c对象是不是Cat类产生的,如果是结果就是true

强制类型转换之前的安全性判断

public static void main(String[] args) {
    //多态创建对象
    Animal animal = new Dog();
    animal.eat();
    //判断 animal是不是Cat类的对象
    //boolean b = animal instanceof Dog ;
    //System.out.println(b);
    //调用子类的特有方法
    if (animal instanceof Cat){
        //if为true,强制转换为Cat
        Cat c = (Cat)animal;
        c.catchMouse();
    }
    if (animal instanceof Dog){
        Dog d = (Dog)animal;
        d.lookHome();
    }
}

1.5.练习

按要求实现下列问题：实现一个名为Person的类和它的子类Employee，Employee有两个子类Faculty和Staff。具体要求如下：

1）姓名name（String类型），地址address（String类型），

电话号码telphone（String类型）和电子邮件地址email（String类型）；

2） Employee类中的属性有：办公室office（String类型），工资wage（double

类型），受雇日期hiredate（String类型）；

3） Faculty类中的属性有：学位degree（String类型），级别level（String类型）；

4） Staff类中的属性有：职务称号duty（String类型）。

5） 现有对象Person p1 =new Faculty()和Person p2 =new Staff ()，请分别为p1的属性赋值“本科”和Staff类的duty赋值“职员”

package polymorphism2;

public class Test {
    public static void main(String[] args) {
        Person p1 =new Faculty();
        //判断p1是不是Faculty类的对象
        if (p1 instanceof Faculty)
        {
            //强制类型转换
            Faculty p11 = (Faculty)p1;
            p11.setDegree("本科");
            System.out.println("p11.getDegree() = " + p11.getDegree());
        }
        Person p2 =new Staff ();
        //判断p2是不是Staff类的对象
        if (p2 instanceof Staff)
        {
            //强制类型转换
            Staff p22 = (Staff)p2;
            p22.setDuty("职员");
            System.out.println("p22.getDuty() = " + p22.getDuty());
        }
    }
}

2. 抽象类 abstract

2.1 抽象方法定义

使用关键字 abstract定义抽象方法

权限修饰符 abstract 返回值类型 方法名字(参数列表) ;
abstract关键字
抽象方法没有方法体, 不需要{},直接分号结束

当一个类中的方法是抽象方法的时候,这个类必须是抽象类,在类的关键字class前面使用abstract修饰.

public abstract class 类名{}

public abstract class Animal {
    /**
     * 动物吃什么?
     * 说不清楚,抽象,可以不说
     */
    public abstract void eat();
}

2.2 抽象类的使用方式

• 抽象类不能实例化对象,不能new对象.
  • 为什么不能建立对象,类中有没有主体的方法存在,建立对象调用抽象方法是绝对的错误,因此不能建立对象.
• 需要子类继承抽象类,重写抽象方法.
• 创建子类对象
• 使用多态性创建对象,调用方法执行子类的重写
• 抽象类创建子类对象，必须全部复写抽象类所有成员函数

public class Cat extends Animal{

    /**
     * 重写父类的方法
     * 去掉修饰符 abstract
     * 添加主体 {}
     */
    public  void eat(){
        System.out.println("猫吃鱼");
    }
}

public static void main(String[] args) {
    //创建Animal的子类对象
    Animal animal = new Cat();
    //eat方法不可能执行父类,运行子类的重写
    animal.eat();
}

2.3 抽象类中多个抽象方法

public abstract class Animal {
    public abstract void  eat();
    public abstract void  sleep();
}

public class Cat extends Animal {
    //抽象类创建子类，必须重写所有的抽象类成员函数
   public void eat(){
       System.out.println("猫最爱吃鱼");
   }
    public void sleep(){
        System.out.println("猫最爱睡觉");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}

2.4 抽象类中成员的定义

2.4.1 抽象类中能否定义成员变量

可以定义成员变量,成员变量私有修饰,提供方法 get/set,由子类的对象使用

public abstract class Animal {
    //定义成员变量
    private String s;
    public abstract void  eat();
    //定义成员函数
    public String getS() {
        return s;
    }
    public void setS(String s) {
        this.s = s;
    }
}

public class Cat extends Animal {
   public void eat(){
       System.out.println("猫最爱吃鱼");
   }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        
        //调用成员函数
        a.setS("helloworld");
        a.getS();
    }
}

2.4.2 抽象类中有构造方法吗

抽象类中有构造方法,不写有默认的

public abstract class Animal {
    //定义成员变量
    private String s;
    public abstract void  eat();
    //定义成员函数
    public String getS() {
        return s;
    }
    public void setS(String s) {
        this.s = s;
    }
    //定义有参构造函数
    public Animal(String s) {
        this.s = s;
        System.out.println("抽象类构造函数初始化");
    }
}

public class Cat extends Animal {
    public Cat() {
        
        //初始化父类的构造函数
        super("helloworld");
        System.out.println("子类构造函数初始化");
    }
    public void eat(){
       System.out.println("猫最爱吃鱼");
   }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Cat();
        System.out.println("a.getS() = " + a.getS());
    }
}

2.4.3 抽象中能否不定义抽象方法

抽象类中,可以不定义出抽象方法.

但是,如果有抽象方法存在,这个类必须是抽象类

2.5 员工案例

/**
 *  公司类
 *  定义的是所有员工的共性内容
 */
public abstract class Company {
    private String name; //员工姓名
    private String id; // 员工编号,唯一标识

    //工作行为,具体到某个岗位是不同,无法写出具体的工作内容
    public abstract void work();


    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 class Development extends Company{
    //重写工作的抽象方法
    //work方法中,输出自己的姓名和工号呢
    @Override
    public void work() {
        //调用父类的方法
        System.out.println(super.getName()+"::"+super.getId()+"研发部的员工在开发程序");
    }
}

/**
 *  定义财务部类
 */
public class Financial extends Company {
    @Override
    public void work() {
        System.out.println(super.getName()+"::"+super.getId()+"财务部员工在算账");
    }

  public static void main(String[] args) {
        //创建对象,子类对象,多态性
        Company c1 = new Development();
        //父类的方法,属性赋值
        c1.setName("张三");
        c1.setId("研发部001");
        //System.out.println(c1.getName() +"::"+c1.getId());
        c1.work();

        Company c2 = new Financial();
        c2.setName("李四");
        c2.setId("财务部001");
        c2.work();
    }

3. 接口 interface

3.1 接口无处不在

接口:就是一个规范,或者称为标准 , 无论什么设备,只要符合接口标准,就可以正常使用. 接口的扩展性很强大.

3.2 Java中接口定义

当一个抽象类中的所有方法全部是抽象的时候,可以将这个抽象类换一个更加贴切的名词,叫他接口. 接口是特殊的抽象类.

定义接口,使用关键字 interface

语法规范:

public interface 接口名{}

接口在编译后,依然还是.class文件

3.3 接口中成员定义 (JDK1.7 版本)

• 成员变量

  • 成员变量的定义是具有固定格式

  • 成员变量的修饰符是固定 public static final

    public static final 数据类型  变量名 = 值 ;
    

• 成员方法

  • 成员方法的定义是具有固定格式

  • 成员方法的修饰符固定为 public abstract

    public abstract 返回值类型 方法名(参数列表) ;
    

3.4 接口的使用方式

• 接口不能建立对象,不能new
• 需要定义类,实现接口(继承类,在接口中称为实现,理解为继承)
  • 实现接口,使用新的关键字 implements
  • 实现的格式 class 类 implements 接口名{}
• 重写接口中的抽象方法
• 创建子类的对象

/**
 *  定义好的接口
 */
public interface MyInterFace {
    //接口的成员变量
    public static final int A = 1;
    //接口的成员方法
    public abstract void myInter();
}

/**
 *  定义MyInterFace接口的实现类
 *  重写接口的抽象方法
 */
public class MyInterFaceImpl implements MyInterFace{
   public void myInter(){
       System.out.println("实现类实现接口,重写方法");
    }
}

public static void main(String[] args) {
    //创建对象,多态性,创建接口实现类的对象
    MyInterFace my = new MyInterFaceImpl();
    my.myInter();
    //输出接口中的成员A的值
    System.out.println(my.A);
}

3.5 接口的多实现

类和类之间单继承,局限性的问题.接口的出现,是对单继承的改良,允许一个类同时实现多个接口.

语法格式:

class 类名 implements 接口A,接口B{}

实现类,重写实现的多有接口中的抽象方法

public interface A {
    public abstract void a();
}

public interface B {
    public abstract void b();
}

/**
 *  实现接口A和B
 */
public class C implements A,B{
    @Override
    public void a() {
        System.out.println("重写A接口方法");
    }

    @Override
    public void b() {
        System.out.println("重写B接口方法");
    }
}

public static void main(String[] args) {
    C c = new C();
    c.a();
    c.b();
}