JavaSE笔记10

多态

对象多态性前提

• 必须有继承或者是接口实现

• 必须有方法的重写

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

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

多态中成员的特点

• 多态中成员变量的特点

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

  • 运行 : 运行父类中的成员变量

• 多态中成员方法的特点

  • 编译 : 父类中没有成员方法,编译失败

  • 运行 : 运行子类的方法重写

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

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(); //"学生吃饭"
}

多态的转型

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

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

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

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

补充: 多态性提升扩展性,是否需要强制转换,根据实际功能需求来决定.

多态中的转型异常

异常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();
    }
}

抽象类 abstract

抽象方法定义

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

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

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

public abstract class 类名{}

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

抽象类的使用方式

• 抽象类不能实例化对象,不能new对象.

  • 为什么不能建立对象,类中有没有主体的方法存在,建立对象调用抽象方法是绝对的错误,因此不能建立对象.

• 需要子类继承抽象类,重写抽象方法.

• 创建子类对象

• 使用多态性创建对象,调用方法执行子类的重写

public class Cat extends Animal{

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

抽象类中成员的定义

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

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

抽象类中,可以不定义出抽象方法. 但是,如果有抽象方法存在,这个类必须是抽象类

子类还是抽象类的问题

当一个子类继承一个抽象类的时候,子类必须重写全部的抽象方法.假如子类重写了部分抽象方法,这个子类依然还是抽象类.

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

/**
 * Cat继承父类Animal,Cat类拥有了父类的成员
 * 父类有什么,我就有什么
 */
public abstract class Cat extends Animal {
    public  void eat(){}
    /**
     * 方法sleep没有重写
     * 还是一个抽象的方法
     */
//    public abstract void sleep();
} 

接口 interface

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

定义接口,使用关键字 interface

语法规范:

public interface 接口名{}

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

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

• 成员变量

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

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

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

• 成员方法

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

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

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

接口的使用方式

• 接口不能建立对象,不能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("实现类实现接口,重写方法");
    }
}

接口的多实现

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

语法格式:

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接口方法");
    }
}