面向对象的程序编程4

多态

多态：同一种事物（），在不同时刻表现不同的状态（）。

多态存在的三个必要条件：

1.要有继承（包括接口的实现）,父类可以表示子类，他们之间是有关系的。

2.要有重写（特定的抽象方法），重写过来后，调用的就是子类自己的方法实现。

3.父类引用指向子类对象

Q：什么是父类引用指向子类对象？

当编译期类型是 父类，运行期类型是子类时，被称为父类引用指向子类对象。

class Animal{ …… }
class Cat extends Animal{ …… }
class Dog extends Animal { …… }
Animal x = new Cat() //Animal 的引用指向Cat的对象

多态环境下，对成员方法的调用（编译看左边，运行看右边）

class Animal{ void show() { System.out.println(“Anmial"); }}
class Cat extends Animal{ void show() { System.out.println(“cat"); } }
…….
Animal x = new Cat() 
x.show() //调用的是子类中的方法

在未运行程序期间（即编译期间），x.show（）在eclipise上实际上显示调用的是父类中的Animal类的方法，但是在实际运行期间，调用的是子类Cat中的方法。

编译期间, 类型是父类类型，调用的是父类中定义的方法。

运行期间，运行时指向的是具体的子类对象，运行时调用的是子类的方法。

多态环境下，对静态成员方法的调用。(编译和运行都看左边)

class Animal{ static void show() 
{ System.out.println(“Animal"); } 
                     }
 class Cat extends Animal { 
     static void show() { System.out.println(“Cat"); } 
               }
     ……. 
    Animal x = new Cat() 
  x.show() //调用的是动物类中的静态成员方法。

多态环境下对成员变量的调用（编译和运行都看左边）

class Animal{ int num = 3; }
class Cat extends Animal { int num = 4; }
……. 
    Animal x = new Cat() x.num; //调用的是动物类中的成员变量。

注意：变量不存在被子类覆盖重写这一说法，只有方法存在覆盖重写

引用多态的好处：

1.方法参数具有多态性

如果代码不使用多态编写：

class Animal{ void eat() {} }
class Cat extends Animal{ void eat() {} }
class Dog extends Animal{ void eat(){} }
public class Test{
    public static void main(String[] args){
        Test t =new Test();
        Dog dog =new Dog();
        Cat cat= new Cat();
       t.feedDog(dog);
       t.feedCat(cat);
        /*
            饲养员喂狗，狗吃东西。
            饲养员喂猫，猫吃东西。
            如果饲养员还要 喂鸡，鱼，鸟...,还需要再给这些动物重新在写对应的程序
            程序的拓展性差
        */
        public void feedDog(Dog dog){dog.eat()}
        public void feedCat(Cat cat){cat.eat()}
        ......
       
    }
}
​

代码使用多态编写：

class Animal{ void eat() {} }
class Cat extends Animal{ void eat() {} }
class Dog extends Animal{ void eat(){} }//方法的形式参数类型是父类类型，而传递实际参数可以是任意 子类的对象 
 method(Animal animal){ animal .eat(); }

方法参数多态性的好处：提高代码的拓展性。

之前说过，所有没有显性继承的类，都默认继承了Object类。

// Object valueOf（Object obj）

多态的向上转型和向下转型

class Animal{ void eat(){ } }
class Cat extends Animal{ void look() { System.out.println("看家"); } }
……… 
​
Animal x=new Cat() //向上造型，Cat对象提升到Animal对象 x.eat() 
//只能使用父类中的方法 
x.look() //报错！不能使用子类中的方法
​
Animal x=new Cat() 
    Cat m=(Cat)x; //向下转型 
m.eat() ; 
m.look();//子父类中的方法都可以使用

向上转型的作用是：提高程序的拓展性。

向下转型的作用是：为了使用子类中的特有方法。

instanceof关键字

if(animal instanceof Bird){
    Bird b =(Bird) animal;
    b.play();
}

引用 instanceof 具体的类型 判断引用实际类型是否为后面指定的具体类型

final关键字

final 用于声明属性，方法和类。

属性：定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改。

方法：不可被继承，子类里不可以重写。

类: 不可被继承，不能被定义为抽象类或者接口。。

关于final关键字：

对属性进行修饰：

private int index; 
private static final double pai=3.14; 
private final int level;
public Test(){ level=0; }
public Test(int index){ 
this.index=index; level=1; 
}

在声明时同时赋值，往往与static一起使用。

声明时不赋值，必须在构造方法中逐一赋值。

总的原则：保证创建每一个对象的时候，final属性的值是确定的。

对参数进行修饰：

在方法参数前面加final关键字，为了防止数据在方法体中被修改。

public void ww(final int a){
	a=12;	//Error!
}

接口

接口 interface

可以将接口看做是一个比较纯正的抽象类，作为设计层面使用的，用来定义功能（方法）。

具体的实现交给具体的类。

接口更抽象，在jdk8之前，接口中只能定义常量和抽象方法。

jdk8之后添加静态方法和默认方法

抽象类中有抽象方法，还可以有非抽象，成员变量，构造方法.....

接口的定义：使用interface 关键字用来声明一个接口。

[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n]

{

// 声明常量 抽象方法 静态方法 默认方法

}

接口的使用：类使用implements关键字实现接口。在类声明中，Implements关

键字放在class声明后面。

[访问修饰符] class 类名 implements 接口名1，接口名2……{ }

继承多个接口：

[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

类继承接口

类只能直接继承一个类

类可以实现多个接口

接口可以继承多个接口

关于接口： 1.接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字

1. 接口中声明的属性默认为 public static final 的

2. 接口中声明的方法 默认为 抽象方法。

3. 接口不是被类继承了，而是要被类实现。接口不能实例化对象

4. 一个接口能继承其它多个接口

5. 当类实现接口的时候，类要实现接口中所有的抽象方法。否则，类必须

   声明为抽象的类

   7.与继承关系类似，接口与实现类之间存在多态性