abstract class和interface有什么区别?！！！

1、一个类可以实现任意多个接口，但它最多只能作为一个抽象类的子类。

2、一个抽象类可以含有若干个非抽象方法，它通常是模板方法模式的一个实例。而一个接口的所有方法都是抽象的，无论是否将它的方法显示地声明为抽象的。

3、一个抽象类可以声明实例变量，其子类可以继承这些实例变量。而一个接口不能声明实例变量，不过接口可以声明static final修饰的域。

4、一个抽象类可以定义构造器方法，而接口不能。

5、一个抽象类的可见性修饰符可以是public、protected、private，或者无修饰符（表示包内可见）；而一个接口的可见性修饰符只能是public，或者无修饰符（表示包内可见）。

6、一个抽象类的方法的可见性修饰符可以是protected、private，或者无修饰符（表示包内可见）；而一个接口的方法的可见性修饰符只能是public。

7、一个抽象类是从Object类派生而来，它继承了Object类的clone()方法和equals()方法。


java中私有方法与抽象方法的区别?抽象类与接口的区别?数据类型间的转换有哪些方法?
私有方法：
    顾名思义，简单理解就是只有“自己”才能使用的方法。
    例如有一个类Test如下：
    class Test(){
        private Test(){
            //这个构造方法是私有方法
        }
    }

    那么在其它类中，如果有代码这么写
    Test test = new Test();
    那么就会报错，因为Test()这个构造方法是Test类私有的，别的类不可以调用，只有Test类自身中的代码才可以访问它。


抽象方法：
    抽象方法是只有方法名、参数等等，而没有实际的方法体的方法。
    例如有这样一个接口Demo：
    interface Demo{
        public boolean func(Map param);
    }

    其中的func方法就是抽象方法。和普通方法比较，可以看出它也可以有参数，有返回值，但是它没有方法体，就是说这个方法具体做些什么并没有定义。这样做的好处是可以让需要实现它的类根据自身的需要自己去“补充”具体的实现代码。抽象方法往往在多态中使用。


抽象类与接口：
    抽象类当中至少有一个抽象方法，当然，它可以有已经实现的方法；而接口中不能包含有方法体（就是已经实现）的方法，例如上面的Demo接口。类继承一个接口，那么它仍然是个接口。


数据类型转换：
    Java对基本数据类型做了封装，例如int有封装类Integer，boolean有Boolean等等，在封装类中都有转换类型的方法。例如：
    Integer.valueOf(String s)
    它尝试将一个字符串转换为Integer。例如将"123456"转换成整型对象123456。

    如果是基本数据类型之间的转换，可以试一试强制类型转换。
    例如：将浮点型float转为双精度型double
    float flo = 1.02f;
    double dou = (double)flo;

区别主要有：
1.抽象类中可以有普通成员变量，而接口中不能有普通成员变量。
2.抽象类中可以同时包含抽象方法和非抽象方法，而接口中全部是抽象方法
3.抽象类中可以有静态方法，接口中不能有静态方法。
4.一个类只能继承一个抽象类，但可以实现多个接口。
5.抽象类中可以有构造方法，接口中不能有构造方法。
6.抽象类中可以有静态成员变量，而且访问类型是任意的，而接口中比为public static final类型，缺了自动补全。

1.interface被继承时用的关键字是implements，而且可以同时implements多个interface，而abstract class被继承时用的关键字是extends，而且只能同时extends一个abstract class。
  2.interface内定义的方法都是public的，而abstract class内的则不一定。
  3.interface内定义的成员对象都是static & final的，而abstract class不是(一定不能是final)
   4.interface的方法不能有默认实现，只有一个声明，而abstract class内声明abstract的方法不能有实现，非声明abstract的方法可以有默认实现。
  5.interface被implements时，所有方法都必须被实现，必须申明是public的，而abstract class被extends时只有abstract的方法才必须被实现，别的有默认实现的直接被继承过来。

注：不能创建接口或抽象类的实例。

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

abatract class 基本功能定义在类中，用来继承。
interface 扩展功能定义在接口中，用来实现。
继承抽象类，实现接口。
继承抽象类是单继承，
实现接口可以实现多个接口。
抽象类对其所有子类提供通用的已实现功能；接口则是定义大范围内相互各异的对象间可共用的功能
简单理解：抽象类是特殊的类，接口是提供功能的，这样虽然片面但是直接。
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected的，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
综合了以前的帖子加自己的理解

1) 抽象方法，只有行为的概念，没有具体的行为实现。使用：abstract 关键字修饰，并且没有方法体。
2) 包含抽象方法的类，就一定是抽象类。使用： abstract 关键字修饰，包含抽象方法。
3) 抽象类不能直接创建实例。可以定义引用变量。
4) 抽象类只能被继承，一个具体类继承一个抽象类，必须实现所有抽象方法。  
5) 抽象方法和抽象类非常适合作为系统的分析和设计的工具。
接口：
1 接口：全部的方法都是抽象方法，全部的属性都是常量。接口用来表示纯抽象概念，没有任何具体的方法和属性。
2 不能实例化，可以定义变量。
3 接口变量可以引用具体实现类的实例。
4 接口只能被实现(继承)，一个具体类实现接口，必须使用全部的抽象方法。
5 接口之间可以继承。
6 一个具体类可以实现多个接口，实现多继承现象，表示：
7 接口中的属性，默认是常量 public static final
8 接中的方法一定是:public abstract
9 实现一个接口，使用关键字implements, 实现实际上是一种继承关系。接口和实现类是父子类型的关系

抽象类和接口的区别我可以给你讲个例子来说明：
有鸟、麻雀、飞机。
这三种事物都具有飞的功能，我们就可以定义飞的接口，让他们来实现，如果还有其他能飞的事物，就不用定义，直接实现飞的接口，方便功能扩展
麻雀是鸟的一种，可以继承鸟，我们可以把鸟定义成抽象类，鸟不用实例化，通过子类继承功能并实例化

Abstract class：
1.不能实例化；
2.一种继承关系，一个类只能使用一次继承关系。可以通过继承多个接口实现多重继承；
3.可有自己的数据成员；
4.方法可以私有，非abstract方法，必须实现；
5.变量可有私有，默认是friendly 型，其值可以在子类中重新定义，也可以重新赋值；
6.设计理念表示的是“is-a”关系
7.实现需要继承，要用extends。

Interface：
1.不能实例化；
2.一个类可以实现多个interface；
3.数据成语，静态的不能被修改即必须是static final，一般不在此定义；
4.方法不可有私有，默认是public，abstract 类型；
5.变量不可有私有，默认是public static final 型，且必须给其初值，实现类中不能重新定义，不能改变其值；
6.设计理念表示的是“like-a”关系；
7.实现要用implements。

abstract的特点：
      使用abstract修饰符修饰的类的话，那么该类中可以有抽象方法，也可以没有抽象方法，抽象方法都必须用publicl修饰，这是为了让子类能更好的去实现该类中的功能。注意:当类中没有一个抽象方法的时候，该类的意义仅仅是为了不让创建对象，用abstract修饰的类中，可以有成员变量，但是不能用该修饰符修饰成员变量。
interface的特点:
        interface与class是同等级的，我们知道类是用来描述事物的，所以从这里我们就可以推断该类的描述的事物可能是不具体的，只是知道他的大致规则，另外interface中不可以有成员变量，成员函数都必须用public来进行修饰，如果那个类要想使用该类，那就必须实现他，并且都要复写该类的所有方法

  1.abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。

　　2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。

　　3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。 这一点是区分什么时候用接口，什么时候用抽象类的最好判断依据。
      如：车，他的每一个子类都会拥有“轮子”这个属性，和“跑”这个方法。而且跑的方式都是一样的，就是通轮子过转动。所以这时最好把"车"定义为抽象类，这样它的子类就可以直接继承“跑”这个方法，减少代码重写。如果把“车”定义为接口，就需要在每一个子类里面定义相同的”跑“方法，显得冗余。由此可见，此时用抽象类更优。
          相反，如果子类里面的实现方法可能都不同时，使用接口就更好。当然使用接口能实现多继承，这是他最好的优点。　　
     4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

　　5.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

　　6.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

　　7.接口中的方法默认都是 public,abstract 类型的。

1、抽象类和接口都不能实例化。
2、抽象类可以声明抽象方法，也可以是具体的方法，还可以声明属性。接口是为了描述某些共同的行为而抽象出来的一个特殊的java类，使用interface修饰。接口解决了java单继承的限制，接口里的方法全部是抽象的：public abstract，接口里的属性必须为：public static final
3、类是对对象的抽象，抽象类是对类的抽象，接口则是对行为的抽象。
4、如果行为跨越了不同类的对象，可使用接口。对于一些相似的类对象，用继承抽象类。 如： 猫、狗可以继承动物类。飞机、麻雀、超人可以实现飞的接口。
5、从设计的角度讲，抽象类是从子类中发现公共的东西，泛化出父类，然后让子类继承。而接口不知道子类的存在，以及方法如何实现还不确定，只是预先定义。
6、从应用上接口主要是用来定义模块之间的通信契约，是一种标准。抽象类则是在代码实现上发挥作用，实现代码的重用。比如模板模式就是抽象类使用的典型实例。假如一个系统的所有servlet都是用一种方式实现记录日志、权限判断、异常处理，那么就可以定义一个抽象的基类，让所有的servlet都继承于这个基类。又比如用传统的MVC开发一个项目时数据库的映射是一项繁琐的工作，这时候就可以用模板模式来优化一下数据的映射。
摘自：http://bbs.itheima.com/forum.php?mod=viewthread&tid=1654

interface的所有方法都必须是抽象的，
而abstract类中方法可以不用被抽象

interface和abstract class都不能实例化