Java考前复习资料（知识点+测试题+答案）

1.编写程序求解：今有物不知其数（设为x，范围是0至1000），三三数之剩二（x除以3余数为2），五五数之剩三，七七数之剩二，问物几何？

public class sansanshu {
	public static void main(String[] args) {
		int i;
		for(i=0;i<=1000;i++)
			if(i%3==2&&i%5==3&&i%7==2)
       System.out.println(i);
	}
}

结果
23，128，233，338，443，548，653，758，863，968

1.标识符号
1、由字母，数字，下划线 , 美元符($)组成；
2、不能以数字开头；
3、不能与关键字、保留字冲突。
注意：
Java区分大小写，X和x是两个不同的标识符
合法标识符
identifier userName User_Name
_sys_value $change 中国 i服了you
非法标识符
2mail room# class
布尔类型
(1)布尔数据类型来自布尔代数，它的值域包括两个值：真（true）和假（false）。例如：

boolean lightsOn = true;
boolean lightsOn = false; 

(2)用布尔值进行运算的运算符是比较运算符（关系运算符）和布尔运算符（逻辑运算符）。
常量
1.变量的值在程序执行过程中可能会改变，常量则表示永远不变的数据。
2.常量的语法如下：

final datatype CONSTANTNAME=VALUE;
(final 数据类型 常量名=值；)
常量必须在使用前给予说明和初始化

1.编写程序：设计一个关于三角形的类Trival，其中的属性包括三角形的底，三角形的高，方法包括：无参构造方法（底和高都为1.0）、为底和高赋初始值的构造方法、获取三角形面积方法findArea()，然后执行测试类TrivalDemo来判断程序是否正确。

class Trival{
	double L,H;
	Trival(){
		L=H=1.0;
	}
	Trival(double l,double h){
		L=l;
		H=h;
	}
	void 面积(){
		System.out.println("面积="+(L*H)/2);
	}
}
public class TrivalDemo {
	public static void main(String[] args) {
		Trival c1=new Trival();
		c1.面积();
	}
}

结果 面积=0.5

2．关于构造函数的说法正确的是 C 。
A．一个类只能有一个构造函数
B．一个类可以有多个不同名的构造函数
C．构造函数与类同名
D．构造函数必须自己定义，不能使用父类的构造函数

this
this可以理解为一个代词，代表当前对象。如果方法形参与对象成员变量同名，那么可以用this来区分。

Rect(double  sideA,double  sideB)
   {    
         this.sideA = sideA;   
         this.sideB = sideB;    
}

static
由static修饰变量—类变量

class  A
{    int   a = 9 ;
      static  int   b = 12;      
      void  f( )
       {      a = 12 ;
        …}
}

访问权限（4个单词）
同类中 同包中 不同包中子类 不同包中任意类
private ★
default/
friendly ★ ★
protected ★ ★ ★
public ★ ★ ★ ★

类的继承
创建子类

 class 子类   extends 父类
{
   ……
}

子类继承父类中访问public、 protected变量和方法；
不继承private的变量和方法。
所有的Java类都直接或间接地继承了
java.lang.Object类
（1）编写一个矩形父类,包括长和宽、构造方法、返回矩形面积和周长的方法；

（2）编写一个立方体子类，即继承矩形父类后增加一个变量（高），返回立方体体积方法；

（3）编写一个执行主类，声明定义一个立方体类对象，并输出该立方体的体积。
成员变量隐藏
子类变量与父类变量同名,则父类变量被隐藏
方法重写
子类重新定义父类已有方法
super
父类对象------super
调用父类构造方法
super必须是子类构造方法的第一条语句
abstract（单词）
abstract----抽象类
不能实例化，即不能创建对象,主要作为基类或父类存在
必须实现所有abstract方法
final最终类（单词）

final----最终类，不能被继承

  public final class Test {
        ……
    }

注意：声明类时abstract 和 final不能同时使用
接口（单词）

1.接口interface——方法定义和常量值的集合

2.接口是特殊的抽象类

3.只包含常量和方法的定义，而没有方法的实现
接口使用
关键字——implements
接口程序

interface CharStorage{
     void put(char c);
          char get(); }
class Stack implements CharStorage{
    char mem[ ]=new char[10];
    int point=0;
   public void put(char c){
   mem[point]=c;
   point++;}
   public char get(){
   point--;
   return mem[point];  }}

（3） ＋
字符串的连接
例如：

 int age=21;
 String s=“He is ” + age + “ years old.”;

（4） charAt (int index )
返回字符串中index位置上的字符
例如：

 System.out.println(s.charAt(6));

(5)提取子串

substring(int beginIndex)
substring(int beginIndex,int endIndex)

用来得到字符串中指定范围内的子串
例子：

"hamburger".substring(4, 8) ====》  "urge" 
"smiles".substring(1, 5)    ====》  "mile" 

（6）toLowerCase()
将串中的所有字符转换成小写
（7）toUpperCase()
将串中的所有字符转换成大写
（8）equals和equalsIgnoreCase
判断两个字符串是否相等，相等返回true，不等返回false;
两种方法的区别：
equalsIgnoreCase不区分字母大小写;
equals则区分字母大小写；
总结:数据类型转换（包装类）
数字->字符串
Double.toString(double);
Float.toString(float);
String.valueOf(各种类型的数值);
Integer.toString(int);
“ ”+字符串
字符串->数字

   Byte.parseByte(string);
   Double.parseDouble(string);

Math类
包含常用数学计算
1.public static final double random( )
返回0.0到1.0间的随机数
2.举例

public class test{
  public static void main(String args[]){    
     int a[]=new int[10],i;
     for(i=0;i<10;i++)
    {  a[i]=(int)(Math.random()*100);
       System.out.println("a["+i+"]="+a[i]);
     }
  } }

栈的线性表
特点：先进后出

import java.util.*;
 class MyStack{
private LinkedList l=new LinkedList();
public void push(Object o)
{
l.addFirst(o);
}
public Object pop()
{
return l.removeFirst();
}
public Object peek()
{
return l.getFirst();
}
public boolean empty()
{
return l.isEmpty();
}
}

public class ListDemo{
public static void main(String args[])
{
MyStack s=new MyStack();
s.push("北京");
s.push("上海");
s.push("大连");
    System.out.print(s.empty());
    System.out.print(s.pop());
    System.out.print(s.pop());
    System.out.print(s.pop());
    System.out.print(s.empty());
}
}

队列的线性表
特点：先进先出

import java.util.*;
class MyQueue{
private LinkedList l=new LinkedList();
public void put(Object ob)
{
l.addLast(ob);
}
public Object get()
{
return l.removeFirst();
}
public boolean empty()
{
return l.isEmpty();
}
}
public class ListDemo{
public static void main(String[] args)
{
MyQueue q=new MyQueue();
q.put("北京");
q.put("上海");
q.put("大连");
System.out.print(q.empty());
System.out.print(q.get());
System.out.print(q.get());
System.out.print(q.get());
System.out.println(q.empty());
}
}

声明异常
声明异常就是告诉编译器在执行方法的过程中可能出现的错误

在方法声明中使用关键字throws可以声明异常，如：

public void myMethod() throws IOException
public void myMethod()
                throws IOException, OtherException

在方法头中用关键字throws进行声明！
注意：声明了抛出异常的方法未必会真的抛出异常！

有时不论异常是否出现或者是否被捕获，都希望执行某些代码。Java有一个finally子句可以用来达到这一目的。
finally子句的语法如下所示：

try{  
  statement1;  //throw a exception
	statement2;
	……
	}
catch(TheException e){ 
  Process exception; 
}
finally{ 
  finalStatements; 
}
otherStatements;
（）

布局管理器类

(1)管理各种组件在容器中的放置状态
(2)标准的布局管理器类

FlowLayout

BorderLayout

GridLayout

菜单栏JMenuBar
菜单JMenu
菜单项JMenuItem

常用组件事件实例（编程题）

import java.awt.*; import java.awt.event.*;
import javax.swing.*;
public class test {   //主类
    public static void main(String args[ ]){
        new JFrameInOut( );  }}
class JFrameInOut extends JFrame implements  
                         ActionListener
{    JLabel  prompt;  //声明标签对象
     JTextField input,output;  //声明文本对象
     JButton btn; //声明按钮对象
     JFrameInOut( ) {
     super("图形界面的Java Application程序");
     prompt=new JLabel("请输入您的姓名");
     input=new JTextField(6);  
     output=new JTextField(20);
     btn=new JButton("关闭"); //产生按钮并初始化
setLayout(new FlowLayout());  //窗体布局 
   add(prompt);    add(input); 
   add(output);    add(btn);
   input.addActionListener(this);      
   btn.addActionListener(this);
   setSize(400,400);  //窗体大小
   setVisible(true);  //可见
}
public void actionPerformed(ActionEvent e) {
 if(e.getSource()==input)  //动作控件是否为文本
 output.setText(input.getText()+" ,欢迎你！");
      else  {
             dispose( );
             System.exit(0);  //关闭窗体
         }}}

当鼠标按下或松开时调用
mousePressed(MouseEvent e)和mouseReleased(MouseEvent e)事件处理器。
而当按下鼠标并松开后，调用mouseClicked(MouseEvent e)事件处理器。

Java不直接支持键盘输入。
Scanner是SDK1.5新增的一个类,可是使用该类创建一个对象.
Scanner reader=new Scanner(System.in);　
然后reader对象调用下列方法(函数),读取用户在命令行输入的各种数据类型

next.Byte(),nextDouble(),nextFloat,nextInt(),nextLine(),nextLong(),nextShot()　

上述方法执行时都会造成堵塞,等待用户在命令行输入数据回车确认

import java.util.*;
public class Example{
public static void main(String args[]){
System.out.println("请输入若干个数,每输入一个数用回车确认");
System.out.println("最后输入一个非数字结束输入操作");
Scanner reader=new Scanner(System.in);
double sum=0;
int m=0;
while(reader.hasNextDouble()){
    double x=reader.nextDouble();
    m=m+1;
    sum=sum+x;
}
System.out.printf("%d个数的和为%f\n",m,sum);
System.out.printf("%d个数的平均值是%f\n",m,sum/m);
}
}

（四个单词）JDBC API提供的常用接口如下：
java.sql.DriverManager：处理驱动程序的调入；
Java.sql.Connection：与特定数据库建立连接；
Java.sql.Statement：SQL语句的执行，包括查询、更改、创建数据库等；
Java.sql.ResultSet：保存查询所得的结果。
注意：需要引入java.sql包

实现线程方法
继承Thread类
直接定义Thread子类，覆写run方法，在方法里定义所要执行的具体操作
实现Runnable接口
只定义了run接口方法，在类定义时实现run方法
主要方法
start（）：启动线程，从新建状态进入就绪排队状态
run（） : 定义线程操作，需要定义run方法

ServerSocket类（单词）
监听服务类，实现网络通讯前，创建服务器端的监听对象，以接收客户端的连接求;
创建对象：
ServerSocket();
ServerSocket(int port);
//参数port指定服务的监听端口;
常用方法：
public Socket accept(); //启动监听
public void close(); //结束监听

Socket类
负责服务端和客户端进行通讯的类;
创建对象：
Socket(InetAddress remoteHost,int remotePort);
//参数remoteHost指定连接的远程机器的IP地址
//remotePort指定远程机器提供服务的监听端口
常用方法：
public InetAddress getInetAddress(); //读取连接到此
//socket上的机器地址
public InputStream getInputStream(); //返回这个
//socket的输入流
public OutputStream getOutputStream();//返回这个
//socket的输出流
public void close(); //关闭socket

上机程序
编写程序：设计一个学生类Student，其中成员变量应包括：学号ID(String)，姓名Name(String)，年龄Age(int)， 专业Profession(String)，Java成绩Score(double), 提供方法printInfor()打印学生所有信息，并编写一个测试类StudentDemo进行测试。

class student{
	String	ID,Name,Profession;
	int Age;
	double Score;
	student(){
		ID="000000000";
		Name="无";
	    Profession="无";
	    Age=0;
	    Score=0.0;
	}
	student(String id, String name, String profession,
			int age, double score){
		ID=id;
		Name=name;
	    Profession=profession;
	    Age=age;
	    Score=score;
	}
	void printInfor(){
		System.out.println("学生信息如下："+"学号："+ID+"  姓名："+Name
                   +"  专业："+Profession+"  年龄:"+Age+"  分数："+Score);
	} 
}
public class studentDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		student s1=new student();
		student s2=new student("201411111","张三","电子信息工程",22,80);
		s1.printInfor();
		s2.printInfor();
	}
}

结果
学生信息如下：学号：000000000 姓名：无 专业：无 年龄:0 分数：0.0
学生信息如下：学号：201411111 姓名：张三 专业：电子信息工程 年龄:22
分数：80.0

（4）1、编写一个窗体，其功能为：在窗口上摆放两个标签。构造第一个标签时，令其上面的文本信息为“我将参加Java程序设计考试。”，将第二个标签构造为空标签。程序将第一个标签的信息复制到第二个标签上，并增加信息“希望自己考取好成绩。”。要求第一个标签以红色为背景，绿色为前景；第二个标签以绿色为背景，蓝色为前景。请根据注释填空，实现该窗体的功能。

import java.awt.*;
import javax.swing.*;
class LabelFrame extends JFrame{
JLabel  p1=new JLabel("我将参加Java程序设计考试。");
	            （1）                        //声明创建第二个标签p2 
	public LabelFrame( ){
//设置窗体的布局
setLayout(new FlowLayout());
p1.setOpaque(true);//设置标签可透明
 p2.setOpaque(true);
		        （2）                     //添加第一个标签        
                （3）                        //添加第二个标签     
        
        //将第一个标签的信息复制到第二个标签上，并增加信息“希望自己考取好成绩”。
		        （4）                                              
p1.setBackground(Color. red);
		        （5）                     //设置第一个标签的前景颜色
		        （6）                     //设置第二个标签的背景颜色
		p2.setForeground(Color.blue);
	}
	public static void  main(String[] args){
		LabelFrame myFrame = new LabelFrame();
		myFrame.setTitle("标签窗体");
		myFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		myFrame.setSize(250,250);
		        （7）                       //设置窗体的可见性         
	}
}

注意：设置背景颜色程序使用语句：
setBackground(Color.red);
设置前景颜色程序使用语句：
setForeground(Color.red);
因为Java中控件默认下是不透明的，因此如果想显示背景颜色，我们需要添加语句p1.setOpaque(true);来设置标签可透明。

2.编写一个窗体，包括一个用于给出提示信息的标签和两个文本框，其中，一个输入文本框用于获取用户给出的一个整数，求该数的平方后将计算结果置在另一个输出文本框中输出。请根据注释将程序补充完整，并执行成功。（注意：数值型数据与字符串之间的相互转换）

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
class ComputeFrame extends JFrame implements  ActionListener{
    
        //声明控件    
                         （1）                             
	public ComputeFrame ( )
	{
	    //创建控件
                            （2）                          
	    
setLayout(new FlowLayout());
	    //添加控件
                               （3）                       
        
//为输入文本框增加监听
                          （4）                    
	}
  	public  void  actionPerformed(ActionEvent  evt)
   	{       
   		//求输入数字的平方后将计算结果置在另一个输出文本框中输出。
                                     （5）                          
   	}
	public static void  main(String[] args){
		ComputeFrame myFrame = new ComputeFrame ();
		myFrame.setTitle("Show");
		myFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		myFrame.setSize(250,250);
		myFrame.setVisible(true);
	}
}

阅读下面程序，按照注释填加语句，并分析理解程序的执行结果和过程。

class WriteWordThread extends Thread {
    WriteWordThread(String s){ 
       setName(s);
    }
  public void run(){
    for(int i=1;i<=8;i++)
    System.out.println("我是一个线程，我的名字是"+getName());
   } 
 }
public class Example{
    public static void main(String args[ ]){  
           WriteWordThread zhang,wang;
           
//创建zhang线程对象，名字为“张无忌”
zhang=new WriteWordThread("张无忌");
           //创建wang线程对象，名字为“王保保”
  wang=new WriteWordThread("王保保");  

//zhang线程开始执行；
           zhang.start();  
for(int i=1;i<=8;i++){ 
                 System.out.println("我是主线程中的语句");                  
            }
           
//wang线程开始执行；
wang.start();       
} 
}