楼上的解释一下 interface A{} public class B implements A{ public static void main(String [] args){ A a = new B(); System.out.println(a.toString()); } } 为什么a可以调用toString()不会出错?既然它跟祖先类没有关系的话。很困扰啊!
使用instanceof()发现是true,说明应该还是继承关系即interface implementser Is a interface.
回复(特兰克斯):B是Object的子类,它也就拥有了toString()方法. 偶同意(地球是圆的)的说法:A a = new B() 也只是一个上溯造型引用的问题. a引用了B类的一个实例,所以也就拥有了toString()方法.偶也认为 接口和Object无血缘关系. OU LE.
上溯造型引用不是只能调用自己有的方法吗?如果我自己加一个方法是会报错的! interface A{} public class B implements A{ public void xxx(){} public static void main(String [] args){ A a = new B(); a.xxx(); System.out.println(a.toString()); } }
TO dwys0343(特兰克斯):多谢鼓励 ! 工作关系,我对聊天工具的使用很有限。CSDN 里会经常见到的,多多交流吧 :D
大家,快下班了,我说两句,对于 interface A{} public class B implements A{ public static void main(String [] args){ A a = new B(); System.out.println(a.toString()); } } 这个程序,为什么不会出错,并不是调用了接口a的toString()方法,而是调用了类B的toString()方法,所以大家不要误会,如果有怀疑,大家可以测试一下,将上面个程序改为如下: interface A{} public class B implements A{ public String toString(){ return "class B"; } public static void main(String [] args){ A a = new B(); System.out.println(a.toString()); } } 以上是我的一些理解
肯定是调用对象B的toString()方法啊!在Thinking in java 的多态性一章中说得很清楚,java方法的绑定是采用后绑定的,也就是运行时绑定,也叫动态绑定,也就是说运行时根据对象的类型来决定绑定哪个方法。除了static和final,java中所有的方法都是采用后绑定的。
changsoso: 你可以运行一下下面的小程序,就清楚了 class A{ public static void a(){ System.out.println("a"); } public void b(){ System.out.println("ab"); } } public class Example extends A{ public static void a(){ System.out.println("Example"); }
public void b(){ System.out.println("Examplebbbb"); }
public static void main(String [] args){ A b = new Example(); b.a(); b.b();
Example e=new Example(); e.a(); e.b(); } }
说一下我的理解:接口是对类的抽象,这一点相信大家是深信不疑的。 接口在抽象级别层次上高于所有类,因此接口在本质上不是类,而是对类的抽象。问题出在“向上转型”这个机制上。以楼主的这个例子来说,A是一个接口,而B是一个实现了接口A的类,B的实例a可以向上转型为Object,亦可以向上转型为A。实际上,一个接口不可能存在直接实例,任何一个接口类型的对象本质上都是Object类的实例。所以:new B()是一个B,也可以是一个Object,但从机制上看,它不可能是一个A(尽管从逻辑上可以这么说)。结论是:不存在一个纯粹的“接口的实例”!那么A a = new B();这种写法意味着什么呢?我觉得,这其实意味着将new B()向上转型为一个类,这个类的定义形于: public class Object implements A { }也就是说,A a = new B();这句将new B()转型为一个实现了接口A的Object。把一个实现了某接口的Object直接写为该接口,在Java中并不少见。比如定内部类的实例时,可以这样写: void f() { Comparable o = new Comparable() { public int compareTo(Object o) { } }; }这里的Comparable是一个接口,但是却可以定义接口的实例o,同样是这种制机,o在本质上是一个实现了Comparable的Object的实例。
总之:如果A是接口,那么把 A a = new B(); 理解为a是一个“A的实例”是不对的。不存在“A的实例”,只存在“实现了A的Object的实例”。
接口本身就是类,但他只能本继承和实现,本能被事例化,有点像虚拟类,但又不完全的是,比如你定义某些功能,但用户要实现这些功能的话,必须继承你的接口,并实现你的借口中定义的方法。 你说的A a = new B(); 其中A就是一个虚拟类而不是一个接口, 就像 List ab=new List();就不可以,因为它是虚拟类被能被事例化 而List ab= new ArrayList();就可以了 但List并不是一个接口欢迎java和jsp的爱好者加入! 共同探讨,共同进步 群号:8137004 有问题也欢迎到这里
to dwys0343(特兰克斯) : 法则1,java里所有对象都是Object的子类,能调用Object里定义的方法(相当于java世界的宪法,) 法则2,接口定义 约束对象不能调用接口里没有定义的方法(相当于java时间的基本法) A a = new B(); //a 是一个对象B,a 接受接口A的约束(a 由B自动向上转型为接口A) a.toString(); //违反法则2,符合法则1,根据宪法优于其他法原则,编译/运行通过
好吧,我不是说 new B()里面没有Object的方法,有,这是毋庸质疑的!只是说用A的引用调用有点不符合接口回调的定义。呵呵!知道就行了!这个贴现在没有讨论的价值了,再争下去没有任何意义了!知道就行了!大家再别回了啊!
感觉interface就是一种特殊的class
to dwys0343(特兰克斯):我在你那个贴子里有回复,去看看吧。
去看Sun的官方文档TJLS(The Java Language Specification)吧!其中第9章9.2节关于接口有这么一段话:If an interface has no direct superinterfaces, then the interface implicitly declares a public abstract member method m with signature s, return type r, and throws clause t corresponding to each public instance method m with signature s, return type r, and throws clause t declared in Object, unless a method with the same signature, same return type, and a compatible throws clause is explicitly declared by the interface. It is a compile-time error if the interface explicitly declares such a method m in the case where m is declared to be final in Object.楼上的老兄,谢了。研究得深入啊,这东西还看!^-^
不过他与类的区分还是很明显的——不能实例化
他的精髓在于提供一些类共同的地方,而且能“多继承”
我们知道所谓对象其实是数据和方法的封装。接口的作用更多的是工程上的,一般上我们用他来封装通用的行为,来达到程序的多态。不必用object的观点来统一接口,在我的感觉中,继承简化对象结构,增加代码重用,接口抽象行为。
接口只是一个协议,如果你实现该接口,那么,你就必须实现该接口下所有的方法。
强烈关注中!!!
类的定义需要“实现”,接口的定义只需要“声明”;
类能实例化出一个对象,接口不能;
类只能单根继承,接口可以多根继承;
继承一个类,相当于借用了它已实现的功能,实现一个接口,相当于对外做了一个承诺;
…… 联系:类可以“实现”接口3. 接口是否具备类的特征 这要看你认为哪些是“类的特征”,hehe,比如,“编译后会生成一个 .class 文件”算不算特征……4. 接口是否是Object 不是。但可以用一个接口型的变量来引用一个对象,而且,被引用的对象,说到底,一定是一个 Object。
我觉得既然interface和class根本就不是一个单词。没道理理解为一种东西。
4接口是否Object?
既然不是类了,自然不可能跟祖先类有什么关系。
在引用上,接口很像是数据库中的视图,是一个虚的外表。不过在其他方面就不像了。
其他的楼上的说的挺多了。
楼主应该很郁闷接口这种无能的东西有什么用吧,如果稍微看一下设计模式,马上就会明白。实在是太有用了
interface A{}
public class B implements A{
public static void main(String [] args){
A a = new B();
System.out.println(a.toString());
}
}
为什么a可以调用toString()不会出错?既然它跟祖先类没有关系的话。很困扰啊!
偶同意(地球是圆的)的说法:A a = new B() 也只是一个上溯造型引用的问题.
a引用了B类的一个实例,所以也就拥有了toString()方法.偶也认为
接口和Object无血缘关系.
OU LE.
interface A{}
public class B implements A{
public void xxx(){}
public static void main(String [] args){
A a = new B();
a.xxx();
System.out.println(a.toString());
}
}
有人说是Class类的原因,我有点趋向于这种说法。
工作关系,我对聊天工具的使用很有限。CSDN 里会经常见到的,多多交流吧 :D
interface A{}
public class B implements A{
public static void main(String [] args){
A a = new B();
System.out.println(a.toString());
}
}
这个程序,为什么不会出错,并不是调用了接口a的toString()方法,而是调用了类B的toString()方法,所以大家不要误会,如果有怀疑,大家可以测试一下,将上面个程序改为如下:
interface A{}
public class B implements A{
public String toString(){
return "class B";
}
public static void main(String [] args){
A a = new B();
System.out.println(a.toString());
}
}
以上是我的一些理解
class A{
public static void a(){
System.out.println("a");
}
public void b(){
System.out.println("ab");
}
}
public class Example extends A{
public static void a(){
System.out.println("Example");
}
public void b(){
System.out.println("Examplebbbb");
}
public static void main(String [] args){
A b = new Example();
b.a();
b.b();
Example e=new Example();
e.a();
e.b();
}
}
接口在抽象级别层次上高于所有类,因此接口在本质上不是类,而是对类的抽象。问题出在“向上转型”这个机制上。以楼主的这个例子来说,A是一个接口,而B是一个实现了接口A的类,B的实例a可以向上转型为Object,亦可以向上转型为A。实际上,一个接口不可能存在直接实例,任何一个接口类型的对象本质上都是Object类的实例。所以:new B()是一个B,也可以是一个Object,但从机制上看,它不可能是一个A(尽管从逻辑上可以这么说)。结论是:不存在一个纯粹的“接口的实例”!那么A a = new B();这种写法意味着什么呢?我觉得,这其实意味着将new B()向上转型为一个类,这个类的定义形于:
public class Object implements A { }也就是说,A a = new B();这句将new B()转型为一个实现了接口A的Object。把一个实现了某接口的Object直接写为该接口,在Java中并不少见。比如定内部类的实例时,可以这样写:
void f() {
Comparable o = new Comparable() {
public int compareTo(Object o) { }
};
}这里的Comparable是一个接口,但是却可以定义接口的实例o,同样是这种制机,o在本质上是一个实现了Comparable的Object的实例。
你说的A a = new B(); 其中A就是一个虚拟类而不是一个接口,
就像
List ab=new List();就不可以,因为它是虚拟类被能被事例化
而List ab= new ArrayList();就可以了
但List并不是一个接口欢迎java和jsp的爱好者加入!
共同探讨,共同进步
群号:8137004 有问题也欢迎到这里
Java 和 C++ 不一样, Java有一个共同的祖先在管理着,这一点比C++强.
Java接口 是通过 引用对象的祖先 来管理 实现所有对象的,下面有个例子.
不管结果是什么,编译过了是没错的.楼上的那位大哥:
从形式上,我们不妨把这种情况理解为 ((Object)intf).toString(),这就好比你定义一个 class 的时候,并没有把它写成 class MyClass extends Object,是一个道理。意思差不多!!!java 隐式地会把一个对象展化为 Object 为什么不能 在定义接口时,隐式地将其转化为Object的引用呢?如果 接口不能操作那些方法, 那会发生什么... ...interface A {
}public class B implements A {
public String reStr() {
return ("hello word.");
} public String toString() {
return ("look look...");
} public static void main(String[] args) throws Exception {
A a = new B();
System.out.println(); //能自动调用 Object的 toString()
//System.out.println(a.reStr()); //不能调用B自定义的方法.
a.equals(a);
a.wait();
a.notify();
}
}
接口中的方法 都是默认public性格的,所以实现它的儿子的那个方法也必须是public性格的。
接口中的属性都是 static final性格的在c++中的类可以多继承~它勤劳且朴素:又干活(方法)又下达指令(抽象)同时还负责财务(属性)~但任务多了~太多东西要管,而且自己家的东西可能别人家的起的名字一样,一不注意就分不清是谁家的 ......容易出乱子(具体出什么乱子-小弟才疏学浅-说不出=_=)java 为了避免类这个家伙惹是生非
把多继承的任务交给了接口
从此类专注于代码重用的工作(相对于类,当然不只)
而接口和抽象类的任务就是规范、约束、定义、模块连接提起继承
我们的第一反映往往子类重用父类的代码
但接口确实不具有这个功能,它只会定规则,活都由实现它的孩子们干了,而且很严厉~不干不行~儿子不干只能轮为抽象类、或继承接口~让他们的后代干~活总是要有人干得(否则接口会没有面子~失去意义~但以后很有可能有一个孩子能够实现它的志愿)~实现接口愿望的孩子成为了实实在在的类。
接口和抽象类的脾气不一样~但配合起来到得心应手~双剑合璧(但有些是面子上的事~骗编译器的~~使用api常套用这样的小把戏)
这个都没搞清还自称“EJB冠军”
接口当然是类,interface关键字就是指定一个类去做什么,而不是怎么做。它是一种抽象类,当然具有类的特征,但接口不能被实例化。类的实例才可以称为Object,接口当然不是。
但接口不像其他的类,直接或间接的继承了Object的方法啊!接口里面好像没有Object的方法哦!
这个问题我觉得没有必要再讨论下去了!大家都知道怎么用就行了!希望大家学习和工作顺利!
法则1,java里所有对象都是Object的子类,能调用Object里定义的方法(相当于java世界的宪法,)
法则2,接口定义 约束对象不能调用接口里没有定义的方法(相当于java时间的基本法)
A a = new B();
//a 是一个对象B,a 接受接口A的约束(a 由B自动向上转型为接口A)
a.toString();
//违反法则2,符合法则1,根据宪法优于其他法原则,编译/运行通过
----------------------------------------
标题:29号JAVA讲座 还有MP4等你拿
----------------
29号有个全天免费的JAVA/J2EE技术讲座,
时间:7月29日(周六)上午10:00 –下午 17:00
9:50签到入场 领抽奖牌 讲座时间 讲座内容
10:00 - 11:00 软件行业分析和JAVA软件工程师职业规划
11:00 - 12:00 JAVA技术核心概要与学习方法
13:00 - 15:00 J2EE企业级案例架构剖析
15:00 - 17:00 JAVA/J2EE案例动手实验 现场礼品:
一等奖 现场抽取128M MP4 一个 二等奖 光电鼠标一套 地点是 :北京市海淀区长春桥路11号万柳亿城大厦C1座17层
有谁去快报名哦 详情访问
http://news.csdn.net/n/20060721/92853.html ----
2006-07-24 14:18:32
法则1,java里所有对象都是Object的子类,能调用Object里定义的方法(相当于java世界的宪法,)
法则2,接口定义 约束对象不能调用接口里没有定义的方法(相当于java时间的基本法)
A a = new B();
//a 是一个对象B,a 接受接口A的约束(a 由B自动向上转型为接口A)
a.toString();
//违反法则2,符合法则1,根据宪法优于其他法原则,编译/运行通过有见地!!!
顶!
declares a public abstract member method m with signature s, return type r,
and throws clause t corresponding to each public instance method m with
signature s, return type r, and throws clause t declared in Object, unless a
method with the same signature, same return type, and a compatible throws
clause is explicitly declared by the interface. It is a compile-time error if the
interface explicitly declares such a method m in the case where m is declared to
be final in Object.楼上的老兄,谢了。研究得深入啊,这东西还看!^-^
------------------------------
这并不能证明借口就是类,恰恰相反,如果我们了解一下class file的结构就会发现:
.class中对interface和class作了非常明确的区分。一个.class文件中有一个access_flags,如果这个标志设置为:ACC_INTERFACE ,则这个文件就是interface,否则就是class。
class MyClass extends java.lang.Object {} //编译通过
interface MyInterface extends java.lang.Object {} //编译出错
如果interface是一个类,那么也应该继承自java.lang.Object这个类的老祖宗。
可以这样理解:
A a代表a可以实现A的所有功能,或者说的正式一点,a实现了接口A
java是单一继承的,如果没有接口,类之间只有树状结构,例如
车-四轮车-轿车
-二轮车-摩托车
此时,轿车和摩托车的关系只能追溯到"车"了
如果没有接口,对于"机动车"这个概念,只能定义为类,是"车"的子类,
轿车和摩托车因为java的单一继承,是无法再继承到"机动车"类下的
这就是有根树的结构的缺陷
对于接口,我觉得可以看作是"功能",类看作是"物体"
A a=new B()
表示a是B类的"物体",但是又有A的"功能"
因为Interface本质上来说是一个虚指针方法列表的首地址,而一个对象如果实现了一个接口,在内存中就有一段地址存放这些虚函数的首指针的列表,但是通过这个接口实例可以访问的偏移是受限的,受限大小:是接口的定义还有接口所继承的接口方法个数,也就是说他只能访问这一些函数。