java抽象类的构造方法和普通类的构造方法一样
都是用来初始化类
只是抽象类的构造方法不能直接调用 因为抽象类不能实现实例
但是一旦一个普通类继承了抽象类 便也可以在构造函数中调用其抽象类的构造函数
也可以使用其方法
可以这么理解吧 抽象类就是一个不能实例化的不同类
不过如果方法加了abstract那么就必须在子类里面重写了
(1)Java中抽象类和接口中有构造方法吗?
①在接口中 不可以有构造方法
在接口里写入构造方法时，编译器提示：Interfaces cannot have constructors。
A. 构造方法用于初始化成员变量，但是接口成员变量是常量,无需修改。接口是一种规范，被调用时，主要关注的是里边的方法，而方法是不需要初始化的，
B. 类可以实现多个接口，若多个接口都有自己的构造器，则不好决定构造器链的调用次序
C. 构造器是属于类自己的，不能继承。因为是纯虚的，接口不需要构造器。
②在抽象类中 可以有构造方法。
在抽象类中可以有构造方法，只是不能直接创建抽象类的实例对象，但实例化子类的时候，就会初始化父类，不管父类是不是抽象类都会调用父类的构造方法，初始化一个类，先初始化父类。(2)补充：构造方法、抽象类、接口的定义：
①构造函数(构造器、构造函数)：构造函数是一种特殊的函数。其主要功能是用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
A.方法名与类名相同；
B.没有返回类型(例如return、void等)；
C.不能被static、final、native、abstract和synchronized修饰，不能被子类继承。
D.父类的构造方法不能被子类调用，可以通过super语句调用父类的构造方法。
E.构造方法可以重载，以参数的个数，类型，顺序，分为空参构造方法和有参构造方法。
②抽象类：使用了关键词abstract声明的类叫作“抽象类”。如果一个类里包含了一个或多个抽象方法，类就必须指定成abstract(抽象)。“抽象方法”,属于一种不完整的方法，只含有一个声明，没有方法主体。
注：
抽象类中不一定有抽象方法，抽象方法一定存在于抽象类中。
继承抽象类的可以是普通类，但必须重写抽象类中的所有抽象方法，也可以是抽象类，无需重写抽象类中的所有抽象方法。③接口：接口是一种规范，是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。
注：
可以说是一种特殊的抽象类，里面的方法全是抽象方法。
子类实现接口必须对接口中的方法全部重写。接口和抽象类的语法区别：
1)接口不能有构造方法，抽象类可以有。
2)接口不能有方法体，抽象类可以有。
3)接口不能有静态方法，抽象类可以有。
4)在接口中凡是变量必须是public static final，而在抽象类中没有要求。

可能好多学习编程的人想：方法的调用我还不会吗？

希望这篇博客能够给大家提供帮助，博客来源于Java核心技术(卷Ⅰ)

弄清楚如何在对象上应用方法调用非常重要。下面假设要调用 x.f(args，) 隐式参数 x 声明为类 C 的一个对象。下面是调用过程的详细描述：


编译器査看对象的声明类型和方法名。假设调用 x.f(param)， 且隐式参数 x 声明为 C类的对象。需要注意的是： 有可能存在多个名字为 f, 但参数类型不一样的方法。例如，可能存在方法 f(int) 和方法 f(String)。 编译器将会一一列举所有 C 类中名为 f 的方法和其超类中访问属性为 public 且名为 f 的方法（超类的私有方法不可访问）。
至此， 编译器已获得所有可能被调用的候选方法。


接下来，编译器将査看调用方法时提供的参数类型。如果在所有名为 f 的方法中存在一个与提供的参数类型完全匹配， 就选择这个方法。这个过程被称为重载解析（overloadingresolution)。 例如，对于调用 x.f(“ Hello” ）来说， 编译器将会挑选 f(String)， 而不是 f(int)。

由于允许类型转换（ int 可以转换成 double, Manager 可以转换Employee, 等等)， 所以这个过程可能很复杂。 如果编译器没有找到与参数类型匹配的方法， 或者发现经过类型转换后有多个方法与之匹配， 就会报告一个错误。
至此， 编译器已获得需要调用的方法名字和参数类型。


如果是 private 方法、 static 方法、 final 方法或者构造器， 那么编译器将可以准确地知道应该调用哪个方法， 我们将这种调用方式称为静态绑定（ static binding )。 与此对应的是，调用的方法依赖于隐式参数的实际类型， 并且在运行时实现动态绑定。在我们列举的示例中， 编译器采用动态绑定的方式生成一条调用 f(String) 的指令。


当程序运行，并且采用动态绑定调用方法时， 虚拟机一定调用与 x 所引用对象的实际类型最合适的那个类的方法。假设 x 的实际类型是 D，它是 C 类的子类。如果 D 类定义了方法 f(String)， 就直接调用它；否则， 将在 D 类的超类中寻找 f(String)， 以此类推。


说明：

每次调用方法都要进行搜索，时间开销相当大。因此， 虚拟机预先为每个类创建了一个方法表（ method table), 其中列出了所有方法的签名和实际调用的方法。这样一来，在真正调用方法的时候， 虚拟机仅查找这个表就行了。在前面的例子中， 虚拟机搜索 D 类的方法表， 以便寻找与调用 f(Sting) 相K配的方法。这个方法既有可能是 D.f(String), 也有可能是X.f(String), 这里的 X 是 D 的超类。这里需要提醒一点， 如果调用 super.f(param), 编译器将对隐式参数超类的方法表进行搜索。

我正在处理一个问题,我很困难,因为我刚刚开始学习
java.任何帮助我可以理解这将是巨大的.我必须编写一个有两个类的程序.主类将从一个文件中读取并使用第二个类来查找文件中重复的相同单词的次数,并将它们添加到一个数组中,该数组包含该单词重复的单词和次数.我可以阅读文件部分.我似乎不能包围我的头,如何从第二类调用一个方法,将单词添加到数组中并递增计数器.
这是我的代码到目前为止如果你运行它,你会看到我有多新的错误,你会得到新的.
import java.io.*;
public class Words{
public static void main (String [] args)
{
ProcessInput();
System.out.println("\nprogram finished");
}
public static WordList ProcessInput( )
{
BufferedReader inputFile;
String inputLine;
String[] word;
WordList words;
try
{
inputFile=new BufferedReader(new FileReader ("inputFile.txt"));
inputLine = inputFile.readLine();
while (inputLine !=null)
{
word=inputLine.toLowerCase().split(" ");
for (int i=0; i
System.out.println (word[i]);
words=addWord(word[i]);
}
inputLine = inputFile.readLine();
}
inputFile.close();
}
catch (IOException ioe)
{
System.out.println (ioe.getMessage());
ioe.printStackTrace ();
}
return words;
}
}
class WordList {
String [] words;
int wordcount;
public WordList ( ){
words= new String [1000];
wordcount=0;
}
public String  addWord (String word) {
words[wordcount]=word;
wordcount=+1;
return words[wordcount];
}
public void printList (){
for (int i=0; i
System.out.println (words[i]);
}
}
}

弄清楚如何在对象上应用方法调用非常重要。假设要调用x.f(args)，隐式参数x声明为类C的一个对象。下面是调用过程的详细描述：


编译器查看对象的声明类型和方法名。假设调用x.f(param)，且隐式参数声明为类C的对象。需要注意的是：有可能存在多个名字为f，但参数类型不一样的方法。例如，可能存在方法f(int)和方法f(String)。编译器会列举C类中所有名为f的方法和其超类中访问属性为public且名为f的方法。

至此，编译器已经获得所有可能被调用的方法。


接下来，编译器将查看调用方法时所提供的参数类型。如果在所有名为f的方法中存在一个与提供的参数类型完全匹配，就选择这个方法。这个过程被称为重载解析(overloading resolution)。由于允许类型转化，所以这个过程可能比较复杂。如果编译器没有找到与参数类型匹配的方法，或者发现经过类型转换后有多个方法与之匹配，就会报告一个错误。


如果是private方法、static方法、final方法或者构造器，那么编译器可以准确的知道应该调用哪个方法，我们将这种调用称为静态绑定(static binding)。与此对应的是，调用的方法依赖于隐式参数的实际类型，并且在运行时实现动态绑定(dynamic binding)。


当程序运行，并且采用动态绑定调用方法时，虚拟机一定调用与x所引用对象的是实际类型最合适的那个类的方法。假设x的实际类型是D，它是C的子类。如果D定义了方法f(String)，就直接调用它；否则，将在D的超类中寻找f(String)，以此类推。


每次调用方法都要进行搜索，时间开销很大。因此，虚拟机预先为每个类创建了一个方法表(method table)，其中列出了所有方法的签名和实际调用的方法。这个方法既有可能是D.f(String)，也有可能是X.f(String)，这里的X是D的超类。如果调用super.f(param),编译器将对隐式参数超类的方法表进行搜索。