JAVA中为什么会有extends和implements 两个关键字
解决方案 »
- socket 请求问题!?
- 读着没有发现问题,可是编译不了,不知道哪错了,求解。
- 疑难 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- ## JDK6.0 对国际化域名的支持 IDN ,www.xn--3et971b.com 代表什么域名 ##
- java可以做spss的二次开发么?多谢!急啊!!!
- 请问我的笔记本是酷睿双核的,下载了几个J2SE的平台都不能用,有哪位高手能帮忙解决吗?
- 知道这里高手比较多,问一个也许不一定用java做的问题。做一个监控程序,如何让程序判断电脑正在访问什么网站,并且使用户该网站访问不了
- 中国人应该反思一下了。。。 我们是个强大的民族,我们应该很强大。。。
- 回文数猜想
- 刚开始学就遇到难提----50
- 五子棋ai算法 求高手帮忙看懂
- 求解JAVA高手!!JDK 1.4 和 1.6 SWING 的字体显示。。在线等。。。
子--父
类--类 extends
类-- 接口 implements
接口-类 N/A
接口-接口 extends
一个类只能继承一个,即单继承。但可以实现多个。
不错
继承只能继承一种,实现能实现多个。两种互相补充才能更好的实现多重继承。
extends 用来描述"is a"的关系
implements 用来描述"like a"的关系
implements java中是实现接口的意思,是为了弥补java类不能直接实现多继承的缺陷,实现程序运行时的多态(多态:一般是根据传入的参数的类型决定执行哪个类或子类的方法)
implements-实现 需要自己去实现方法才能去用。 就像我这样的平头老百姓,自己的目标,需要自己努力去实现。
区别与联系
1、 组成:
抽象类:抽象方法、普通方法、常量、变量、构造方法、全局常量,所以说抽
象类只比普通类多了一个抽象方法;
接口:抽象方法和全局常量;
此处需要注意:抽象类的抽象方法必须加入abstract关键字进行修饰,而接口不需要,因为接口总默认的方法都是抽象的,默认的常量都是全局常量;
2、 定义:
抽象类:abstract;
接口:interface;
3、 子类:
子类通过extends继承抽象类;
子类通过implements实现接口;
4、 限制:
一个子类只能继承一个抽象类;
但一个子类可以同时实现都个接口
5、 关系:
一个抽象类可以实现多个接口,但是一个接口不能继承一个抽象类只能实现多个接口;
一个抽象类可以包含多个接口,一个接口中可以包含多个抽象类;
6、 设计模式:
抽象类;模版设计
接口:工厂设计、代理设计
两个在一起操作可以完成适配器设计
7、 实例化:
都是通过对象的多态性,通过子类进行对象的实例化操作;
8、 实现限制:
抽象类:存在单继承的局限性;
接口:不存在此局限性;
9、 特性:
接口:表示一个标准、一种能力;
接口(inteface):接口被用来建立类与类之间关联的标准;
抽象类(abstract class):只要类中有抽象方法,此类就被称为抽象类,而我认为,抽象类除了被继承之外,没有任何意义;
所以,综上所述:如果接口和抽象类可以同时使用的话,则优先选择接口,这样可以通过接口避免了单继承的局限性;
适配器设计模式:
将两个不兼容的类纠结在一起使用,属于结构型模式,需要有Adaptee(被适配者)和Adaptor(适配器)两个身份,例如如果我们将两个没有关系的类组合在一起使用, 此时我们可以修改各自类的接口,但是如果我们没有接口的源码,或者说,我们不愿意为了一个应用程序来修改各自的接口,这时我们就可以使用实现Adapter方式(使用Adapter,在这两个接口之间创建一个混合接口):
范例:假设我们现在要打桩,有两种类:方形桩和圆形桩;
方形桩:
public class SquarePeg{
public void insert(String str){
System.out.println("SquarePeg insert():"+str);
}
}
圆形桩:
public class RoundPeg{
public void insertIntohole(String msg){
System.out.println("RoundPeg insertIntoHole():"+msg);
}
}
Now,有一个应用,需要既要打印圆形桩又要打印方形桩,那么我们需要将这两个没有关系的类综合应用.假设RoundPeg我们没有源代码,或源代码我们不想修改,那么我们使用Adapter来实现这个应用:
public class PegAdapter extends SquarePeg{
private RoundPeg roundPeg;
public PegAdapter(RoundPeg peg)(this.roundPeg=peg;)
public void insert(String str){ roundPeg.insertIntoHole(str);
}
}
在上面代码中,RoundPeg属于Adaptee,是被适配者.PegAdapter是Adapter,将Adaptee(被适配者RoundPeg)和Target(目标SquarePeg)进行适配.实际上这是将组合方法(composition)和继承(inheritance)方法综合运用.
PegAdapter首先继承SquarePeg,然后使用new的组合生成对象方式,生成RoundPeg的对象roundPeg,再重载父类insert()方法。从这里,你也了解使用new生成对象和使用extends继承生成对象的不同(new生成的是一个新的一模一样的对象,extends继承了属性 生成的对象可以对属性进行修改),前者无需对原来的类修改,甚至无需要知道其内部结构和源代码.
如果你有些Java使用的经验,已经发现,这种模式经常使用。进一步使用上面的PegAdapter是继承了SquarePeg,如果我们需要两边继承,即继承SquarePeg 又继承RoundPeg,因为Java中不允许多继承,但是我们可以实现(implements)两个接口(interface)
public interface IRoundPeg{
public void insertIntoHole(String msg);
}
public interface ISquarePeg{
public void insert(String str);
}
下面是新的RoundPeg 和SquarePeg, 除了实现接口这一区别,和上面的没什么区别。
public class SquarePeg implements ISquarePeg{
public void insert(String str){
System.out.println("SquarePeg insert():"+str);
}
}
public class RoundPeg implements IRoundPeg{
public void insertIntohole(String msg){
System.out.println("RoundPeg insertIntoHole():"+msg);
}
}
下面是新的PegAdapter,叫做two-way adapter:
public class PegAdapter implements IRoundPeg,ISquarePeg{
private RoundPeg roundPeg;
private SquarePeg squarePeg;
// 构造方法
public PegAdapter(RoundPeg peg){this.roundPeg=peg;}
// 构造方法
public PegAdapter(SquarePeg peg)(this.squarePeg=peg;)
public void insert(String str){ roundPeg.insertIntoHole(str);}
}
还有一种叫Pluggable Adapters,可以动态的获取几个adapters中一个。使用Reflection技术,可以动态的发现类中的Public方法。
代理设计模式:
接口:
public interface IGive {
public void giveMoney();
}
代理:
package org.lxh.proxydesignmodedemo;
public class ProxyGive implements IGive {
private IGive give = null;
public ProxyGive(IGive give) {// 讨债对象
this.give = give;
}
public void before() {
System.out.println("准备:刀、绳子、枪、斧子、、、、、");
}
public void giveMoney() {
this.before();
this.give.giveMoney();
this.after();
}
public void after() {
System.out.println("销毁所有证据!!!!!!!!");
}
}
真正的实体:
package org.lxh.proxydesignmodedemo;
public class RealGive implements IGive {
public void giveMoney() {
System.out.println("把钱还给我!!!!");
}
}
测试:
package org.lxh.proxydesignmodedemo;
public class ProxyDesignDemo {
public static void main(String args[]) {
IGive give = new ProxyGive(new RealGive());
give.giveMoney();
}
}
工厂设计模式:
接口:
package org.lxh.factorydesignmodedemo;
public interface IFruit {
public void eat();
}
实体1:
package org.lxh.factorydesignmodedemo;
public class Orange implements IFruit {
public void eat() {
System.out.println("吃橘子!!!!!");
}
}
实体2:
package org.lxh.factorydesignmodedemo;
public class Apple implements IFruit {
public void eat() {
System.out.println("吃苹果!!!!!");
}
}
工厂:
package org.lxh.factorydesignmodedemo;
public class Factory {
public static IFruit getFruit(String className) {
IFruit f = null;
if ("Apple".equals(className)) {
f = new Apple();
}
if ("Orange".equals(className)) {
f = new Orange();
}
return f;
}
}
测试:
package org.lxh.factorydesignmodedemo;
public class FactoryDesignDemo {
public static void main(String args[]) {
IFruit f = Factory.getFruit("Apple");
if (f != null)
f.eat();
else {
System.out.println("没有任何有效的东西可吃的!!!!!!!!");
}
}
}
接口是公开的(public)里面不能有私有的方法和变量,是让别人使用的,实现接口的类一定要实现接口里定义的所有方法,而对于抽象类,里面可以有私有方法或私有变量,实现抽象类的类可以有选择的重写需要用到的方法,但是必须实现里面所有的抽象方法;