引言
接口和抽象类的概念不一样。接口是对动作的抽象,抽象类是对根源的抽象。抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。比如,男人,女人,这两个类,他们的抽象类是人。说明,他们都是人。人可以吃东西,狗也可以吃东西,你可以把“吃东西”定义成一个接口,然后让这些类去实现它.在高级语言上,一个类只能继承一个类。(正如人不可能同时是生物和非生物),但是可以实现多个接口(吃饭接口、走路接口)。第一点.接口是抽象类的变体,接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。第二点.接口可以多继承,抽象类不行第三点.接口定义方法,不能实现,而抽象类可以实现部分方法。第四点.接口中基本数据类型为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,我们还是要乖乖的这样做。
当然抽象类也可以这么用,但是因为一个类只能继承一个类,如果把抽象类拿来当接口用,那多态就是笑话了。
文章为作者独立观点,不代表 股票程序化软件自动交易接口观点