多态性是面向对象的最后一个特征，它本身主要分为两个方面：
方法的多态性：重载与覆写
1 重载：同一个方法名称，根据参数类型以及个数完成不同功能；
2 覆写：通一个方法，根据操作的子类不同，所完成的功能也不同。
对象的多态性：父子类对象的转换。
1 向上转型：子类对象变为父类对象，父类 父类对象 = 子类 子类对象 自动；
2 向上转型：父类对象变为子类对象，格式：子类 子类对象 = （子类）父类实例，强制；
class A{
public void print(){
System.out.println("A输出");
}
}
class B extends A{
public void print(){
System.out.println("B输出");
}
}
public class TestDemo1{
public static void main(String args[]){
B b = new B();
//B输出
b.print();
}
}
这种操作主要观察两点：
1 看实例化的是哪一类（new）；
2 看new的这个类之中是否被覆写了父类调用的方法。
public class TestDemo1{
public static void main(String args[]){
A a = new B(); //向上转型
//B输出
a.print();
}
}
public class TestDemo1{
public static void main(String args[]){
A a = new B(); //向上转型
B b = (B) a; //向下转型
b.print();
}
}
public class TestDemo1{
public static void main(String args[]){
A a = new A(); //没有转型
B b = (B) a; //向下转型
b.print();
}
}
/*
Exception in thread "main" java.lang.ClassCastException: A cannot be cast to B
at DuoTaiXing.main(TestDemo1.java:14)
*/
以上的程序在编译的时候没有发生任何错误信息，但是在执行的时候出现了“ClassCastException”错误提示，表示的是类转换异常，即：两个没有关系的类互相发生了对象的强制转型。
转型的因素：
1 在实际工作之中，对象的向上转型为主要使用，向上转型之后，多有方法以父类的方法为主，但是具体的实现，还是要看子类是否覆写了此方法；。
2 向下转型，因为在进行向下转型操作之前，一定要首先发生向上转型，以建立两个对象之间的联系，如果没有这种联系，是不可能发生向下转型的，一旦发生了运行中就会出现“ClassCastException”当需要调用子类自己特殊定义方法的时候，菜需要向下转型。
3 不转型，在一些资源较少的时候，如：移动开发。
class A{
public void print(){
System.out.println("A输出");
}
}
class B extends A{
public void print(){
System.out.println("B输出");
}
public void funB(){
System.out.println("funB");
}
}
public class TestDemo1{
public static void main(String args[]){
A a = new B(); //向上转型
System.out.println(a instanceof A);
System.out.println(a instanceof B);
if (a instanceof B){
B b = (B) a;
b.funB();
}
}
}
/*
true
true
funB
*/
为了日后的操作方便，在编写代码的时候，尽量不要去执行向下的转型操作，子类尽量不要去扩充新的方法名称（父类没有的方法名称），依据父类定义的操作完善方法。
例题：利用对象向上转型完成
class A{
public void print(){
System.out.println("A输出");
}
}
class B extends A{
public void print(){
System.out.println("B输出");
}
}
class C extends A{
public void print(){
System.out.println("C输出");
}
}
public class TestDemo2{
public static void main(String args[]){
fun(new B());
fun(new C());
}
public static void fun(A a){
a.print();
}
}
这样以来就得到了类型的统一，就算有再多的子类出现，方法或者是类也不需要进行修改了，但是在这块必须强调的是：子类操作的过程之中，尽量向父类靠拢。
以后所有的代码之中，都会存在对象的转型问题，并且向上转型居多。
在日后的所有开发之中，像之前程序那样，一个类去继承另外一个已经实现好的类的情况，是不可能出现的。即：一个类不能去继承一个已经实现好的类，只能继承抽象类或实现接口。
在以后你进行的项目开发中，绝对不要出现一个类继承一个已经实现好的类。
对象多态性的核心本质在于方法的覆写，这样的操作有些不合要求，所以要对子类的方法进行强制的要求就必须采用我们的抽象类进行实现。
普通类就是一个完善的功能类，可以直接产生对象并且可以使用，里面的方法都是带有方法体的，而抽象类之中最大的特点是包含了抽象方法，而抽象方法是只声明而未实现（没有方法体）的方法，而抽象方法定义的时候要使用abstract关键字完成，而抽象方法一定要在抽象类之中，抽象类要使用是用abstract声明。
abstract class A{
private String msg = "www.baidu.com";//属性
public void print(){ //普通方法
System.out.println(msg);
}
//{}为方法体，所有的抽象方法上是不包含有方法体的
public abstract void fun() ; //抽象方法
}
public class ChouXiang{
public static void main(String args[]){
/*
ChouXiang.java:12: 错误: A是抽象的; 无法实例化
A a =new A();
^
1 个错误
*/
A a =new A();
}
}
抽象类比普通类多了抽象方法而已，没有上面特殊的。
抽象方法为什么不能实例化对象？
抽象类中包含抽象方法，而抽象方法与普通方法最大的区别就是没有方法体，不知道具体的实现，而如果产生了实例化就意味着以可以调用类中的所有操作。
抽象类的使用原则：
abstract class A{
private String msg = "www.baidu.com";//属性
public void print(){ //普通方法
System.out.println(msg);
}
//{}为方法体，所有的抽象方法上是不包含有方法体的
public abstract void fun() ; //抽象方法
}
//一个子类只能够利用extends来继续继承抽象类，所以依然存在单继承局限
class B extends A{//定义抽象类的子类
public void fun(){
System.out.println("Hello");
}
}
public class ChouXiang{
public static void main(String args[]){
A a =new B();//向上转型
a.print();
a.fun();
}
}
通过以上的一个程序，现在就可以清楚的发现，与之前类不一样的是，抽象类定义出了子类必须要覆写的方法，而之前的类子类可以有选择性的来决定是否覆写。而且可以发现，抽象类实际上就比普通类多了一些抽象方法而已，其他的定义和普通类完全一样。如果把普通类比喻成一盘炒熟的菜，那么抽象类就是一盘半成品。
关于抽象类的若干中疑问？
1、抽象类能否使用final定义？
不能，因为final定义的类不能有子类，而抽象类必须有子类。
2、抽象类之中能否包含构造方法？
可以，因为抽象类之中除了包含抽象方法之外，还包含了普通方法和属性，而属性一定要在构造方法执行完毕之后才可以进行初始化操作；
3、抽象类之中能否不包含抽象方法？
可以，抽象类之中可以没有抽象方法，但是反过来来讲，如果有抽象，则一定是抽象类。即使抽象类之中没有抽象方法也不能被直接实例化。
4、抽象类能否使用static声明？
如过定义的是外部抽象类，则不能够使用static声明，可是如果定义的是内部类，那么这个内部的抽象类使用了static声明之后，就表示一个外部的抽象类。
abstract class A{
private String str = "Hello,China";
static abstract class B{
public abstract void print();
}
}
class C extends A.B{
public void print(){
System.out.println("你好,中国");
}
}
public class ChouXiang{
public static void main(String args[]){
A a =new B();//向上转型
a.print();
}
}
结论：如果构造方法没有执行，类中对象中属性一定都是其对应数据类型的默认值。
抽象类的最大特点在于强制规定了子类的实现结构。
抽象类和普通类最大的特点就是约定了子类的实现要求：但是抽象类有一个缺点——单继承局限，如果要想要求以及避免单继承局限，就需要使用接口。在以后的开发中，接口优先，在一个操作中既可以使用抽象类又可以使用我们的接口，优先考虑接口。
接口就是一个抽象方法和全局常量的集合，属于一种特殊的类，如果一个类定义的时候全部由抽象方法和全局常量所组成的话，那么这种类就称为接口，但是接口是使用interface关键字定义的。
interface A{//定义接口
public static final String INFO="Hello,World";
public abstract void print();
}
interface B{
public abstract void get();
}
那么在接口之中，也同样存在了抽象方法，很明显，接口对象无法进行对象的实例化操作，那么接口的使用原则如下：
1、每一个接口必须定义子类，子类使用implement关键字实现接口；
2、接口的子类（如果不是抽象类）则必须覆写接口之中所定义的全部抽象方法；
3、利用接口的子类，采用对象的向上转型方式，进行接口对象的实例化操作。
在Java之中每一个抽象类都可以实现多个接口,但是反过来讲,一个接口却不能继承抽象类,可是Java之中,一个接口却可以同时继承多个接口，以实现接口的多继承操作。
//因为接口和类的定义命名要求相同，所以为了区分接口和类
//建议在所以的接口前面追加一个字母I
interface IMessage{
public static final String MSG = "www.baidu.com";
public abstract void print();//抽象方法
}
interface INews{
public abstract String get();
}
class MessageImpl implements IMessage,INews{
public void print(){
System.out.println("IMessage中print方法：" +IMessage.MSG);
}
public String get(){
return "INews中get方法：" + IMessage.MSG;
}
}
class NewsImpl implements INews{
public String get(){
return null;
}
}
public class InFa{
public static void main(String args[]){
IMessage ms = new MessageImpl();
//InFa
ms.print();
INews m = new MessageImpl();
//INews中get方法：www.baidu.com
System.out.println(m.get());
/*
Exception in thread "main" java.lang.ClassCastException: NewsImpl cannot be cast to IMessage
at InFa.main(InFa.java:33)
转换异常
*/
INews mn = new NewsImpl();
IMessage m1 = (IMessage) mn;
System.out.println(mn.get());
}
}
但是需要说明的是:接口之中的全部组成就是抽象方法和全局常量,那么在开发之中一下的两种定义接口的最终效果是完全一样的:
完整定义：
interface A{
public static final String INFO="接口A";
public abstract void print();
}
简化定义：
interface A{//定义接口
public String INFO="接口A";
public void print();
}
接口之中所有访问权限只有一种:public,即:定义接口方法的时候就算没写上public,最终也是public.
//因为接口和类的定义命名要求相同，所以为了区分接口和类
//建议在所以的接口前面追加一个字母I
interface INews{
public String get();//抽象方法
}
//可以再类上进行明确描述，在以后的开发之中也经常出现以下的命名习惯
abstract class AbstractMessage{
//只有接口中的abstract中才可以省略，抽象类中的不能省略
public abstract void print();
}
class NewsImpl extends AbstractMessage implements INews{
public String get(){
return "www.baidu.com";
}
public void print(){} //有方法体就叫覆写
}
public class InFa1{
public static void main(String args[]){
INews news = new NewsImpl();
System.out.println(news.get());
//NewsImpl是抽象类和接口的共同子类
AbstractMessage am = (AbstractMessage) news;
am.print();
}
}
3.一个抽象类可以使用implements实现多个接口，但是接口不能够去继承抽象类；
//因为接口和类的定义命名要求相同，所以为了区分接口和类
//建议在所以的接口前面追加一个字母I
interface INews{
public String get();//抽象方法
}
//可以再类上进行明确描述，在以后的开发之中也经常出现以下的命名习惯
abstract class AbstractMessage implements INews{
//只有接口中的abstract中才可以省略，抽象类中的不能省略
public abstract void print();
}
class NewsImpl extends AbstractMessage{
public String get(){
return "www.baidu.com";
}
public void print(){} //有方法体就叫覆写
}
/*
该类的调用相当于孙子实例化爷爷对象 将 爷爷对象转换为儿子对象
*/
public class InFa1{
public static void main(String args[]){
INews news = new NewsImpl();
System.out.println(news.get());
//NewsImpl是抽象类和接口的共同子类
AbstractMessage am = (AbstractMessage) news;
am.print();
}
}
实际上此时关系属于三层继承。
接口与抽象类
//因为接口和类的定义命名要求相同，所以为了区分接口和类
//建议在所以的接口前面追加一个字母I
interface INews{
public String get();//抽象方法
public void pirnt();
}
//假设一个接口可能有无数个子类，但是对于一个方法的实现是一样的
abstract class AbstractMessage implements INews{
public void print(){
System.out.println("www.baidu.com");
}
}
//生怕别人不知道NewsImpl是INews接口的子类，做一个重复标记而已
class NewsImpl extends AbstractMessage implements INews{
public String get(){
return "www.baidu.com";
}
public void print(){} //有方法体就叫覆写
}
/*
该类的调用相当于孙子实例化爷爷对象 将 爷爷对象转换为儿子对象
*/
public class InFa1{
public static void main(String args[]){
INews news = new NewsImpl();
System.out.println(news.get());
//NewsImpl是抽象类和接口的共同子类
AbstractMessage am = (AbstractMessage) news;
am.print();
}
}
4.一个接口可以使用extends来继承多个父接口。
interface A{
public void pirntA();
}
interface B{
public void pirntB();
}
interface C extends A,B{
public void pirntC();
}
class Impl implements C{
public void pirntA();
public void pirntB();
public void pirntC();
}
public class InFa1{
public static void main(String args[]){
}
}
5.接口可以定义一系列的内部接口，包括：内部普通类、内部抽象类、内部接口，其中使用static定义的内部接口就相当于是一个外部接口
而在开发之中,内部类是永远不会受到概念限制的,在一个类中可以定义内部类,在一个抽象类之中也可以抽象内部类,在一个接口里面也可以定义内部抽象类或内部接口.但是从实际的开发来讲用户去定义内部抽象类或内部接口的时候是比较少见的(android开发中见过)，而且在定义内部接口的时候如果使用了static，表示一个外部接口。
interface A{
public void printA();
static interface B{ //外部接口
public void printB();
}
}
class X implements A.B{
public void printA(){
System.out.println("A");
}
public void printB(){
System.out.println("B");
}
}
public class Inter{
public static void main(String args[]){
A.B ab = new X();
ab.printB();
}
}
以上对于接口的概念并不是很难理解，但是需要强调的是，在实际开发之中，接口有三大主要功能：
定义USB接口：
interface USB{
public void install(); //进行安装
public void work(); //进行工作
}
定义USB的子类：
class Computer{
public void plugin(USB usb){
usb.install();
usb.work();
}
}
class Flash implements USB{
public void install(){
System.out.println("安装U盘驱动");
}
public void work(){
System.out.println("U盘进行工作");
}
}
class Printer implements USB{
public void install(){
System.out.println("安装打印机驱动");
}
public void work(){
System.out.println("打印机进行工作");
}
}
源代码：
interface USB{
public void install(); //进行安装
public void work(); //进行工作
}
class Computer{
public void plugin(USB usb){
usb.install();
usb.work();
}
}
class Flash implements USB{
public void install(){
System.out.println("安装U盘驱动");
}
public void work(){
System.out.println("U盘进行工作");
}
}
class Printer implements USB{
public void install(){
System.out.println("安装打印机驱动");
}
public void work(){
System.out.println("打印机进行工作");
}
}
public class InFa3{
public static void main(String args[]){
/*
安装U盘驱动
U盘进行工作
安装打印机驱动
打印机进行工作
*/
Computer cm = new Computer();
cm.plugin(new Flash());
cm.plugin(new Printer());
}
}
发现使用接口和对象多态性结合，对于参数的统一更加明确。而且可以发现接口时再类之上的设计。
| 区别 | 抽象类 | 接口 |
| 定义关键字 | 使用abstract class进行声明 | 使用interface进行声明 |
| 组成 | 全局常量、全局变量、构造方法、抽象方法、普通方法 | 全局变量、抽象方法 |
| 权限 | 可以使用任何权限 | 只能使用public权限 |
| 关系 | 一个抽象类可以实现多个接口 | 接口不能继承抽象类，却可以继承多个接口 |
| 使用 | 子类使用extends | 子类使用implements |
| 设计模式 | 模板设计模式 | 工厂模式、代理模式 |
| 局限 | 一个子类只能继承一个抽象方法 | 一个子类可以实现多个接口 |
通过上面的分析可以得出结论：在开发之中，抽象类和接口实际上都是可以使用的，并且使用哪一个都没有明确的限制，可是抽象类有一个最大的缺点—一个子类只能够继承一个抽象类，存在单继承的局限，所以当遇到抽象类和接口都可以实现的情况下，优先考虑接口，避免单继承局限。
除了单继承的局限之外，实际上使用抽象类和接口都是类似的，但是在实际的开发中，抽象类的设计比接口的复杂。
