Java基础---多态、抽象类、接口

               2015-4-4

一、多态

    1、定义：某一个事物，在不同时刻表现出来的不同状态。

    2、多态的前提与体现：

       （1）要有继承关系；

       （2）要进行方法的重写；

       （3）要父类引用指向子类对象。

    3、成员访问特点：

成员变量：编译看左边，运行看左边

构造方法：给对象中的成员进行初始化操作使用

成员方法：（方法重写）编译看左边，运行看右边

 静态方法：静态方法没有方法重写

                            编译看左边，运行看左边

成员访问特点：方法的运行看右边，其它看左边。

举例：

       class Animal {
	public void eat(){
		System.out.println("动物吃饭");
	}
	public void sleep(){
		System.out.println("动物睡觉");
	}
      }
    class Dog extends Animal {
	//重写父类方法
	public void eat(){
		System.out.println("狗吃零食");
	}
	public void sleep(){
		System.out.println("狗趴着睡觉");
	}
   }
     class Cat extends Animal {
	//重写父类方法
	public void eat(){
		System.out.println("猫吃老鼠");
	}
	public void sleep(){
		System.out.println("猫站着睡觉");
	}
	//子类特有方法
	public void playGame(){
		System.out.println("英雄联盟");
	}
    }
    class DuoTaiDemo2 {
	public static void main(String[] args) {
		//养只小狗
		Animal an = new Dog();
		an.eat();
		an.sleep();
		//再养只小狗
		Dog dog1 = new Dog();
		dog1.eat();
		dog1.sleep();
		//再养一只
		Dog dog2 = new Dog();
		dog2.eat();
		dog2.sleep();
		System.out.println("------------");
		dogMethod( dog1 );
		dogMethod( dog2 );
		System.out.println("------------");
		//多态
		animalMethod( an );// Animal an = new Dog();
		animalMethod( dog1 ); 
		Cat c = new Cat();
		animalMethod( c );
		animalMethod( new Cat() );//匿名对象作为实际参数适用
		//多态的弊端
		Animal an2 = new Cat();
		an2.playGame();
	}
	//多态
	public static void animalMethod(Animal an){//Animal an = dog1 = new Dog();
		an.eat();
		an.sleep();
	}
	//猫的方法
	public static void catMethod(Cat c){
		c.eat();
		c.sleep();
	}
	//狗的方法
	public static void dogMethod( Dog d ){
		d.eat();
		d.sleep();
	}
}

  4、多态的好处与弊端

好处：

（1）提高了程序的维护性(由继承保证)；

（2）提高了程序的扩展性(由多态保证)。

 弊端：不能访问子类特有功能。

   5、多态中的转型问题

（1）向上转型：左边（父类）= 右边（子类）例如：Animal ani= new Cat();

（2）向下转型（即强制转换）：把父类的引用强制转换为一个子类对象。

例如： Cat cat1=(Cat)ani

方法：

         （1）子类没有重写父类方法：编译看左边的父类方法，

运行是父类方法（方法从父类继承）

         （2）子类重写了父类方法：编译看左边的父类方法，

                                                                  运行看右边的子类方法。

   6、多态图解：

 

   7、多态在内存中的分配：

   8、多态方法访问：

（1）父类不能访问子类特有方法；

  （2）进行了方法重写，执行的是子类方法；

（3）没有进行方法重写，执行的父类方法；

 

二、抽象类

   1、必要性：许多类不需要具体实现功能，只需要声明方法即可，这样就是抽象类就有必要了。

   2、抽象方法：只有方法的声明，没有方法体的方法。用abstract修饰。

   3、抽象类的特点：

（1）抽象类和抽象方法必须用abstract关键字修饰

格式： abstract class 类名{ }

              Public abstract void eat（）；

（2）抽象类不一定有抽象方法，有抽象方法的类一定是抽象类。

（3）抽象类不能实例化。需要猫狗这样的子类具体实现。

（4）抽象类的子类要么是抽象类，要么重写抽象类中的所有抽象方法。

   4、抽象类的成员特点：

成员变量：可以是变量；也可以是变量。

构造方法：有构造方法，但是不能实例化；

那么，构造方法的作用是什么呢？用于子类访问父类数据的初始化。

成员方法：可以有抽象方法，限定子类必须完成某些动作；也可以有非抽象方法，提供代码的复用性。

 

   5、抽象类的的定义

     一个类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？

   可以，可以防止其他人创建本类对象。

abstract不能和这些关键字共存：

private——冲突

final——冲突

static——无意义

三、接口

   1、接口特点：

   （1）定义一个接口interface，格式：interface 接口名{ }

   （2）如何让一个类实现接口：implements

         格式：class 类名 implements 接口名 { }

 （3）接口不能实例化

           那么，接口如何实例化？

           按照多态的方式，由具体的子类实例化，其实这也是多态的一种，接口多态。

代码举例：

	Interface InterAnimalTrain{
       Public abstract voidjump();
	}
	Class Cat implements InterAnimalTrain{
 
	}

   2、三种多态：

              普通类多态：（基本不用）

              抽象类多态：（偶尔用用）

                接口多态：（经常用）

   3、接口子类：

      要么是抽象类，要么重写接口中的所有方法。

   4、接口实现的类的格式：

         通常实现接口的类，名字按照指定方式命名，原有名字后面加上Impl

例如：

	interface Inter {
	   intnum = 10；
	   finalint num2 = 20;
	}
	// 通常实现接口的类，名字按照指定方式命名，原有名字后面加上Impl
	class InterImpl implements Inter {
       }

   5、接口成员的特点：

成员变量：

都是final修饰的常量

默认修饰符：public static final

构造方法：接口中没有构造方法；

   成员方法：只能是抽象方法；

   6、类与类，类与接口，接口与接口的关系

              类与类：继承关系，Java中的类是单继承关系，可以多层继承

类与接口：实现关系，可以实现一个接口，或者多个接口

                   Java中的类，可以在继承一个类的同时，实现多个接口

                   Object：类Object是类层次结构的根类。每个类都使用Object作为超类。

接口与接口：继承关系，多继承关系

面试：Java有多继承吗？

答：有。平常使用事，没有多继承。因为Java中类是单继承，接口是多继承。

   7、抽象类与接口的区别

        抽象类 与 接口的 区别？
 Abstract Class 与 Interface 的区别？

成员区别
抽象类 
变量,常量;
抽象方法,
非抽象方法
接口 
常量;
抽象方法
关系区别
类与类 
继承，单继承
类与接口 
实现，单实现，多实现
接口与接口 
继承，单继承，多继承
设计理念区别
抽象类 
被继承体现的是：”is a”的关系。共性功能
接口 
被实现体现的是：”like a”的关系。扩展功能