黑马程序员——Java面向对象之二（接口和多态 ）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、接口（interface）

1、接口的定义概述：

          java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

在java中定义接口与定义类不同：

定义类用class；定义接口用interface。

接口的定义格式：interface{ }

对于接口中常见的成员，而这些成员都有固定的修饰符。

1、成员变量：public  static final

2、修饰方法：public abstract

注：接口中的成员都是public

接口的特点：

接口是对外暴露的规则

接口是程序的功能扩展

接口的出现降低了耦合性

接口可以实现多实现

类与接口之间是是实现关系，而且一个类继承另一个类的同时可以实现多个接口

接口与接口之间是继承关系

接口与抽象类的异同点：

相同点：

           都是不断向上抽取而来的

不同点：

           1、抽象类可以被继承，而且只能是单继承，接口需要被实现，而且 可以多实现。

           2、抽象类中可以定义抽象方法 和非抽象方法，子类继承后可以直接使用非抽象方法，接口只能定义抽象方法，必须有子类去实现。

           3、抽象类的继承是is a关系，在定义该体系的基本共性内容，接口实现的是like a 关系，在定义该功能的额外功能。

类与类之间是继承关系，接口之间是实现关系，接口不可以被实例化，因为接口不可以创建对象，创建了毫无意义，接口只能由实现了接口的子类并覆盖了接口中所有的方法后，该子类才可以被实例化，否则，这个子类仍然是个抽象类。

示例（1）接口示例化过程：

public class Interface 
{
	public static void main(String[]args)
	{
      Demo d=new Demo1();
     System.out.println(d.NUM);
	}
}
interface Demo
{
	public static final int NUM=4;
	public abstract void show();
}
class Demo1 implements Demo
{
	public void show()
	{
		
	}

在Java中不直接支持多继承，因为会出现调用的不确定性，所以Java 将多继承进行了改良，变成了多实现。

示例（2）一个类可以实现多个接口：

public class Interface 
{
	public static void main(String[]args)
	{
      Demo2 d=new Demo2();
      int add =d.show1(3,4);
     System.out.println(add);
	}
}
interface Demo
{
	public static final int NUM=4;
	public abstract void show();
}
interface Demo1
{
	public static final int NUM=4;
	public abstract int show1(int a,int b);
}
class Demo2 implements Demo,Demo1//多实现
{
	public int show1(int a,int b)
	{
		int sum = a+b;
		return sum;
		
	}
	public void show() {
	}
	
}

       示例（3）一个类继承另一个类的同时，还可以实现多个接口。

      
public class Interface 
{
	public static void main(String[]args)
	{
      Demo2 d=new Demo2();
      int add =d.show1(3,4);
     System.out.println(add);
	}
}
interface Demo
{
	public static final int NUM=4;
	public abstract void show();
}
interface Demo1
{
	public static final int NUM=4;
	public abstract int show1(int a,int b);
}
class Demo2 extends A implements Demo,Demo1//继承类A的同时多实现
{
	public int show1(int a,int b)
	{
		int sum = a+b;
		return sum;
		
	}
	public void show() {
	}
}
class A
{
	public void method()
	{<span style="font-family: arial, 宋体, sans-serif;">}</span>
}<span style="font-family: arial, 宋体, sans-serif;">     </span>

           示例（4）接口的出现避免了单继承的局限性。接口之间是继承关系，而且可以实现多继承，最后再让类实现。

           
interface B
{
	
	public abstract void show();
}
interface C
{
	
	public abstract void method();
}
interface D extends B,C//接口之间是继承关系，而且接口可以多继承。
{
	
	public abstract void function();
}
class E implements D
{
	/*
	 * 实现三个方法的覆盖。
	 * */
	public  void show()
	{}
	public  void method()
	{}
	public  void function()
	{}
}

二：多态的概述：

    定义：简单的说就是一个对象对应的不同形态。

       例：动物中猫，狗。猫这个对象对应的类型是猫类型，如：猫 x = new猫(); 同时猫也是动物中的一种，也可以把猫称为动物。动物  y = new猫(); 那么动物就是猫和狗具体事物中抽取出来的父类型。父类型引用指向了子类对象。

           
 
 

  
  （1）多态的体现

  
  父类的引用指向了自己的子类对象。

  
  父类的引用也可以接收自己的子类对象。
 
 
 
 

  
  
（2）多态的前提

  
  必须是类与类之间有关系。要么继承，要么实现。

  
  通常还有一个前提：存在覆盖。
 
 
 
 

  
  
（3）多态的好处

  
  多态的出现大大的提高程序的扩展性。

（4）多态的弊端：

  
  提高了扩展性，但是只能使用父类的引用访问父类中的成员。
 
 
 
 

  
  例如下面的示例：
 
 
 
 
      
  
  
package 练习1;

	//父类————动物  
	abstract class Animal  
	{  
	    public abstract void eat();  
	  
	}  
	  
	//子类————猫  
	class Cat extends Animal  
	{  
	    //复写父类中的抽象功能  
	    public void eat()  
	    {  
	        System.out.println("吃鱼");  
	    }  
	  
	    //Cat特有的功能  
	    public void catchMouse()  
	    {  
	        System.out.println("抓老鼠");  
	    }  
	}  
	  
	  
	class Demo  
	{  
	    public static void main(String[] args)   
	    {  
	        Animal a = new Cat(); //自动类型提升，毛对象提升为动物类型，但是其特有的功能无法访问。
	                             //作用就是限制对特有功能的访问。
	                            
	        a.eat();  
	        Cat c = (Cat)a;//向下转型目的是为了使用子类中的特有功能  
	       c.catchMouse(); 
	    }  
	}  
  
  
2：多态的扩展性：
  
  
   下面就是一个多态的扩展性的例子：例如毛、狗、猪、都具备动物的一些特征。
  
  
      <pre name="code" class="java">package 练习1;

	//父类————动物  
	abstract class Animal  
	{  
	    public abstract void eat();  
	  
	}  
	  
	//子类————猫  
	class Cat extends Animal  
	{  
	    //复写父类中的抽象功能  
	    public void eat()  
	    {  
	        System.out.println("吃鱼");  
	    }  
	  
	    //Cat特有的功能  
	    public void catchMouse()  
	    {  
	        System.out.println("抓老鼠");  
	    }  
	}  
	  
	//子类————狗
		class Dog extends Animal  
		{  
		    //复写父类中的抽象功能  
		    public void eat()  
		    {  
		        System.out.println("啃骨头");  
		    }  
		  
		    //dog特有的功能  
		    public void lookHome()  
		    {  
		        System.out.println("看家");  
		    }  
		}  
		//子类————猪 
		class Pig extends Animal  
		{  
		    //复写父类中的抽象功能  
		    public void eat()  
		    {  
		        System.out.println("饲料");  
		    }  
		  
		    //pig特有的功能  
		    public void catchMouse()  
		    {  
		        System.out.println("拱地");  
		    }  
		}  
	class Demo  
	{  
	    public static void main(String[] args)   
	    {  
	        Animal a = new Cat(); //自动类型提升，毛对象提升为动物类型，但是其特有的功能无法访问。
	                             //作用就是限制对特有功能的访问。
	                            
	        a.eat();  
	        Cat c = (Cat)a;//向下转型目的是为了使用子类中的特有功能  
	       c.catchMouse(); 
	       Animal d = new Dog();
	       d.eat();
	       Dog d1 = (Dog)d;
	       d1.lookHome();
	       Animal p = new Pig();
	       p.eat();
	    }  
	}