java课后习题.docx

第1章习题解答
1．Java语言有那些特点？
答：Java语言的特点包括：平台无关性、面向对象、简单性、安全性、分布式、健壮性、解释型、多线程。
2．为什么说Java是结构中立的，具有跨平台特性？
答：无论哪种编程语言编写的程序最终都需要操作系统和处理器来完成程序的运行，平台无关性是指软件的运行不因操作系统、处理器的变化导致程序无法运行或出现运行错误。
以C++程序为例，C++编译器针对源程序所在平台进行编译、连接，然后生成机器指令，这样就无法保证C++编译器产生的可执行文件在所有平台上都被正确执行。如果更换了平台，可能需要修改源程序，并针对新的平台重新编译源程序。
相反，Java源代码不会针对一个特定平台进行编译，而是生成一种字节码中间文件（class文件），这种文件是平台无关且体系结构中立的。也就是说，无论一个Java程序是在Windows、Solaris、Linux还是其他具有Java编译器的操作系统下编译，作为编译结果的字节码文件都是相同的，都可以在任何具有Java虚拟机（JVM）的计算机上运行。JVM能够识别这些字节码文件，JVM将字节码文件进行转换，使之能够在不同平台上运行。任何操作系统只要安装了JVM，就可以解释并执行这种与体系结构无关的字节码文件，实现了跨平台。
跨平台特性保证了Java的可移植性，任何Java源程序都可以移植到其他平台上。除此之外，Java的数据类型与机器无关，原始数据类型存储方式是固定的，避开了移植时可能产生的问题。例如，在任何机器上，Java的整型都是32位的，而C++中整型的存储依赖于目标计算机。另外Java的字符串采用标准的Unicode格式保存，也保证了Java的可移植性。
3．简述Java的3种主要平台，这些适合开发那种应用？
答：Java的开发平台（JDK）是开发人员用来构建Java应用程序的软件包，它包括：Java虚拟机（JVM）、Java编译器（javac）、Java归档（jar）实用程序、Java文档（javadoc）实用程序等。目前，Java的运行平台主要分为下列3个版本。
（1）Java标准版
Java标准版即Java SE，曾被称为J2SE。Java SE提供了标准的JDK开发平台，利用该平台可以开发桌面应用程序、低端的服务器应用程序以及Java Applet程序。学习Java应当从Java SE开始，本书主要介绍Java SE。
（2）Java微型版
Java微型版即Java ME，曾被称为J2ME。Java ME是一种很小的Java运行环境，用于嵌入式的消费产品中，例如手机、平板电脑和各种轻量智能设备等。
（3）Java企业版
Java企业版即Java EE，曾被称为J2EE。可以构建企业级的服务应用。Java EE平台包含了Java SE，并增加了附加类库，以便支持目录管理、交易管理和企业级消息处理等功能。
4．什么是JDK、JRE、JVM，简述三者之间的关系。
答：Java的开发平台（JDK）是开发人员用来构建Java应用程序的软件包，它包括：Java虚拟机（JVM）、Java编译器（javac）、Java归档（jar）实用程序、Java文档（javadoc）实用程序等。
所谓的Java运行环境（JRE）是JDK的子集，包括JVM、运行时类库和执行Java字节码所需要的Java应用程序启动器，但省略了Java编译器等开发工具。如果只需要运行Java而不需要开发Java程序，则不需要完全安装JDK，只选择安装JRE即可。
9.在【例2-3】的基础上，对矩形类增加一个构造函数，使得能够用一个坐标点、矩形长度、矩形宽度以及方向（包括X方向和Y方向，其值为1或-1）构造一个实例。编写测试类进行测试，确认程序的正确性。
答：编写构筑函数的程序如下：
/* 构造函数之三：用一个坐标点的值和矩阵长度和宽度以及方向进行矩阵的初始化 */
public Rectangle(double x1, double y1, double length, double width,
int x_direct, int y_direct) {
this.point1 = new Point(x1, y1);
this.point2 = new Point(x1 + length * x_direct, y1 + width * y_direct);
}
第3章习题解答
1. Java语言的注释有哪几种？分别给出一个例子。
答：Java语言的注释有3种，分别是单行注释、多行注释和文档注释。
单行注释的例子如下：
public static Point origin = new Point(0, 0); //类初始化时，创建一个原点实例
多行注释的例子如下：
/* 类初始化时，创建一个原点实例 */
public static Point origin = new Point(0, 0);
文档注释的例子如下：
/**
*
* @类名：Point
* @类简介：坐标点类，可以初始化其坐标x和y。
* @编程人： 林福平
* @编程日期：2012-8-9
* @修改日期：2012-8-10
*
*/
2. Java语言中分隔符有哪几种？空白符有哪些？
答：Java语言中的分隔符有空白符、注释和普通分隔符三种。Java语言中的空白符（White Space）包括空格（SP，space）、制表符(‘\t’，Tab键)、走纸换页(‘\f’)、回车(‘\r’)和换行(‘\n’)。
3. 简述标识符的用途。下列字符串中，哪些是标识符？
PIx2 -length a+b _bytes $long MIN_VALUE
答：Java语言中的标识符用于对类、方法、变量、类型、数组和文件等进行命名。
上述字符串中，以下这些是Java语言的标识符：
PIx2 _bytes $long MIN_VALUE
4. 下列字符串中，哪些是关键字？
true for int null $float _double
答：上述字符串中，以下这些是Java语言的关键字：
true for int null
5. Java语言的基本数据类型分为那几大类？
答：Java语言的基本数据类型分为数值类型（包括整数类型和浮点类型）、字符类型(char)和布尔类型(Boolean)。整数类型有byte、 short、 int和long。浮点类型有float和double。
6. 编写一个简单的Java程序，验证带有下划线(_)的常量是否符合语法，同时给出一个十六进制形式浮点数常量验证它是否符合语法。
答：根据《Java语言规范》（《The Java™ Language Specification Java SE 7 Edition》）一书的语法规定，常量中可以使用下划线(_),并且允许使用十六进制浮点数的。但是，实际使用中由于难以理解，通常情况下应该避免使用。
例子程序如下：
public class TestJava {
public static final double X123 = 0x1_2_3.0p+0;
public static void main(String[] args) {
System.out.println(X123);
}
}
该程序运行结果如下：
291.0
7. 阅读以下Java语言程序的片段，写出程序输出结果：
int i = 1928;
do{
System.out.println(i);
i = i / 10;
} while(i > 0);
程序运行结果如下：
1
3
9
27
81
8.阅读以下Java语言程序的片段，写出程序输出结果：
int i = 1928;
do{
System.out.println(i);
i = i / 10;
} while(i > 0);
程序运行结果如下：
1928
192
19
1
9.用Java语言编写程序，计算输入的两个整数的最大公约数（GCD）。采用经典的Euclid算法，方法是：用变量m和n存储两个数的值，如果n为0，程序结束，m的值为最大公约数；否则计算m除以n的余数，把n保存到m中，并且把余数保存到n。重复这个过程，每次都先判定n是否为0。
答：编写程序如下（程序中，变量m和n的值是给定的，要使得程序具有通用性，可以将其改为运行时输入）：
public class TestJava {
public static void main(String[] args) {
int m = 420;
int n = 98;
while(n != 0) {
int temp = m % n;
m = n;
n = temp;
}

System.out.println(m);
}
}
程序运行结果是14。
10.用Java语言编写程序，然后对用户输入的一个分数（分别输入分子和分母）进行约分，并且输出约分后的分数（分别输出分子和分母）。例如输入分子为6并且分母为12，那么输出结果为1/2。
答：对于输入的分子和分母，求出其最大公约数，用最大公约数来除这两个数就得到约分的结果。程序设计如下：
public class TestJava {
public static void main(String[] args) {
Scanner numerator = new Scanner(System.in);
Scanner denominator = new Scanner(System.in);
int m = numerator.nextInt();
int n = denominator.nextInt();
while(n != 0) {
int temp = m % n;
m = n;
n = temp;
}
System.out.println(numerator.nextInt()/m +"/"+denominator.nextInt()/m);
}
}
在输入的分子和分母分别98和420的情况下，程序运行结果是7/30。
11.用Java语言编写程序，计算e=1+1/1! +2/2! +……+n/n!。要求e值精确到小数点第5位。
答：采用逼近法计算e，首先计算至第i项和第i+1项之和，比较它们的差值，满足精确到小数点第5位（差值<0.00001），即得到所求的e。
程序设计如下：
public class TestJava {
public static void main(String[] args) {
double ei;
double ei1 = 1;
i = 1;
double factorial = 1;
do {
ei = ei1;
factorial *= i;
ei1 += 1 / factorial;
i++;
} while(Math.abs(ei1-ei) > 0.00001);
System.out.println(ei1);
}
}
程序运行结果是2.7182815255731922。

import java.io.*;
import java.util.Scanner;
public class Xt9_11_BuffereStream {
public static void main(String[] args) throws IOException{
String filename="",str;
Scanner scan=new Scanner(System.in);
System.out.print("输入文件名：");
filename=scan.next();
FileReader fin=new FileReader(filename);//打开文本文件读
BufferedReader bin=new BufferedReader(fin);//字符流转换为缓冲流
int count=0;
while((str=bin.readLine())!=null&&count<10){//从文件读一行字符
System.out.println(str); //显示
count++;
}
bin.close();
}
}
第4章 习题解答
1. 声明一个数组，保存一个学生的数学、语文、英语、物理、化学等课程的成绩，编写一个程序，计算5门课程的平均成绩，精确到0.1分，成绩值从键盘录入。
import java.util.Scanner;
public class XT_1_score {

public static void main(String[] args) {
// TODO Auto-generated method stub
double score[] = new double[5];
System.out.println("请分别输入数学、语文、英语、物理、化学的成绩（数字之间用空格格开）：");
double sum = 0, average = 0;
Scanner in = new Scanner(System.in);

int i;

for (i = 0; i < 5; i++)
score[i] = in.nextDouble();
for (i = 0; i < 5; i++)
sum += score[i];
average = sum / 5;
System.out.println("平均成绩为：" + String.format("%.1f", average));

}
}
2. 编程实现统计50名学生的百分制成绩中各分数段的学生人数，即：分别统计出100分、90-99分、80-89分、70-79分、60-69分、不及格的学生人数。
import java.util.Scanner;
public class XT_2_score_sore {
public static void main(String[] args) {
// TODO Auto-generated method stub
double score[] = new double[50];
int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, i;
System.out.println("请依次输入50名学生的成绩（用空格隔开）：");
Scanner br = new Scanner(System.in);
for (i = 0; i < 50; i++)
score[i] = br.nextDouble();
for (i = 0; i < 50; i++) {
if (score[i] == 100)
a++;
if (score[i] >= 90 && score[i] <= 99)
b++;
if (score[i] >= 80 && score[i] <= 89)
c++;
if (score[i] >= 70 && score[i] <= 79)
d++;
if (score[i] >= 60 && score[i] <= 69)
e++;
if (score[i] < 60)
f++;
}
System.out.println("成绩为100分的个数：" + a);
System.out.println("成绩为90-99分的个数：" + b);
System.out.println("成绩为80-89分的个数：" + c);
System.out.println("成绩为70-79分的个数：" + d);
System.out.println("成绩为60-69分的个数：" + e);
System.out.println("成绩为不及格的个数：" + f);
}
}

3. 编写一个程序，实现打印输出字符串数组中最大值和最小值。提示：按照字典顺序决定字符串的最大值和最小值，字典中排在后面的大于前面的。
import java.util.Arrays;
import java.util.Scanner;

class XT_3_string {

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入字符串数组中的字符：");
Scanner in = new Scanner(System.in);
String str = in.next();
char array[] = new char[str.length()];
for (int i = 0; i < str.length(); i++) {
array[i] = str.charAt(i);
}
Arrays.sort(array);
System.out.println("最大值為：" + array[str.length() - 1]);
System.out.println("最小值為：" + array[0]);
}
}

4. 使用键盘输入一个字符串，编写程序统计这个字符串中的字母、空格和数字的个数。
import java.util.Scanner;
class XT_4_string {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 0, b = 0, c = 0;
System.out.println("请输入一段字符串：");
Scanner in = new Scanner(System.in);
String str = in.nextLine();
for (int i = 0; i < str.length(); i++) {
char array = str.charAt(i);
if ((array >= 'a' && array <= 'z')
|| (array >= 'A' && array <= 'Z'))
a++;
if (array >= '0' && array <= '9')
b++;
if (array == ' ')
c++;
}
System.out.println("字母的个数：" + a);
System.out.println("数字的个数：" + b);
System.out.println("空格的个数：" + c);
}
}

5. 编程实现将数组中的值按逆序重新存放，例如：原来顺序是9、7、4、6，要求改为6、4、7、9。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class XT_5_nixu {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub

System.out.println("请输入数组的长度：");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String m;
m = br.readLine();
int array[] = new int[Integer.parseInt(m)];
System.out.println("请输入数组的元素(用空格隔开)：");
Scanner in = new Scanner(System.in);
for (int i = 0; i < Integer.parseInt(m); i++) {
array[i] = in.nextInt();
}
System.out.println("逆序输出：");
for (int i = Integer.parseInt(m) - 1; i >= 0; i--)
System.out.print(array[i] + " ");

}

}

6. 编写程序，完成打印输出杨辉三角形（要求输出的格式应在屏幕的居中位置）。杨辉三角形的格式如下：
1 ​ ​ ​ ​ ​ ​ ​ ​ ​
​ ​ ​ ​ ​ ​ ​ ​ 1 ​ 1 ​ ​ ​ ​ ​ ​ ​ ​
​ ​ ​ ​ ​ ​ ​ 1 ​ 2 ​ 1 ​ ​ ​ ​ ​ ​ ​
​ ​ ​ ​ ​ ​ 1 ​ 3 ​ 3 ​ 1 ​ ​ ​ ​ ​ ​
​ ​ ​ ​ ​ 1 ​ 4 ​ 6 ​ 4 ​ 1 ​ ​ ​ ​ ​
​ ​ ​ ​ 1 ​ 5 ​ 10 ​ 10 ​ 5 ​ 1 ​ ​ ​ ​
​ ​ ​ 1 ​ 6 ​ 15 ​ 20 ​ 15 ​ 6 ​ 1 ​ ​ ​
​ ​ 1 ​ 7 ​ 21 ​ 35 ​ 35 ​ 21 ​ 7 ​ 1 ​ ​
​ 1 ​ 8 ​ 28 ​ 56 ​ 70 ​ 56 ​ 28 ​ 8 ​ 1 ​
1 ​ 9 ​ 36 ​ 84 ​ 126 ​ 126 ​ 84 ​ 36 ​ 9 ​ 1
import java.util.Scanner;
public class XT_6_YangHSJ {

public static void yanghui(int a[][], int r) {
for (int i = 0; i < r; i++) {
for (int j = 0; j < a[i].length; j++) {
if (i == 0 || j == 0 || j == a[i].length - 1)
a[i][j] = 1;
else
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
}
}
System.out.println(r + "行杨辉三角为:");

// 输出杨辉三角
for (int i = 0; i < r; i++) {
for (int k = r-i; k >0; k--)
System.out.print(" ");
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + " ");

}
System.out.println();
}
}

public static void main(String[] args) {
// TODO Auto-generated method stub
{
System.out.println("请输入杨辉三角的行数:");
Scanner input = new Scanner(System.in);
int r = input.nextInt();
input.close();
int a[][] = new int[r][];
for (int i = 0; i < r; i++)
a[i] = new int[i + 1];
yanghui(a, r);
}
}
}
第5章 习题解答
1. 使用抽象和封装有哪些好处？
答：抽象是人们解决问题的基本手段，程序设计过程中需要对问题领域进行分析、设计中得出的抽象概念，然后封装成一些类。封装也称为信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他部分只有通过包裹在数据外面的被授权的操作来与这个抽象数据类型交流与交互。也就是说，用户无需知道对象内部方法的实现细节，但可以根据对象提供的外部接口(对象名和参数)访问该对象。把对象中相同或相似地地方抽象出来，从特殊到一半，从具体到抽象的过程，对象经过抽象得到类，类的实例化成了对象。也可以高度抽象成接口，让不完全相同，但包含相同点的对象实现此接口，也就是利用多态实现。把相同点抽象出来，抽象成此类或接口的方法、属性、字段等，封装就是隐藏某个对象的与其基本特性没有很大关系的所有详细信息的过程，就是将需要让其他类知道的暴露出来，不需要让其他类了解的全部隐藏起来，封装可以阻止对不需要信息的访问，我们可以使用访问指定符实现封装，也可以使用方法实现封装，可以将隐藏的信息作为参数或者属性值、字段指传给公共的接口或方法，以实现隐藏起来的信息和公开信息的交互。封装的目的就是为了实现“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，就是这个类只完成自己的功能，不需要外部参与；低耦合，就是仅暴露很少的方法给外部使用。
2. 构造方法的作用是什么？它与一般的成员方法在使用和定义方面有什么区别？
答：构造方法用于生成一个对象实例，并对对象实例中的成员变量初始化。当用new创建一个类的新的对象时，构造方法立即执行。构造方法名字必须与类名相同。
3. Overload和Override的区别?
答：方法重载（overloading）与方法覆盖（overriding）是实现多态性的基本手段，但两者的机制不同。方法重载是指一个类中可以有多个方法具有相同的名字，但这些方法的参数不相同。参数不同具体体现为：或者参数的个数不相同，或者是参数的类型不同。方法覆盖（overriding）是指子类的方法名与父类的方法名完全相同，并且返回值类型、入口参数的数目、类型均相同，即在子类中重新改写了父类的同名方法。Java根据实际参数的个数和类型来选择调用合适的方法，这样就能使用相同的方法名实现不同的功能，体现了多态性。
4. 类、类的成员变量和成员方法的访问权限修饰符分别有哪些？
答：Java提供public、protected、private、默认等4种访问控制符，在类、成员变量、成员方法的前面可以使用访问控制符关键字，没有显式使用的均为默认控制类型。Java语言提供的访问权限控制符的访问权限如表5-1。
表5-1 Java语言提供的访问权限控制符

本类
本包
不同包中的子类
不同包中的所有类
private
√

默认
√
√

protected
√
√
√

public
√
√
√
√

5. this、super关键字有何用途？
答：子类在继承父类时，可能会出现变量隐藏、方法覆盖（overriding）等现象。变量隐藏指子类的成员变量与父类成员同名，此时，父类的成员变量被隐藏。方法覆盖指子类的方法与父类的方法名相同，方法的返回值类型、入口参数的数目、类型、顺序均相同，只是方法实现的功能不同，此时父类的方法被覆盖。如果子类需要调用或访问父类被隐藏的变量或被覆盖的方法，可以使用super关键字实现。Java提供关键字super来实现对父类的成员和方法的访问。Super有三种情况可以使用：
⑴ 用来访问父类中被覆盖的方法；
⑵ 用来访问父类中被隐藏的成员变量；
⑶ 用来调用父类中的构造方法。
关键字this可以出现在类的构造方法和非static修饰的成员方法（即实例方法）中，代表实例对象自身，有以下几种使用情况：
（1）在类的成员方法中，可以通过this来访问实例对象的成员变量或调用成员方法。
（2）在类的成员方法中，区分成员变量和局部变量；
（3）在类的成员方法中，使用this返回实例对象本身的引用；
（4）在类的构造方法中，使用this调用该类的其他构造方法。
6. JAVA实现多态的机制有哪些？
答：多态性包含编译时的多态性、运行时的多态性两大类，即：多态性也分静态多态性和动态多态性两种。静态多态性是指定义在一个类或一个函数中的同名函数，它们根据参数表（类型以及个数）区别语义，。动态多态性是指定义在一个类层次的不同类中的重载函数，它们一般具有相同的函数，因此要根据指针指向的对象所在类来区别语义，它通过动态联编实现。 Java从多个方面支持多态性，一方面可以通过方法重载实现多态，另一方面也可以通过继承过程中出现的方法覆盖以及对象类型转换（父类引用指向子类对象）实现。方法重载（overloading）与方法覆盖（overriding）是实现多态性的基本手段。
7. 什么是类变量和类方法？
答：static可以用来修饰类的成员变量或成员方法，分别称为类变量（或静态变量）和类方法（或静态方法）。相应地，没有被static修饰的类的成员变量或成员方法称为实例变量或实例方法。
1.类变量
在生成每个类的实例变量时，Java运行系统为每个对象的实例变量分配一个内存空间，实例变量指向该内存空间，不同的实例变量占用不同的内存区域。对于类变量来说，Java运行系统为类的类变量分配公共的存储空间，该类的每个实例对象共享同一类变量的存储空间。因此，每个对象对类变量的修改都会影响其他实例对象。
类变量可以通过类名直接访问，也可以通过实例对象来访问，都是对同一内存单元的操作，
类变量的使用具有如下特点：
（1）类变量可以通过类名直接访问，而不需要创建对象
（2）任何一个对象对类变量的修改，都是在同一内存单元上完成的。因此，每个对象对类变量的修改都会影响其他实例对象。
2.类方法
声明为static的方法称为类方法（或称静态方法），与此相对，没有static修饰的成员方法则为实例方法。类方法的本质是该方法属于整个类，而不是属于某个实例，可以不创建实例，直接通过类名调用。
类方法的使用具有以下特点：
（1）类方法可以通过类直接调用，而不需要创建实例对象。例如：Java Application的入口main（）方法就被声明为static类方法，可以不需要创建任何实例对象对调用。
（2）类方法属于整个类，被调用时可能还没有创建任何对象实例，因此类方法内只可以访问类变量，而不能直接访问实例变量和实例方法。
（3）类方法中不能使用this关键字，因为静态方法不属于任何一个实例。
8. final关键字有何用途？
答：final可以用来修饰类以及类的成员变量和成员方法。
1.final修饰类
如果一个类被final修饰符修饰和限定，说明这个类称为最终类，它不可能有子类，有子类就意味着可以定义新成员。Java API中有不少类定义为final类，这些类通常是有固定作用、用来完成某种标准功能的类，例如：Math类、String类、Integer类等。
abstract和final修饰符不能同时修饰一个类，但是可以各自与其他的修饰符合用。当一个以上的修饰符修饰类时，这些修饰符之间以空格分开，写在关键字class之前，修饰符之间的先后排列次序对类的性质没有任何影响。
2.final修饰成员变量
用final修饰的成员变量为常量，不允许修改。
同样final修饰符可以与其他修饰符一起修饰成员变量，这些修饰符之间以空格分开，修饰符之间的先后排列次序对成员变量的性质没有任何影响。
3. final修饰成员方法
用final修饰的成员方法是功能和内部语句不能被更改的最终方法，即不能被当前类的子类重新定义的方法。它固定了这个方法所对应的具体操作，防止子类对父类关键方法的错误重定义，保证了程序的安全性和正确性。
final类中的所有成员变量和方法都被默认为final的。
9. 什么是抽象类，如何定义抽象类？
答：抽象是人们解决问题的基本手段。在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来却不是这样，并不是所有的类都是用来描绘对象的。如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。比如：进行图形编辑软件的开发时，会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体对象，所以用以表征抽象概念的抽象类是不能够实例化的。
抽象类需要使用abstract来修饰，定义语法如下：
abstract class <类名> [extends<父类>][implements<接口名>]{
<类主体>
}
10. 什么是接口，如何定义接口？
答：接口（interface）是Java所提供的另一种重要功能，它的结构和抽象类非常相似。接口是一种特殊的类，但接口与类存在着本质的区别。类有成员变量和成员方法，而接口却只有常量和抽象方法，也就是说接口的成员变量必须初始化，同时接口中的所有方法必须全部声明为abstract方法。
1.接口的定义
通过关键词interface来定义,接口定义的一般形式为
[接口修饰符] interface〈接口名〉[extends〈父类接口列表〉] {
接口体
}
11. 接口与抽象类的区别有哪些？
答：接口和抽象类非常相似。接口是一种特殊的类，但接口与类存在着本质的区别。抽象类有成员变量和成员方法，而接口却只有常量和抽象方法。
12. 接口是否可继承接口?
答：与类一样，可以使用extends子句、扩展接口，生成子接口。原来的接口称为基本接口（base interface）或父接口(super interface)，扩展出的接口称为派生接口或子接口。通过这种机制，派生接口不仅可以保有父接口的成员，同时也可以加入新的成员以满足实际问题的需要。与类不同的是，一个接口可以扩展多个接口，继承它们所有属性，而一个类只能扩展一个类。显然，接口不能扩展类，接口的方法必须全是抽象的。
13. java如何实现多重继承？
答：Java不直接实现多重继承，但是提供了接口实现多重继承。
14. 如何