java简答题和编程题答案.doc

二．简答题
1. Java中命名标识符有什么规则？
Java语言规定标识符是以字母、下划线“_”或美元符号“$”开始随后可跟数字、字母、下划线或美元符号的字符序列
2.什么是继承机制
类具有继承性，子类对父类的继承关系体现了现实世界中特殊和一般的关系。通过继承可以更有效地组织程序结构，明确类间关系，并充分利用已有的类来完成更复杂、深入的开发
3.什么是抽象类
抽象类体现数据抽象的思想，是实现程序多态性的一种手段。接口则是Java中实现多重继承的唯一途径。
抽象类的作用在于将许多有关的类组织在一起，提供一个公共的类，即抽象类，而那些被它组织在一起的具体的类做为它的子类由它派生出来。
4. Java中的接口如何声明？
声明接口的格式如下：
[修饰符] interface 接口名［extends 父接口名列表］
{　常量数据成员声明
　抽象方法声明
}
5.什么是包
包（package）是Java提供的文件（即公共类）的组织方式。一个包对应一个文件夹，一个包中可以包括许多类文件。包中还可以再有子包，称为包等级。
6.什么是域的隐藏？子类和父类有同名域，在子类方法中如何进行访问父类的域
（1）. 数据成员的隐藏
数据成员的隐藏是指在子类中重新定义一个与父类中已定义的数据成员名完全相同的数据成员，即子类拥有了两个相同名字的数据成员，一个是继承父类的，另一个是自己定义的。
（2）当子类要操作继承自父类的同名数据成员时，可使用关键字super引导。
即super.数据成员
7.静态属性如何声明，存储和访问
static：静态方法，又称类方法
使用类名或对象名作为前缀，建议使用类名
在方法体中只能使用static变量和static方法或访问自己的局部变量
8. Java的访问控制符有哪些？各有什么作用？
访问控制符（访问权限）
public：可被所有其他类引用
protected：该类自身、子类、同一包中的其他类
private：仅可被该类自身引用和修改，不能被其他任何类（包括子类）引用default(缺省)：本包中的类
9. 简述JAVA的异常处理机制
每当Java程序运行过程中发生一个可识别的运行错误时，即该错误有一个异常类与之相对应时，系统都会产生一个相应的该异常类的对象，即产生一个异常。一旦一个异常对象产生了，系统中就一定有相应的机制来处理它，确保不会产生死机、死循环或其他对操作系统的损害，从而保证了整个程序运行的安全性。这就是Java的异常处理机制。
10. 编写图形用户界面程序的一般步骤是什么
(1) 构建一个顶层容器；通常是JFrame或JApplet
(2)   构建若干个组件，组件可以是其它容器；
(3)    设定容器的布局管理器；用容器的add方法将这些组件加入到这个容器中；
(4)    设置组件事件；并将组件事件与代码关联。

三．编程题目：
1、设计一个表示二维平面上的点的类Point，包含表示坐标位置的protected类型的成员变量x和y，以及获取和设置x和y的值的public类型的方法：getx()、gety()、setx()、sety()。Point类的构造方法要有多种形式
import java.util.*;//Scanner类在这个包里
class Point{
protected float x,y; //定义Circle类的坐标
protected Scanner scan=new Scanner(System.in); //设一个SCanner对象scan，指定输入方式是从键盘读入
public Point(){
x=0;y=0;
} //无参构造
public Point(float x,float y){
this.x=x;
this.y=y;
} //有参构造
public void setx(){
x=scan.nextFloat();
}//从键盘读入坐标x
public void sety()
y=scan.nextFloat();
}//从键盘读入坐标y
public float getx(){
return this.x;
}//得到当前对象的x
public float gety(){
return this.y;
}//得到当前对象的y

}

2. 设计一个表示二维平面上的圆的类Circle，它继承自Point类。类Circle包含表示圆半径的protected类型的成员变量r，以及获取和设置r的值的public类型的方法：getr()、setr()，计算圆面积的方法area()。此外，Circle类的构造方法要有多种形式
class Circle extends Point{
protected float r; //定义出半径r
public Circle(){
super(); //调用Point类的无参构造
r=0;
} //无参构造
public Circle(float x,float y,float r){
super(x,y); //调用Point类的有参构造
this.r=r;
}//有参构造
public void setr(){
r=scan.nextFloat();
}
public float area(){
final float PI=(float)3.14;
return(PI*r*r);
}//返回此圆 的面积的一个函数
public static void main(String[]args){

}
}

3. 编写一个java应用程序，以不同形式建立若干个Circle类的对象，输出它们的中心点
public class Test{
public static void main(String []args ){
Circle circle1,circle2;
System.out.println("circle1********************");
circle1=new Circle(1,2,3); //circle1 采用传参的方式构造
System.out.println("circle1: point:("+circle1.x+","+circle1.y+") r="+circle1.r);//输出中心点和半径
System.out.println("circle1: area:"+circle1.area()); //输出面积
System.out.println("circle1********************");

circle2=new Circle();
System.out.println("circle2********************");
System.out.println("please input the (x,y) r");
circle2.setx(); //circle2采用从键盘的方式构造
circle2.sety();
circle2.setr();
System.out.println("circle2: point:("+circle2.x+","+circle2.y+") r="+circle2.r);//输出中心点和半径
System.out.println("circle2: area:"+circle1.area());//输出面积
System.out.println("circle2********************");
}
}

4. 给定一个正整数数组，按照冒泡排序算法进行排序

import java.util.Scanner;
public class Sort{
private int []data;//定义一个数组
private Scanner scan;//一个阅读类对象
Sort(){
data=null;
scan=new Scanner(System.in); //初始化对象，让其输入方式是从键盘读入
}

public void readdata(){//从键盘读入数组
int n;
System.out.println("please input the size of the data:");
n= scan.nextInt();//读入一个整数（数组长度）赋给n
data=new int[n];//data给data赋空间
for(int i=0;i<n;i++){
data[i]=scan.nextInt();//读入数组中的所有的数
}
}
public void outputdata(){//输出一个数 组
for(int i=0;i<data.length;i++){
System.out.print(data[i]+" ");//输出每个元素
}
System.out.println();//输出一个回车
}

public void sort(){ //升序排列
int i,j,r;
for(i=0;i<data.length-1;i++){
for(j=0;j<data.length-1;j++){
if(data[j]>data[j+1]){//相邻的两个数比较，把大的放在后面,每一轮下来最大的都是在最后
r=data[j];
data[j]=data[j+1];
data[j+1]=r;
}
}
}

}
public static void main(String []args){
Sort sortdata=new Sort();//创建一个这样的对象
sortdata.readdata();//读入一个数组
sortdata.sort();//进行排序
sortdata.outputdata();//输出数组

}
}

5. 编写一个Java程序，将某一整数范围内所有素数打印出来。要求用图形界面实现
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.event.*;
import java.util.*;
import java.io.*;
public class File1 extends JFrame{ //继承窗口容器
private JLabel labela; //设标签对象
private JLabel labelb;
private JTextField texta; //设文本输入框对象
private JTextField textb;
private JButton ok; //设一个按扭对象
private Container content; //设一个面板容器对象
private int low,high; //low-下限 high-上限
private Scanner scan; //阅读类
private JTextArea text;//结果显示区域的文本区对象
public File1(){ //构造函数
this.setSize(300,450); //设置窗口大小
this.setTitle("素数"); //设置标题
this.setVisible(true); //可见
this.setResizable(false);//不可改大小

Dimension screen=Toolkit.getDefaultToolkit().getScreenSize(); //读取屏幕大小尺寸
Dimension mySize=this.getSize(); //读取窗口大小尺寸
setLocation((screen.width-mySize.width)/2,(screen.height-mySize.height)/2);
content=this.getContentPane(); //把面板容器加入到窗口中
content.setLayout(null); //无布局模式
labela=new JLabel("input low:"); //为标签开辟空间
labelb=new JLabel("input high:");
content.add(labela); //向面板中加入标签
content.add(labelb);
texta=new JTextField("0",50); //为文本输入框开辟空间
textb=new JTextField("0",50);

content.add(texta); //向面板容器中加入文本框对象
content.add(textb);

text=new JTextArea(); //开辟一片文本显示区域的空间
content.add(text); //加入到面板中
text.setBounds(0, 150, screen.width, screen.height/3);

ok=new JButton("ok");
content.add(ok);
labela.setBounds(5,5,80,20); //设置各个对象在窗口中的位
置（x,y,width,heigth);
labelb.setBounds(5,50,80,20);
texta.setBounds(80,5,100,20);
textb.setBounds(80,50,100,20);
ok.setBounds(225,40,50,50);
ok.addActionListener(new clicked());//对按扭进行事件监听

}
public void sendtotext(int low,int high) throws IOException
{//把所有的素数挑出来输出到文本显示区的函数

String str=new String("between ");
str=str+Integer.toString(low);
str=str+" and ";
str=str+Integer.toString(high);
str=str+": "; //让str中存入“between low and high: ”

int i,j,flag=0;
if(low<2)low=2;
for(i=low;i<high;i++){
for(j=2;j<i;j++){
if(i%j==0)break;
}
if(j!=i)continue;
else {str=str+Integer.toString(i);str=str+" ";}
flag=1;
}//选出所有素数，写入到str中

if(flag==0){ //若没有素数则存入没有素数
str="sorry,not exsits";
}

text.setText("");

text.append(str); //在文本显示区中输入str结果
text.setCaretPosition(0);//让文本区的焦点一开始在文本开头儿
}
public class clicked implements ActionListener{//监听类

@Override
public void actionPerformed(ActionEvent e) {//若触发了事件则执行的函数，也就是说在按下按扭之后要执行的函数
low=Integer.parseInt(texta.getText());//把下限转换为整型
high=Integer.parseInt(textb.getText());
try {
sendtotext(low,high); //把结果写入到文本显示区
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}

}

}

public static void main(String[]args){
File1 file=new File1();//新建一个File1对象，这样 就会弹出图形化窗口
}
}
6.没有第6题
7. 编写一个程序，找出整数数组中的最小元素和最大元素，并统计最大元素和最小元素的个数
import java.util.Scanner;
public class Count{
private int []data;//定义数组对象
private int max_count;//最大值的个数
private int min_count;//最小值 的个数
private Scanner scan;//定义一个阅读类的对象
Count(){//构造函数 赋初值
data=null;
max_count=0;
min_count=0;
scan=new Scanner(System.in);
}

public void readdata(){
int n;
System.out.print("please input the size of the data: ");
n=scan.nextInt(); //读入数组长度存入n中
data=new int[n];//为数组开辟空间，这个一定 不要忘
for(int i=0;i<n;i++){
data[i]=scan.nextInt();//读入数组中的每一个元素
}
}

public void count(){//统计数组中的最大值和最小值的个数
int max,min;
max=data[0];
min=data[0]; //一开始假设最大值和最小值都是第一个元素

for(int i=0;i<data.length;i++){ //遍历一遍
if(max<data[i]){//如果max不是最大的，那max存入比他大的，并将个数置成1
max=data[i];
max_count=1;
}
else {//若max 是目前最大的，如果有和他一样大的，max_count自增
if(max==data[i])max_count++;
}

if(min>data[i]){//最小值同理于最大值方法
min=data[i];
min_count=1;
}
else{
if(min==data[i])min_count++;
}
}
}
public void output(){//输出结果
System.out.println("the max_count: "+max_count+" "+"the min_count: "+min_count);
}

public static void main(String []args){
Count co=new Count();//新建一个Count对象
co.readdata();//读入数组
co.count();//统计个数
co.output();//输出结果
}
}

8. 编写一个程序，列出某个目录及其子目录下的所有文件的名称和他们的属性
import java.io.*;
import java.util.Scanner;
public class Catalog {
private String path; //文件路径
private File dir; //一个文件类对象
private Scanner scan; //阅读类对象

public Catalog(){ //构造函数，初始化数据
path=null;
dir=null;
scan=new Scanner(System.in);
}
public void open(String path){ //让dir指向路径所指的文件
dir=new File(path);

}

public void input(){ //读入路径到path
System.out.println("Please input the path:");
path=scan.nextLine();
open(path);//调用open函数（上面）
}

public void listfiles(File dir,int level)
{//展开所有子目录，level是指当前的目录是第几层的子目录
int i=0;
File []files=dir.listFiles(); //将当前目录dir下的所有文件存入到一个文件数组中files
for(i=0;i<files.length;i++){ //遍历这个文件数组
for(int j=0;j<level;j++){//按照level的值输出指定的空格，表现出目录之间的层次关系
System.out.print(" ");
}
System.out.print(files[i].getName()+":"); //输出文件名称
if(files[i].isFile())System.out.println("a File"); //输出文件是否是目录属性还有很多，如大小等，自己去弄吧哈
else System.out.println("a directory");
if(files[i].isDirectory()){
listfiles(files[i],level+1); //若该文件是一个目录的话 ，递归调用此函数，将它的子目录展开
}
}
}

public void showca(){ //展示目录
if(!dir.exists()){System.out.println("sorry,not exists!");}//若一开始指定路径的文件不存在的话
else{//若存在则展开所有子目录
listfiles(dir,0);//(函数在上面）
}
}
public static void main(String []args){
Catalog ca=new Catalog();//建立一个对象
ca.input();//输入根 目录 的路径
ca.showca();//展开根 目录下的所有子目录
}
}

第四题.读程序题
1. m = 10
2. 9 7 5 3 1
3. 黄牧
000001
4. 02