Java 第三弹- 多态 接口 抽象类

抽象类

**
Java语言中设置抽象类不可以实例化对象，图形类不同抽象出任何一种具体图形，但子类可以。

/**
* 用abstract 定义抽象类
*/

public abstract class Animal
{
	String name="动物";
	/**
	* abstract 定义抽象方法，没有方法体
	*/
	abstract void eat();

//普通方法
	public void setName(String name)
	{
		this.name=name;
	}
} 

子类:

public class Dog extends Animal
{
	//必须实现父类的抽象方法
	@Override
	void eat()
	{
		System.out.println("我喜欢撒狗粮");
	}
}
		

abstract：抽象类的关键字；

使用abstract关键字定义的类是抽象类，使用这个关键字定义的方法称为抽象方法。

抽象方法没有方法体，这个方法本身没有任何意义，实际上抽象类除了被继承之外没有任何意义。

另外Java中规定了类不能同时继承多个父类，面临这种问题，就出现了接口的概念。

**

什么叫接口

**
首先要牢记，接口并不是类。编写的时候感觉有点像。但完全是不同的概念。
类描述对象的属性和方法，接口则是包含类要实现的方法
即接口是抽象方法的集合

**

接口的声明

[可见度] interface 接口名称 [extends 其他的接口名] {  
 // 声明变量  
// 抽象方法  
}  

• 其他的接口名可以多个，这就是java中的，类不能多继承，但是接口可以多继承 如 public interface A extends B,C
• 变量都是static和final变量

/**
 * 接口有以下特性：
 *
 * 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
 * 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键子。
 * 接口中的方法都是公有的
 */
public interface AnimalInterface {

    void setName(String name);

}

**

接口不能被继承（extends），但可以被实现（implements）

public class Dog extends Animal implements AnimalInterface{
//必须实现父类抽象方法的抽象方法
@Override
void eat()
{
	System.out.println("我喜欢撒狗粮");
}
//必须实现接口的抽象方法
@Override
public void setName(String name)
{
}

往往在开发中抽象类和接口有些混淆，或者说有些乱用。首先抽象类用的比较少，接口用到多。接口用来定义规范，封装，回调使用。其实可以完全不用抽象类，用普通类和接口结合替代抽象类，但存在即合理。

我们知道在Java中不允许多重继承，但使用接口就可以实现多重继承。因为一个类可以同时实现多个接口，这样可以使用implements关键字后并且使用逗号分隔开来。

多重继承的语法：

class 类名 implements 接口1，接口2，…，接口n

**

多态

**

利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理方法。

在这里可以举个实例：

比如我们现在定义了一个四边形类，可以让它处理所有继承该类的对象，然后利用向上转型理念可以把每个继承四边形类的对象作为draw()方法参数，然后根据不同的图形对象绘制相应的图形。这样可以避免代码冗余问题，便于维护。

程序员无需在所有的子类中执行相同功能的算法，只要可以实例化一个继承父类的子类对象即可调用相应的方法。只要去维护父类中的这个方法即可。

**

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象

定义继承的类或者接口。可以是类，抽象类，接口

public interface AnimalInterface {

    void setName(String name);

}

子类

public class Bird implements AnimalInferface{

	private String name;
	@Override
	public void setName(String name)
	{
		this.name=name;
	}
//多态 子类扩充功能
	public void move()
	{
		System.out.println(this.name+"会飞");
	}
}

public class Dog extends Animal implements AnimalInterface{

	private String name;
	//必须实现父类抽象类的方法
	@Override 
	void eat()
	{
		System.out.println("我喜欢撒狗粮");
	}
	//必须实现接口的抽象方法
	@Override 
	public void setName(String name)
	{
		this.name=name;
	}
	//演示多态
    public void move(){
        System.out.println(this.name+"会跑");
    }
}

应用实例

public class AbstractDemo{

public static void main(String []args){
//父类（抽象类/接口）对象名=new 子类（实现类）(); (向上转型)
	AnimalInterface a=new Dog();

//向下转型，需判断
	if(a instanceof Dog){
	Dog c=(Dog) a;//向下转型 (调用子类特有方法)
	c.setName("大狗");
	c.move();
	}
	
   show(new Dog(),"小狗");
   show(new Bird(),"小鸟");
}

public static void show(AnimalInterface a,String name){
	
	a.setName(name);
	//子类特有方法调用，向下转型
	 if (a instanceof Dog)  {  // 狗做的事情
        Dog c = (Dog)a;
        c.move();
    } else if (a instanceof Bird) { // 鸟做的事情
        Bird c = (Bird)a;
        c.move();
    }
  }
}

**
多态下访问成员变量的两种方式下的不同规则

（1）直接通过对象名称访问成员变量：看等号左边是哪个对象（子类或父类），则优先用哪个对象的成员变量，没有则向上找。

（2）间接通过成员方法访问成员变量：看该方法属于哪个对象（子类或父类），则优先用哪个对象的方法，没有则向上找。

**
多态下访问成员方法的规则：

看new的是哪个对象（子类或父类），则优先用哪个对象的成员方法，没有则向上找。