Question

求详解java中的接口与多态

Answer 1

多态是面向对象的核心之一，面向接口编程也是以面向对象编程为核心。
接口就是一种规范，我们平时编程要融入生活，比如说电脑的主板，上面有很多接口，插CPU得接口只要插上CPU就可以工作，不管它是哪个厂家生产的CPU，不管它内部如何工作，只要是CPU就可以用。好比你写个接口，里面有个fly方法，实现此接口的类都要实现这个方法，至于你如何飞是你的问题，不管你用翅膀飞，还是骑扫把飞，只要实现’fly飞‘就可以。
上面是让你将编程融入生活，说说编程的东西。
多态就是父类或者接口的引用指向子类的对象的情况。比如child类 extends Fahter类
那么可以Father f=new Child(); 如果一段代码可以用父类运行，当换成子类时，功能不变，那么就是多态。多态主要一定要记得两段话，编译时看引用，运行时看对象。这句话的意思是在IDE编译阶段，你用f点出来的方法(f.这里会提示Father类有得实例方法)都是Fahter类自己有得，而Child类里自己有得方法不会被自动提示出来。但是如果子类重写父类的方法了（重写：就是子类定义了一个与父类一模一样的方法，只是方法体不同），运行时还要看后面new出来的是谁，new Child();那么执行要执行Child类重写的方法体，这样做的好处是我可以在一个方法里写f.fly();（比如Father和Child都有fly方法）
public void test(Father f){
f.fly();
} 在这样的代码下 我里面代码不用动，但是可以让f.fly()效果不同，因为我传进去的子类对象可以不同，比如test(new Child1()); test(new Child2()); test(new Child3());然而这三个子类里面的fly都有自己的具体实现，这就是多态的表现，同一个引用调用同一个方法而表现出多种状态。接口换成父类是一样的。 再有不懂得地方追问。 呵呵

Answer 2

面向对象的特征:抽象、封装、继承、多态。
抽象类:本身就是一个java类,可以被继承的需要abstract来修饰的,不能private ,可以 定义了一些抽象的方法. 但抽象类的方法可以是抽象也可以不是抽象的.
抽象类不能被实例化.
抽象方法:1.需要关键字 abstract 来修饰的方法
2.方法本身没有方法体.
3.子类必须重写该方法.
4不能被实例化

接口是高度抽象的抽象类：
1所有方法都没有方法体inplements
2方法默认的都是抽象的都是 public的
3 在接口里定义的变量都默认是final的
4完成Java里多重继承
5接口不能被实例化

抽象类跟接口的区别
1抽象类的成员可以具有访问级别,而接口的成员全部public级别
2抽象类可以包含字段,而接口不可以,
3抽象类可以继承接口,而接口不能继承抽象类
4抽象类的成员可以具有具体实现,而接口不行
5抽象的子类可以选择性实现其基类的抽象方法,而接口的子类必须实现

多态性
关于java的多态，有的书上是这样讲的，java的多态分成静态的多态，和动态的多态，而所谓静态的多态就是只函数的重载，动态的多态就是方法的覆写。
如下面：
class Test
{
void print()
{
System.out.println("hello world");
}
void print(int x)
{
System.out.println("hello world"+i);
}
public static void main(String []args)
{
Test ts=new Test();
ts.print();
ts.print(10);
}
}
/*
上面的程序就是在一个类中成员方法的重载例子。也就是一个静态的多态性。系统会在你编译的时候根据你调用的方法的参数列表来动态的决定调用那一个函数。
*/

动态的多态：

class Test
{
void print()
{
System.out.println("hello Test");
}
public static void main(String []args)
{
A a=new A();
a.print();
}
}

class A extends Test
{
void print()
{
System.out.println("hello A");
}
}

/*
这时由于子类覆写了父类的方法，所以调用的是子类覆写后的方法。
这是动态的多态。
*/

是把一个子类的实例赋值给一个父类的问题，请看下面的程序：
class A
{
void print(){}
public static void main(String []args)
{
A [] a=new A[3];
a[0]=new B();
a[1]=new C();
a[2]=new D();
for(int i=0;i<a.length;i++)
{
a[i].print();
}
}
}

class B extends A
{
void print()
{
System.out.println("hello B");
}
}

class C extends A
{
void print()
{
System.out.println("hello C");
}
}

class D extends A
{
void print()
{
System.out.println("hello D");
}
}

/*
上面的程序执行的结果：
hello B
hello C
hello D

可以看出，程序不会调用父类的print()方法,再说父类print()方法根本什么也不做。这就是JVM (java虚拟机),能在程序运行时，动态的识别变量的类型。就像上面一样。这主要是靠java的运行时的类型识别机制实现的，当然我认为这其实也可以看成是java多态的一种表现。
*/

在java中子类是父类的实例，这就像是说 鱼是动物。但不能说动物就一定是鱼，这也是符合了人们对现实世界的认识规律。另外java为我们提供了一个关键字，在孙鑫的教程里面也讲到了吧。它是instanceof
你可以用这来判断一个对象是否是一个类的实例。还是上面的A ,B,C ,D类的例子：
在mian函数中写上下面的代码：(把原来的代码删掉)
B b=new B();
if(b instanceof A)
System.out.println("b instanceof A");
//输出：b instanceof A

说明b是A类的实例。

再看下面的例子。
A a=new B();
if(a instanceof B)
System.out.println("a instanceof B");

//输出：a instanceof B
但此时不能这样，B b=a;
虽然a是B的实例但是这里不能这样赋值，要像下面：
B b=(B)a;
//进行类型的强制转换

Answer 3

接口是用来实现不同对象的不同行为方式，然后在调用时，动态的根据对象的不同，表现不同的行为，即面向接口编程，另外在设计接口的时候也要遵循低耦合，高聚合的原则
多态是父类与子类之间行为的复用与扩展，这是面向对象编程的基础概念

Answer 4

接口仅仅是多态的一个产物而已

=============================
如果一定要选择的话，我会选第一句的，至少它意思表达到了，而第二句就太偏了，多态并不意味着接口，但接口意味着多台，可以这么理解的