引言
接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类，他们的抽象类是人。说明，他们都是人。人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.在高级语言上，一个类只能继承一个类。(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。第一点．接口是抽象类的变体，接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。第二点．接口可以多继承，抽象类不行第三点．接口定义方法，不能实现，而抽象类可以实现部分方法。第四点．接口中基本数据类型为static而抽类象不是的。当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。
PS(一个类只能继承一个类)，类的单继承:
public class MyClassOne {
int len = 1 ;
}
public class MyClassTwo {
int len = 2 ;
}
//下面编译不过，去掉,MyClassTwo 编译过
public class MyClass extends MyClassOne, MyClassTwo{
public static void main(String args[]){
MyClass my = new MyClass();
System.out.println(my.len);
}
}
抽象类
有时候，我们可能想要构造一个很抽象的父类对象，它可能仅仅代表一个分类或抽象概念，它的实例没有任何意义，因此不希望它能被实例化。例如：有一个父类水果，它有几个子类苹果、“橘子、香蕉等。水果在这里仅仅只是作为一个分类，显然水果的实例没有什么意义。而水果类又要能被子类化，这就要求我们使用抽象类来解决这个问题。在java中，通过在class关键字前增加abstract修饰符，就可以将一个类定义成抽象类。抽象类不能被实例化。例如：定义抽象类水果
如果我们试用以下语句来获得一个实例，将无法编译成功。Fruitfruit=newFruit();//不能实例化而我们仍然可以构造水果类的子类，如：
这样就达到我们的目的了。->实例化抽象类除了能象普通类一样可以拥有一般的属性和方法，也可以拥有抽象方法。例如：抽象类形状拥有抽象方法draw()。
抽象方法与抽象的行为相对应，通常是这个行为对父对象没有意义，而子对象有具体动作。例如方法draw()对于类Shape没有意义，而类Shape的子类矩形的方法draw()可以有实际的动作，子类圆的方法draw()也可以有实际的动作。抽象类可以有抽象方法也可以没有抽象方法；但是如果一个类有抽象方法，那这个类只能定义为抽象类。如果按照以下代码类“形状”仍然拥有抽象方法draw()，但没有定义为抽象类，将会编译失败。
public class Shape { //只能定义为抽象类abstract
……
public abstract void draw();
……
}
抽象方法还有一个特点是，它强迫子类要么仍然保持抽象性，要么具体表现出这个方法的行为。这样也可以强化多态性。
abstract class B {
private String str;
public B(String a) {
System.out.println('父类已经实例化');
this.str=a;
System.out.println(str);
}
public abstract void play();
}
public class A {
public static void main(String[] args) {
B aa = new B('test') {
@Override
public void play() {
System.out.print('B play method');
}
};
aa.play();
}
}
输出父类已经实例化testBplaymethod
class Test extends B{
@Override
public void play() {
System.out.print('B play method');
}
}
B aa = new Test();
aa.play('test');
接口
java语言使用关键字interface定义一个接口。接口也是抽象对象，它甚至比抽象类更抽象。接口中的方法都是抽象方法(接口中一般只包含一组public抽象方法，且必须是公有抽象方法，但方法定义中publicabstract可省略，也可以包含public静态final数据)。一个接口可以继承其他接口(可多个)；一个类通过关键字implements声明要实现一个接口，并具体实现接口的方法。例如：有一个接口InterfaceA，
类ClassA实现接口InterfaceA。
public class ClassA implements InterfaceA {
public void methodA() {
System.out.println( 'methodA of ClassA implements InterfaceA' );
}
}
如果是抽象类实现一个接口，那么抽象类中可以不具体实现接口的方法，而由其子类去实现。抽象类ClassB实现接口InterfaceA，但是没有具体实现方法methodA()，
publicabstractclassClassBSimplementsInterfaceA{}//子类ClassBSub实现接口InterfaceA，但是没有具体实现方法methodA()，
public class ClassBSub implements InterfaceA{
public void methodA() {
System.out.println( 'methodA of ClassBSub the subclass of ClassB' );
}
}
接口继承
public interface Interface1 {
int len = 1 ;
void output();
}
public interface Interface2 {
int len = 2 ;
void output();
}
public interface Interface3 extends Interface1, Interface2 {
int len = 3 ;
@Override
void output();
}
public class InterfaceSub implements Interface1, Interface2 {
public void output() {
System.out.println('output in class interfaceTest.InterfaceSub.');
}
public void outputLen(int type) {
switch (type) {
case Interface1.len:
System.out.println('len of interfaceTest.Interface1=.' + type);
break;
case Interface2.len:
System.out.println('len of interfaceTest.Interface2=.' + type);
break;
case Interface3.len:
System.out.println('len of interfaceTest.Interface2=.' + type);
break;
}
}
public static void main(String[] args) {
InterfaceSub interfaceSub= new InterfaceSub();
// interfaceTest.Interface1 a = new interfaceTest.Interface1() {
// @Override
// public void output() {
interfaceTest.Interface1.len
// }
// };
interfaceSub.output();
interfaceSub.outputLen(1);
interfaceSub.outputLen(2);
interfaceSub.outputLen(3);
}
}
输出
output in class interfaceTest.InterfaceSub.
len of interfaceTest.Interface1=.1
len of interfaceTest.Interface2=.2
len of interfaceTest.Interface2=.3
区别
接口和抽象类显著的共同点是接口和抽象类都可以有抽象方法。
接口和抽象类的不同点
抽象类可以有实例变量，而接口不能拥有实例变量(接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的)，接口中的变量都是静态的常量。(首先接口是一种高度抽象的'模版'，,而接口中的属性也就是’模版’的成员，就应当是所有实现'模版'的实现类的共有特性，所以它是public的,是所有实现类共有的.否则具体实现类不能使用该变量，则就没有了定义的意义,一个既是static又是final的字段表示只占据一段不能改变的存储空间)抽象类可以有非抽象方法，而接口只能有抽象方法(publicabstract默认省略)。抽象的子类可以选择性实现其基类的抽象方法,而接口的子类必须实现
java允许一个接口继承多个父接口，也允许一个类实现多个接口，而这样的多继承有上面提到的缺点马？答案是没有，这是由接口的抽象性决定的。正如前面介绍的，在接口中不能有实例变量，只能有静态的常量，不能有具体的方法，只能有抽象方法，因此也就摒弃了多继承的缺点。对于一个类实现多个接口的情况，因为接口只有抽象方法，具体方法只能由实现接口的类实现，在调用的时候始终只会调用实现类的方法，因此不存在多继承的第二个缺点；而又因为接口只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。对于一个接口继承多个父接口的情况也一样不存在这些缺点。请看以下示例。接口A：
接口B：
接口InterfaceSub继承接口A和接口B：publicinterfaceInterfaceSubextendsInterfaceA,interfaceB{}
类Xyz实现接口InterfaceSub：
public class Xyz implements InterfaceSub {
public void output() {
System.out.println( 'output in class Xyz.' );
}
public void outputLen( int type) {
switch (type) {
case InterfaceA.len:
System.out.println( 'len of InterfaceA=.' +type);
break ;
case InterfaceB.len:
System.out.println( 'len of InterfaceB=.' +type);
break ;
}
}
public static void main(String[] args) {
Xyz xyz= new Xyz ();
xyz .output();
xyz .outputLen();
}
}
//或者
public class Xyz implements InterfaceA,InterfaceB {
...
}
以上代码不存在什么问题，但是如果试编写以下存在冲突的代码，则会编译失败(根本就访问不了le。
疑问
Java实现接口必须重写其中全部的方法吗
抽象类可以不用,普通类必须全部重写。比如
public interface A {//定义一个接口
public void show();//定义一个接口方法
}
public abstract class AExtend implements A{
//抽象类实现接口A，但可以不实现show方法，由子类再去实现
}
Java接口对象=new实现类与实现类对象=new实现类区别
问题
为什么main函数中构造对象的时候是：UserServiceuserService=newUserServiceImpl();而不是UserServiceImpluserService=newUserServiceImpl();第二种可以的
接口的设计主要还是为了实现多态的。
你这里觉得没区别是因为你只有一个UserServiceImpl实现类。假设我们还有类A，B，C，他们都具有共同的行为regist。假设我们还有个方法
当然如果不用interface，那么你可能要定义4个方法来应对我们不同的对象了
尽管他们方法体一样，要做的事一样。可是如果没有interface，我们还是要乖乖的这样做。
当然抽象类也可以这么用，但是因为一个类只能继承一个类，如果把抽象类拿来当接口用，那多态就是笑话了。
文章为作者独立观点，不代表观点
相关文章
股民评论