接口和抽象类的概念不一样。接口是对动作的抽象,抽象类是对根源的抽象。
抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。比如,男人,女人,这两个类(如果是类的话……),他们的抽象类是人。说明,他们都是人。
人可以吃东西,狗也可以吃东西,你可以把“吃东西”定义成一个接口,然后让这些类去实现它(类实现多个接口,实现多个动作).
所以,在高级语言上,一个类只能继承一个类(抽象类,java类的单继承,接口可以多继承)。(正如人不可能同时是生物和非生物),但是可以实现多个接口(吃饭接口、走路接口)。
第一点.接口是抽象类的变体,接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。
第二点. 接口可以多继承,抽象类不行
第三点. 接口定义方法,不能实现,而抽象类可以实现部分方法。
第四点. 接口中基本数据类型为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); } }
抽象类
有时候,我们可能想要构造一个很抽象的父类对象,它可能仅仅代表一个分类或抽象概念,它的实例没有任何意义,因此不希望它能被实例化。例如:有一个父类 水果(Fruit),它有几个子类苹果(Apple)、“橘子(Orange)、香蕉(Banana)等。水果在这里仅仅只是作为一个分类, 显然水果的实例没有什么意义(就好像一个人如果告诉你他买了一些水果但是却不告诉你是苹果还是橘子,你很难想象他到底买的是什么。)。而水果类又要能被子 类化,这就要求我们使用抽象类(abstract)来解决这个问题。
在java中,通过在class关键字前增加abstract修饰符,就可以将一个类定义成抽象类。抽象类不能被实例化。例如:
定义抽象类水果(Fruit)
public abstract class Fruit { …… }
如果我们试图用以下语句来获得一个实例,将无法编译成功。
Fruit fruit = new Fruit(); // 不能实例化
而我们仍然可以构造水果类的子类,如:
public class Apple extends Fruit { …… } // 子类 橘子(Orange) public class Orange extends Fruit { …… }
这样就达到我们的目的了。 ->实例化
抽象类除了能象普通类一样可以拥有一般的属性和方法,也可以拥有抽象方法(abstract method)。例如:
抽象类 形状(Shape)拥有抽象方法draw()。
public abstract class Shape { …… public abstract void draw(); …… }
抽象方法与抽象的行为相对应,通常是这个行为对父对象没有意义,而子对象有具体动作。例如方法draw()对于类Shape没有意义,而类 Shape的子类矩形(Rectangle)的方法draw()可以有实际的动作(根据矩形的四个顶点画出矩形的四个边),子类圆(Circle)的方法 draw()也可以有实际的动作(根据圆心和半径画出圆周)。
抽象类可以有抽象方法也可以没有抽象方法;但是如果一个类有抽象方法,那这个类只能定义为抽象类。
如果按照以下代码类“形状(Shape)”仍然拥有抽象方法draw(),但没有定义为抽象类,将会编译失败。
public class Shape { //只能定义为抽象类abstract …… public abstract void draw(); …… }
抽象方法还有一个特点是,它强迫子类要么仍然保持抽象性(即不具体实现该方法并仍然定义为抽象类),要么具体表现出这个方法的行为(实现具体的动作或者通过抛出UnsupportedOperationException异常来表明不支持该行为)。这样也可以强化多态性。

匿名内部类实例化

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(); } }
输出
父类已经实例化
test
B play method
抽象类的确不能实例化。
这种格式(new TestAbs(){要重写的方法})叫匿名内部类,实际上是实例化一个它的子类。其实就相当于下面这样,只是匿名不匿名的区别。
class Test extends B{ @Override public void play() { System.out.print("B play method"); } } B aa = new Test(); aa.play("test");
接口
java语言使用关键字interface定义一个接口。接口也是抽象对象,它甚至比抽象类更抽象。接口中的方法都是抽象方法(接口中一般只包含一组public抽象方法,且必须是公有抽象方法,但方法定义中public abstract可省略,也可以包含public 静态final数据)。
一个接口可以继承其他接口(可多个);一个类通过关键字implements声明要实现一个接口,并具体实现接口的方法。
例如:有一个接口InterfaceA,
public interface InterfaceA { void methodA(); }
类ClassA实现接口InterfaceA。
public class ClassA implements InterfaceA { public void methodA() { System.out.println( "methodA of ClassA implements InterfaceA" ); } }
如果是抽象类实现一个接口,那么抽象类中可以不具体实现接口的方法(保持其抽象性),而由其子类去实现。
抽象类ClassB实现接口InterfaceA,但是没有具体实现方法methodA(),
public abstract class ClassBS implements InterfaceA{ }
//子类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
区别
接口和抽象类显著的共同点是接口和抽象类都可以有抽象方法。

接口和抽象类的不同点

(1)抽象类可以有实例变量,而接口不能拥有实例变量(接口是公开的,里面不能有私有的方法或变量,是用于让别人使用的,而抽象类是可以有私有方法或私有变量的),接口中的变量都是静态的常量(public static final)。 (首先接口是一种高度抽象的"模版",,而接口中的属性也就是’模版’的成员,就应当是所有实现"模版"的实现类的共有特性,所以它是public 的 ,是所有实现类共有的 .否则具体实现类不能使用该变量,则就没有了定义的意义,一个既是static又是final的字段表示只占据一段不能改变的存储空间)
(2)抽象类可以有非抽象方法,而接口只能有抽象方法(public abstract 默认省略)。
(3)抽象的子类可以选择性实现其基类的抽象方法,而接口的子类必须实现
java允许一个接口继承(extend)多个父接口,也允许一个类实现多个接口,而这样的多继承有上面提到的缺点马? (类单继承,接口多继承)
答案是没有,这是由接口的抽象性决定的。
正如前面介绍的,在接口中不能有实例变量,只能有静态的常量,不能有具体的方法(包含方法体),只能有抽象方法,因此也就摒弃了多继承的缺点。
对于一个类实现多个接口的情况,因为接口只有抽象方法,具体方法只能由实现接口的类实现,在调用的时候始终只会调用实现类的方法(不存在歧义), 因此不存在多继承的第二个缺点;而又因为接口只有静态的常量,但是由于静态变量是在编译期决定调用关系的,即使存在一定的冲突也会在编译时提示出错;而引 用静态变量一般直接使用类名或接口名,从而避免产生歧义,因此也不存在多继承的第一个缺点。
对于一个接口继承多个父接口的情况也一样不存在这些缺点。
请看以下示例。
接口A:
public interface InterfaceA { int len = 1 ; void output(); }
接口B:
public interface InterfaceB { int len = 2 ; void output(); }
接口InterfaceSub继承接口A和接口B:
public interface InterfaceSub extends InterfaceA, 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 { ... }
以上代码不存在什么问题,但是如果试图编写以下存在冲突的代码,则会编译失败(根本就访问不了len)。
Xyz xyz = new Xyz(); int len = xyz.len; System.out.println(len);
疑问

Java实现接口必须重写其中全部的方法吗

抽象类可以不用,普通类必须全部重写。
比如
public interface A {//定义一个接口 public void show();//定义一个接口方法 } public abstract class AExtend implements A{ //抽象类实现接口A,但可以不实现show方法,由子类再去实现 }

Java 接口 对象 = new 实现类 与 实现类 对象= new 实现类 区别

接口 : public interface UserService { // 注册 public void regist(); } 实现类: public class UserServiceImpl implements UserService { @Override public void regist() { System.out.println("区别"); } } main(){ UserService userService = new UserServiceImpl(); userService.regist(); } //匿名类 new接口 需要实现方法 UserService userService3 = new UserService() { @Override public void regist() { // you impl } };
问题
为什么main 函数中 构造对象的时候 是:
1) UserService userService = new UserServiceImpl(); 而不是
UserServiceImpl userService = new UserServiceImpl();第二种可以的
接口的设计主要还是为了实现多态的。
你这里觉得没区别是因为你只有一个UserServiceImpl实现类。
假设我们还有类A,B,C,他们都具有共同的行为regist。
假设我们还有个方法(其他变量使用do方法)
void do(UserService us){ //us.regist(); }
当然如果不用interface,那么你可能要定义4个方法来应对我们不同的对象了
void do(UserServiceImpl us){ //us.regist(); } void do(A us){ //us.regist(); } ...
尽管他们方法体一样,要做的事一样。可是如果没有interface,我们还是要乖乖的这样做。
当然抽象类也可以这么用,但是因为一个类只能继承一个类,如果把抽象类拿来当接口用,那多态就是笑话了。
参考:
http://zhidao.baidu.com/link?url=lvYrFKZHw0Uj4MLM56b1YCxUbJyPqPDQRhlBVOWBmMlHqwrax9VUYiDiO6dUZnLcb0AEP5BIbI0BsY_bWuBwM_
https://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html(匿名类小结)
有道云笔记链接可查看:IDEA中新建一个java类,无法实现Servlet接口或者继承HttpServlet类 问题描述: 新建一个java类,无法实现Servlet接口或者继承HttpServlet类 原因: 缺少tomcat的libraries(HttpServlet类...
问题描述:
新建一个java类,无法实现Servlet接口或者继承HttpServlet类
原因:
缺少tomcat的libraries(HttpServlet类或者Servlet接口对应位置在tomcat的lib中对应的jar包)
没有导入Servlet-api.jar包
解决方法:
添加servlet-api到自己的项目中,选中项目名,点OK即可
成功引入servlet-api.jar包后:
直接按住alt + enter键可以出来提示,要求实现Servlet中的五个抽象方法
泛型也可以继承和实现接口 public class Test{	public static void main(String[] args) {	} } class Father<T>{	} interface ARB<E>{	} class child<T,E&...
线程我只写过继承Thread类的,后来知道java多线程有三种方式,今天首先比较一下常用的继承Thread类和实现Runnable接口的区别。 按着Ctrl键进入Thread之后,发现Thread类也是Runnable接口的之类,这应该就是它们...
继承一般开发中用的会相比少一点,接口相比就应该会多一点.,接口主要是实现一种松耦合,便于以后的维护、升级,继承主要是提高代码的可重用性,很多东西都可以在父类中做好。子类可以直接用,用一句现在流行的话来说...
大家好,这是我的第一次写博客,主要是想记录自己的学习过程,话不多说,来聊一下Java中的类的继承与接口的实现个人理解。Java是面向对象的程序设计语言,所以我们经常要用到类。在类中经常被提到的就是类的继承,...
Java的接口有继承和实现两个概念,接口可以继承另一个接口,并获得其父接口里的所有方法和成员变量,接口也可以被一个类实现,实现接口的类需要实现接口及其父接口里的所有抽象方法,怎么理解呢? (1)如果...
**Java中接口与继承的区别 ** 在Java中,接口的实现和继承的实现很类似的,写法上是几乎是一致的,就是关键字这一部分...//实现接口一定要实现(重写)接口中所有的抽象方法 //实现接口(继承):implements //public cla
java中类实现接口用implements关键词,接口继承接口用extends关键词,那么可以用implements吗
类与类之间单根继承 使Java语言变得易于使用和简单, 如果一个类可以继承多个类,那么这个类所有成员变量名和方法名必须要不同(C++就是这样要求的).这是前提,我们必须确定这个才能用多重继承,如果在类方法名...