Java程序设计基础(题库)

选择题  20’

一、选择：

知识点：Java 语言概述

1.编译Java程序的命令文件名是（ C ）

A.  java.exe      B.  java.c    C.  javac    D.  appletviewer.exe 

2.  Java语言与其他语言相比，独有的特点是（C）

A  面向对象     B 多线程      C 平台无关性    D 可扩展性   

3.  编译Java程序filename.java 后，生成的程序是（C）

A  filename.html   B  filename.jav   C  filename.class   D  filename.jar 

4.  下面声明Java应用程序main(  )方法中，正确的是（A ）

   A  public static void main(String args[ ]){……}

   B  private static void main(String args[ ]){……}

   C  public void main(String args[ ]){……}

   D  public static void main(String args){……}

知识点： 数据类型

8.  定义a 为int 类型变量。下面正确的赋值语句选项是（ ）

   A int a=6；  B a==3       C a=3.2f   D a+=a*3

10. 下列有关Java布尔类型的描述中，正确的是

　　A 一种基本的数据类型，它的类型名称为boolean

　　B 用int表示类型

　　C 其值可以赋给int类型的变量

D 有两个值，1代表真，0代表假

知识点：变量定义

13. 下面变量定义错误的是（）

A float x; y;                  B float x,y=2.33f    

C public int i=100,j=2,k;        D char ch1=’m’,ch2=’\’;

16.  下列变量定义正确的是（ ）

   A double d;     B float f=6.6;    C byte b =130;   D boolean t=”true”;

知识点：数组

17. 设有定义语句”int a[ ]={66,88,99}”，则关于该语句的叙述错误的是（）

A 定义了一个名为a的一维数组    B a 数组有三个元素

C a数组的下标为1~3             

D 数组中的每个元素的数据类型都是int型

18. 若已定义：”int a[ ]={0,1,2,3,4,5};”，则对a数组元素正确的引用是（）\

   A a[－1]       B a[6]         C a[5]      D a(0)

19. 现有整型数组int a [ ]={10,21,28,-3,84,55};为了打印输出数组的各个元素，下面正确的代码是（ ）

A for(int i=0;i<=6;i++) B for(int i=0;i<5;i++)

     System.out.println(a[i]);              System.out.println(a[i]);

C for(int i=0;i     System.out.println(a(i));              System.out.println(a[i]);

知识点：类和对象

21. 定义类头时可以使用的访问控制修饰符是（ ）

A  public  B abstract  C private   D static 

23. 定义一个类Point,类中有两个double型变量x和y，对于构造函数的声明错误的是（A）

   A Point Point(int x){…..}        B public Point(int x ){……}

   C public Point ( int x ,int y){…..}  D public Point(Point p ){……}

24. 有关类的说法正确的是（B）

   A 类具有封装性，所以类的数据是不能被访问的

   B 类具有封装性，但可以通过类的公共接口访问类中的数据

   C 声明一个类时，必须用public修饰符

   D 每个类中，必须有main方法，否则程序无法运行

26. 以下关于构造函数及其重载的说法正确的是（D）

   A  类定义了构造函数，Java就不会自动为该类创建默认的不带参数的构造函数

   B  构造函数不能对私有变量初始化

   C 一个类中含有几个构造函数，称为构造函数的重载。对于重载的函数，其参数列表可以相同。

   D 重载的构造函数之间可以通过关键字this在构造函数中的任意位置相互调用

27. 以下关于类对象的使用，说法正确的是（B）

   A 通过构造函数实例化一个类对象后，在类的内部，不管变量的访问修饰符是私有的还是共有的，都可以通过“对象名 . 变量名”对变量进行访问

   B 在类的外部调用类对象拥有的方法必须用“对象名 . 方法名（）”

   C 同一个类的对象之间可以赋值，且他们分别代表不同的对象

   D 类对象可以作为方法的参数，这时在方法体中可以引用对象的变量和调用对象的方法

知识点：继承

29. 下列关于继承的哪项叙述是正确的？(D)

   A）在java中允许多重继承

   B）在java中一个类只能实现一个接口

   C）在java中一个类不能同时继承一个类和实现一个接口

   D）java的单一继承使代码更可靠

32.  Java中所有类的父类是（D ）

A  Father      B  Lang        C  Exception        D  Object

知识点：事件

33. 下列Java常见事件类中哪个是鼠标事件类？（C）

   A  InputEvent

   B  KeyEvent

   C  MouseEvent

   D  WindowEvent

34. 下列为窗口事件的是(B)

　　A  MouseEvent

　　B  WindowEvent

　　C  ActionEvent

D  KeyEvent

知识点：接口

35. 若有以下类声明：

   Public class A extends B implementsC,D{….}

   下面说法错误的是（A ）

A  这个声明是错误的

B  类A继承自父类B

C  C和D是接口，类头的定义声明类A实现接口C和D

D  关键字extends指明类的继承关系

知识点：图形界面

38. 下列哪个选项是创建一个标识有"关闭"按钮的语句？（C ）

　　A）TextField  b = new  TextField（"关闭"）;

　　B）TextArea  b = new  TextArea （"关闭"）;   

　　C）Button   b = new  Button（"关闭"）;

D）Checkbox  b = new  Checkbox（"关闭"）;

知识点：异常

39. 下列常见的系统定义的异常中，哪个是输入、输出异常?（B）

    A）ClassNotFoundException

    B）IOException

    C）FileNotFoundException

D）UnknownHostException

40. 下列常见的系统定义的异常中，哪个是数组越界异常?（A）

　　A）ArrayIndexOutOfBoundsException

　　B）IOException

　　C）NullPointerException

D）ArithmeticException

填空题 20’

知识点：类和对象

1．类是Java中的一种重要的复合数据类型，是组成Java程序的基本要素。一个类的实现包括两部分：  类声明 、    类体  。

2. Java程序里，对象是类的一个___实例__。运算符   new       为对象分配内存空间，它调用对象的构造方法，返回引用。

3．成员变量表示对象的____特征____，成员方法表示对象的___行为_____。

4. 构造函数的方法名必须与__类_____名相同，使用运算符__new_____创建类的对象，给对象分配内存空间。

知识点：接口

5. 定义接口和定义类相似，只是要把定义类的关键字___class_____换为   interface       。

6. 在Java中能实现多重继承效果的方式是__接口____。

知识点：方法

9. 面向对象的语言将客观世界都看成由各种对象所组成的，共同特征和行为的对象组成类，类是___属性_____和___方法_____的集合。

12. 同一个类中多个方法具有相同的方法名，不同的参数列表称为方法的__重载___。

知识点：继承

14.一个类可以从它的父类中继承所有的属性和方法。采用这种方法可以提高软件的____重用性______。

15.在Java程序里类之间的继承关系只能是___单继承_______。

16. 继承就是在已经存在类的基础上再扩展产生新的类。已经存在的类称为__父类____，新产生的类称为___子类_____。

知识点：接口

知识点：文件

程序填空 30’   10

知识点：循环结构  

1．本程序的功能是输出0到20之间所有奇数的和。

public class Exam_1{

    public static void main(String[] args) {

        int sum=0;

       int i=0;

while(i<20){

          if(i %2!=0或i%2==1)

                sum=sum+i;

             i=i+1或i++或++i;

          }

        System.out.println("sum="+sum);

}

}

2．本程序计算20以内的随机整数的阶乘。

import java.util.Random;

public class Exam_1{

    public static void main(String args[]){

        Random random = new Random();

        float x = random.nextFloat();//产生0.0与1.0之间的一个浮点数

        int n = Math.round(20*x);  //构造20以内的一个整数

        long f = 1 ;  //保存阶乘的结果

        int k = 1;  //循环变量

   //*********Found********

        do { f=f*k;

           k++;

            } while(k<=n);      

        System.out.println(n+"!= "+f);

    }

}

3．本程序显示数组的长度及每个数组元素的值。

public class ArrayLength {

    public ArrayLength() {

    }

    public static void main(String[] args) {

        int c[]=new int[]{1,4,7,2,5};

        System.out.println("the Length is "+ c.length);

        for(int i=0;i        {

            System.out.println("c["+i+"]="+ c[I ]);

        }

    }

}

4.本程序求1到100的和。

public class Sum {

    public Sum() {

    }

    public static void main(String[] args) {

    int i=1, sum=0;//分别表示个数与累加和

    do{

        sum=sum+i; //进行累加求和

       i=i+1; //进行个数加1

}while(i<=100);

    System.out.println("1+2+3+...+100="+ sum);//输出累加的最后结果

    }

}

知识点：异常     

1．本程序为从控制台读取一个字符

public class SqrtException {

    public SqrtException() {

    }

    public static void main(String[] args) {

     try {

          int ch=System.in.read();

      }catch(Exceptione){

          System.out.println(getMessage()); //显示异常信息

      }finally{

          System.out.println("into finally");

      }

    }

}

2．本程序为把字符串转换为相应的整形数值。

public class ExT {

    public ExT() {

    }

    public static void main(String[] args) {

      int n=0,m=0,t=555;

      try {

          m=Integer.parseInt("8888");

          n=Integer.parseInt("abc7");

          t=9999;

      } catch (NumberFormatException e)

      {

          System.out.println("发生异常："+e.getMessage());

         e.printStackTrace();//打印异常信息在程序中出错的位置及原因

          n=123;

      }

      System.out.println("n="+n+",m="+m+",t="+t);

    }

}

3．本程序为读取一个文本文件

import java.io.*;

public class Test

{

    public static void main(String[] args)

    {

        FileInputStream fis = null;

      try {

            fis = new FileInputStream("c:/a.txt");    

            int b;    

            b = fis.read();

            while(b!= -1)

            {

                System.out.print((char)b);

                b = fis.read();

            }

            //移到finally中去执行

            //fis.close();

        }

        catch (Exception e)

        {

            System.out.println("错了");

        }

       finally

        {

            try

            {

                fis.close();

            }

            catch(IOException ioe)

            {

                System.out.println("关闭文件出错！");    

            }

        }        

    }

}

4．本程序中MyException为自定义异常类，Test类中对输入的字符串进行测试，如果不是“食物”，则抛出异常。

public class Test

{

        void eating(String s) throws Exception

        {

                if (s.equals("食物"))

                {

                        System.out.println("真好吃啊!");

                }

                else

                {

                        Throw new MyException("不是食物不能吃啊");

                }

        }

        public static void main(String[] s)

        {

                Test person = new Test();

                try

                {

                person.eating("不是食物");

                }

                catch(Exception e)

                {

                        System.out.println(e);

                }

        }

}

  class MyException extends Exception

{

    public  MyException ()

    {

        super();

    }

    public MyException(String s)

    {

        super(s);

    }

}

知识点：数组

1. 本程序为定一个整型数组，输出数组的长度

public class ArrayDf

{

    public static void main(String[] args)

    {

        int [] intArray;

        intArray = new int[10];

        System.out.println("数组长度："+ intArray.length);

    }    

}

2．本程序利用数组输出20以内的奇数

public class DynaInitArray

{

        public static void main(String[] args)

        {

                int[] a;

                a = new int[10];

                for (int i = 0;i<10;i++)

                {

                        a[i] = 2*i+1;

                        System.out.println("a[i]=" + a[i]);

                }        

        }    

}

3．本程序为把数组a的第四个数组元素值修改为31，并显示修改前和修改后数组a的全部数组元素

public class ArrayCopy

{

  public static void main(String[] args)

  {

    int[] a = {12,3,19,2,10,13,9};

    int[] b;

    b = a;

    System.out.println("Before Modifying:");

for (int i = 0;i    {

      System.out.print("a["+i+"]=" +a[i] + "    ");

    }

    System.out.println("");

    b[3]=31;

    System.out.println("After Modifying:");

for (int i = 0;i    {

      System.out.print("a["+i+"]=" +a[i] +"    ");

    }    

  }  

}

4．本程序为把数组a 的部分数组元素拷贝到数组b的后5个数组元素中，并且显示出数组b经修改前、后的数组元素值。

public class ArrayCopy2

{

        public static void main(String[] args)

        {

                int[] a = new int[10];

                int[] b = new int[10];

                System.out.println("Before Copying:");

for (int i = 0;i<10;i++)

                {

                        a[i]= i+1;

                        b[i] = (i+1)*100;

                        System.out.print("b["+i+"]=" +b[i] + "    ");

                }

                System.out.println("");

                System.arraycopy(a,2,b,5,5);

                System.out.println("After Copying:");

for (int i = 0;i                {

                        System.out.print("b["+i+"]=" + b[i] + "    ");

                }

        }    

}

知识点：线程        

1．本程序利用线程显示1-99之间的数

public class TestThread extends Thread {

        public void run()

        {

for(int i = 0;i<100;i++)

                System.out.println("Count:"+i);

        }

        public static void main(String[] args)

        {

                TestThread tt = new TestThread();

              tt.start

                       }    

}

2．本程序利用线程显示0-9之间的所有整数

public class RunnableThread implements  Runnable

{

        //实现接口Runnable中的run方法

        public void run()

        {

for (int k = 0;k<10;k++)

                {

                        System.out.println("Count:"+k);

                }        

        }

        public static void main(String[] args)

        {

                RunnableThread rt = new RunnableThread();

                Thread t = new Thread(rt);

                 t.start();

                      }    

}

3．本程序在显示0-30之间的整数时，每隔10个数，休眠2秒。

public class ThreadState

{

        public static void main(String args[]) 

        {

                TestThreadState tts = new TestThreadState();

                Thread t = new Thread(tts);

                t.start();

        }

}

class TestThreadState implements Runnable 

{

        public void run() 

        {

for(int i=0; i<30; i++)

                {    

                        if(i%10==0 && i!=0) 

                        {

                                try

                                {

                                        System.out.println("Before sleeping:"+Thread.currentThread().isAlive());

                                        Thread.sleep (2000); 

                                        System.out.println("After sleeping:"+Thread.currentThread().isAlive());

                                }

                                catch(InterruptedException e)

                                {

                                        e.printStackTrace();

                                }            

                        }

                        System.out.println("No. " + i);

                }

        }

}

4．本程序利用2个线程分别显示0-19之间的整数

public class MutiThread

{

        public static void main(String[] args)

        {

                RunningObject ro = new RunningObject();

                Thread t1 = new Thread(ro,"1st");

               Thread t2 = new Thread(ro,"2nd");

                t1.start();

                t2.start();

        }

}

class RunningObject implements Runnable {

        public void run() {

for(int i=0; i<20; i++) {

                        String name = Thread.currentThread().getName();

                        System.out.println(name + ": " + i);

                }

        }

}

程序运行结果  4*5

知识点：线程

程序运行结果：

1.

class FruitThread extends Thread{

    public FruitThread(String name){

        super(name);

    }

    public void run(){

        System.out.println(this.getName());

        System.out.println("Done"+this.getName());

    }

}

public class TwoFruit {

    public static void main(String[] args) {

        new FruitThread("苹果").start();

    }

}

程序运行的结果是：

苹果   

Done苹果

2.

public class ThreadRunnable implements Runnable{

    int count = 1,number;

    public ThreadRunnable(int num) {

        number=num;

        System.out.println("创建线程  "+number);

    }

    public void run(){

        while(true){

            System.out.println("线程 "+number+":计数"+count);

            if(++count==3) return;

        }

    }

    public static void main(String[] args) {

       new myThread(1).start();

    }

}

程序运行的结果是：

创建线程  1线程 1:计数1  线程 1:计数2

3. 

public class test implements Runnable{    

    public void run(){

for(int i=3;i<=15;i++){

            if(isPrime(i))

                System.out.print(i+"\");

        }

    }

    public boolean isPrime(int n){

        boolean b=true;

for(int i=2;i            if(( n%i)==0)  b=false;

        }

        return b;

    }

    public static void main(String[] args) {

        Thread a=new Thread(new test());

        a.start();

    }

}

程序运行的结果是：

3    5    7    11    13

4.

class threadA implements Runnable{

    public void run(){

for(int i=0;i<10;i++){

            System.out.println("i = "+i);

            if(i==2)break;

        }

    }

}

public class test {    

    public static void main(String[] args) {

        Thread a=new Thread(new threadA());

        a.start();

    }

}

程序运行的结果是：

i = 0   i = 1   i = 2

知识点：流

程序运行结果：

1.

import java.io.*;

public class Untitled2 {

   public static void main(String[] args) throws IOException {

        int count=0,b;

        System.out.println("please input data:");

        while((char)(b=System.in.read())!='N'){

            System.out.print((char)b);

            count++;

        }

        System.out.println();

        System.out.println("you have input "+count+" chars!");

    }

}

键盘输入的内容：1234N

程序运行的结果是：

1234   you have input 4 chars!

2.

public class FileInputStreamTest {

    public static void main(String[] args) throws Exception {

        String str="12345";

        File file=new File("test.txt");

        FileInputStream fis=new FileInputStream(file);

        byte bytes[]=new byte[fis.available()];

        fis.read(bytes);

        fis.close();

        System.out.println(new String(bytes));

    }

}

注：test.txt文件中的内容是abcdef

程序运行的结果是：

abcdef

3.

import java.io.*;

public class FileInputStreamTest {

    static String name="test.txt";

    static BufferedReader br=null;

    public static void main(String[] args) throws Exception {

       try{

           File f=new File(name);

           FileReader fr=new FileReader(f);

           br=new BufferedReader(fr);

          String str=br.readLine();

          System.out.println(str.toLowerCase());

       }

       finally{

           if(br!=null)

               br.close();

       }

    }

}

注：test.txt文件中的内容：aBcDEfG

程序运行的结果是：

abcdefg

import java.io.*;

public class FileInputStreamTest {

    static String name="test.txt";    

    public static void main(String[] args) throws Exception {

       try{

           FileOutputStream fos=createfile();

           writeFile(fos);

       }catch(IOException ioe){

           System.out.println(ioe.getMessage());

       }       

    }

    static FileOutputStream createfile() throws IOException{

        File f=new File(name);

        FileOutputStream fos=new FileOutputStream(f);

        return fos;

    }

    static void writeFile(FileOutputStream o)throws IOException{

        DataOutputStream dos=null;

        try{

            dos=new DataOutputStream(o);

            dos.writeBytes("Hello".toUpperCase());

        }finally{

            if(dos!=null) dos.close();

        }

    }

}

程序运行以后，test.txt文件中的内容是：

HELLO

知识点：类、对象、函数

1． 

 class  Example

{

   static double PI=3.14156;

   static double  area(int r)

{

 return PI*r*r;

}

static float area(int p_width,int p_high)

{

return p_width*p_high;

}

static double area(int a,int b,int c)

{

double s=(a+b+c)/2;

return Math.sqrt(s*(s-a) *(s-b) *(s-c)); //方法sqrt()功能是开方

}

public static void main(String args[ ])

{

int a=5,b=4,c=3;

System.out.println(“圆的面积：”+area(a));

System.out.println(“长方形的面积：”+area(a,b));

System.out.println(“三角形的面积：”+area(a,b,c));

}

}

程序运行的结果是：

圆的面积：78.539长方形的面积：20.0三角形的面积：6.0

2． 

  class a1

{int x=9;  }

class cc extends a1

{ int x=25;

 public static void main(String args[])

 {

  int s1,s2;

  a1 p=new a1();

  cc p1=new cc();

  s1=p.x;

s2=p1.x;

System.out.println(“s1”+s1);

System.out.println(“s2”+s2);

}

}

程序运行的结果是：

s19s225

3． 

public class A implements B

{ static int m;

  public static void main(String args[ ])

  { m=B.k ;

   System.out.println(m);

   A  a=new A();

   a.myMethod();

  }

public  void  myMethod()

   {  System.out.println(++m);   }

}

interface B

{

  int k=5;

  void myMethod();

}

程序运行的结果是：

5  6

4．

class Person{

    public String name;

    public int age;

    public void show(){

        System.out.println("name=" + name);

        System.out.println("age=" + age);

    }

}

class Student extends Person{

    public String school;

    public void show(){

        super.show();

        System.out.println("school="+school);

    }

}

public class Test5 {

    public static void main(String[] args) {

        Student s1=new Student();

        s1.name="张三";

        s1.age=20;

        s1.school="长春职业技术学院";

        Person p1=s1;

        p1.show();

    }

}

程序运行的结果是：

name=张三   age=20   school=长春职业技术学院

知识点：循环结构

1.

public class Test {

    public static void main(String[] args) {

        int sum=3,a=4,b=6,c=7;

while(a            while(b!=c){

                sum+=b;

                b++;

            }

            b=6;

            a++; 

        }

        System.out.println(sum);

    }    

}

程序运行的结果是：

15

2.

public class Test {

    public static void main(String[] args) {

       int x=10;

for(int i=5;i<20;i++){

           if(i==10) break;

           x++;

       }

       System.out.println(x);

    }    

}

程序运行的结果是：

15

3.

public class Test {

    public static void main(String[] args) {

       int a=16,b=2;

       do{

           a/=b;

}while(a>3);

       System.out.println(a);

    }    

}

程序运行的结果是：

2

4.

public class Test {

    public static void main(String[] args) {

for(int i=0;i<10;i++){

           if(i%2==0) continue;

            if(i%7==0) break;

           System.out.print(i);

       }

    }    

}

程序运行的结果是：

135

操作题

知识点：类和对象 

一、编写一个类，类名为：梯形。此类包括4个成员变量（即属性）：上底、下底、高、面积，四个成员变量的数据类型均为单精度浮点型。此类包括2个构造方法，分别为一个无参数的构造方法和一个3个参数(参数名分别为上底、下底、高)的构造方法（构造方法的内容为对上底、下底、高三个成员变量赋初始值）。该梯形类还包括一个无参数、有返回值的普通方法：计算面积，此方法的功能为根据上底、下底、高来计算面积，并返回面积的值。编写一个测试类，类名为Test ,对梯形类进行测试。（30分）

要求：

1.梯形类的名字、成员变量、方法均为中文名称；

2. 测试类的名字使用题目给出的英文名称；

3. 梯形类和测试类放在一个文件中进行编写;

4．程序的入口类为测试类;

程序运行情况

1．使用无参数的构造方法建立对象t1,调用其计算面积方法，在控制台输出面积的值

2．使用有参数的构造方法建立对象t2, 上底初始值设为2.0f,下底初始值设为3.0f,高的初始值设为4.0f ,调用其计算面积方法，在控制台输出面积的值。

评分标准：

1．正确建立梯形类的4个成员变量（3分）

2．正确建立无参数的构造方法 （2分）

3．正确建立有参数的构造方法（4分）

4．正确建立计算面积方法（6分）

5．正确建立测试类 （3分）

6．正确建立对象t1 ,（2分）

7．正确输出t1的普通方法，（3分）

8．正确建立对象t2,（4分）

9．正确输出t2 的普通方法，（3分）

正确答案：

public class Test {

    public Test() {

    }

    public static void main(String[] args) {

        梯形 t1=new 梯形();

        System.out.println(t1.计算面积());

        梯形 t2=new 梯形(2.0f,3.0f,4.0f);

        System.out.println(t2.计算面积());

    }

}

class 梯形

{

    float 上底,下底,高,面积;

    梯形()

    {

    }

    梯形(float 上底,float 下底,float 高)

    {

        this.上底=上底;

        this.下底=下底;

        this.高=高;

    }

    public float 计算面积()

    {

        面积=(上底+下底)*高/2;

        return 面积;

    }

}

二、编写一个类：People,  包括三个属性name（字符串类型） , age （整型）, sex（字符串类型）。为其建立4个构造方法，分别为一个无参数的构造方法、一个包含参数为name 的构造方法（方法内容为对name成员变量赋初值）、一个包含参数为name和age两个参数的构造方法（方法内容为对name、age两个成员变量赋初值）、一个包含参数为name、age、sex三个参数的构造方法（方法内容为对name、age、sex三个成员变量赋初值）。包含一个无参数无返回值的普通方法show(),此方法的功能为输出name 、age、 sex 三个成员变量的值，show方法的输出格式为“姓名为：**,年龄为：**,性别为：*”。编写测试类Test,分别使用四个构造方法创建对象p1,p2,p3,p4, 且分别调用其show()方法。

要求：

1.类名、成员变量名、方法名分别使用题目给出的英文命名

2. People类和测试类放在一个文件中进行编写;

3. 程序的入口类为测试类;

程序运行情况：

１.使用无参数的构造方法建立对象p1,调用其show()方法，在控制台能够查看输出。

2.使用带有一个参数的构造方法建立对象p2,name值设为 “马晓春”调用其show()方法，在控制台能够查看输出。

3.使用带有2个参数的构造方法建立对象p3,name值设为 “常昊”，age设为 34，调用其show()方法，在控制台能够查看输出。

4.使用带有3个参数的构造方法建立对象p4,name值设为 “聂卫平”， age 设为 58，sex设为 “男”，调用其show()方法，在控制台能够查看输出。

评分标准：

1．正确建立People类的属性3分

2．正确建立People类的无参数构造方法２分

3．正确建立People类的有参数的三个构造方法９分

4．正确建立People类的show()方法5分

5．正确建立测试类３分

6．正确建立People类的４个对象４分

7．４个对象正确调用其show()方法４分

正确答案：

public class Test {

    public Test() {

    }

    public static void main(String[] args) {

     People p1=new People();

     p1.show();

     People p2=new People("马晓春");

     p2.show();

     People p3=new People("常昊",34);

     p3.show();

     People p4=new People("聂卫平",58,"男");

     p4.show();

    }

}

class People

{

    String name,sex;

    int age;

    People()

    {

    }

    People(String name)

    {

        this.name=name;

    }

    People(String name,int age)

    {

        this.name=name;

        this.age=age;

    }

    People(String name,int age,String sex)

    {

        this.name=name;

        this.age=age;

        this.sex=sex;

    }

    public void show()

    {

        System.out.println("姓名为："+name+",年龄为："+age+",性别为："+sex);

    }

}

三 编写一个类Dog ，包括一个私有整型的成员变量weight。Dog类中包括2个构造方法，分别为一个无参数的构造方法和一个有参数的构造方法（构造方法的内容为对weight成员变量赋初始值）。在Dog类中为weight成员变量添加其对应的get()

方法和set()方法。在主函数中对Dog类进行测试，分别使用有参数的构造方法和无参数的构造方法创建对象。在控制台输出显示“使用带参数的构造方法,狗的体重为:15”、“使用无参数的构造方法,狗的体重为:20”

要求：

1.类名、成员变量名、方法名分别使用题目给出的英文命名

2. 程序的入口即为Dog类

3．setWeight ()的参数名为weight,数据类型与成员变量的数据类型相同.

4．Get方法要求有返回值

5．测试时为成员变量赋值使用带有参数的构造方法以及set方法

6．测试时获取成员变量的值必须使用get方法。

程序运行情况：

1．正确使用无参数的构造方法创建对象d1.

2．正确使用带参数的构造方法创建对象d2，并同时为weight赋初值。

3．d1使用set方法为weight赋初值

4．分别调用d1以及d2的get（）方法完成在控制台的输出。

评分标准：

1．正确定义weight成员变量（2分）

2．正确定义无参数的构造方法（2分）

3．正确定义有参数的构造方法（3分）

4．正确定义weight的set()方法（5分）

5．正确定义weight的get()方法（5分）

6．正确使用无参数构造方法创建对象d1(2分)

7．正确使用有参数构造方法创建对象d2(3分)

8．正确调用set()方法（2分）

9．正确调用get()方法，且显示输出（6分）

正确答案：

public class Dog

{

        private int weight;

        public Dog()

        {

        }

        public Dog(int dog_weight)

        {

                weight = dog_weight;

        }

        public void setWeight(int weight)

        {

            this.weight=weight;

        }

        public int getWeight()

        {

            return weight;

        }

        public static void main(String[] args)

        {

                Dog d1 = new Dog(15);

                System.out.println("使用带参数的构造方法,狗的体重为:"+d1.getWeight());

                Dog d2=new Dog();

                d2.setWeight(20);

                System.out.println("使用无参数的构造方法,狗的体重为:"+d2.getWeight());

        }

}

四、编写一个类Student ,包括4个属性（即成员变量）：name(字符串类型)、sex(性别)、grade(整型)、age(整型)。为这个4个属性分别建立其对应的get 方法和set方法。在main方法中定义Student类的对象，调用其相应的set方法为name赋值为“张三”、为sex赋值为“男”、为grade赋值为1，为age赋值为20。然后调用其相应的get方法在控制台成功输出显示“姓名：张三  性别:男  年级:1  年龄20”。

”

要求：

1.类名、成员变量名、方法名分别使用题目给出的英文命名

2. 程序的入口即为Student类

3．setName()的参数名为name,数据类型与成员变量的数据类型相同 ,setSex()的参数名为sex, ,数据类型与成员变量的数据类型相同 ，setGrade()的参数名为grade ,数据类型与成员变量的数据类型相同 ，setAge()的参数名为age，,数据类型与成员变量的数据类型相同。

4．Get方法要求有返回值

5．测试时为成员变量赋值必须使用set方法

6．测试时获取成员变量的值必须使用get方法。

程序运行情况：

5．定义Student 类的对象s

6．调用对象s的setName()方法，为name赋值为“张三”

7．调用对象s的setSex()方法，为sex赋值为“男”

8．调用对象s的setGrade()方法，为grade赋值为1

9．调用对象s的setAge()方法，为age赋值为20

10．调用对象s相应的get()方法，在控制台输出显示“姓名：张三  性别:男  年级:1  年龄20”。

11．

评分标准：

1．正确定义4个属性（4分）

2．正确定义4个属性的set（）方法（8分）

3．正确定义4个属性的get()方法（8分）

4．正确定义Student 类的对象S (2分)

5．正确为属性赋值（4分）

6．程序正常运行，显示输出结果（4分）

     正确答案：

public class Student

{

        //定义属性

        String name;

        String sex;

        int grade;

        int age;

        //定义属性“name”的设置方法

        public void setName(String _name)

        {

                name = _name;

        }

        //定义属性“name”的获取方法

        public String getName()

        {

                return name;

        }

        //定义属性“Sex”的设置方法

        public void setSex(String _sex)

        {

                sex = _sex;

        }

        //定义属性“Sex”的获取方法

        public String getSex()

        {

                return sex;

        }

        //定义属性“grade”的设置方法

        public void setGrade(int _grade)

        {

                grade = _grade;

        }

        //定义属性“grade”的获取方法

        public int getGrade()

        {

                return grade;

        }

        //定义属性“age”的设置方法

        public void setAge(int _age)

        {

                age = _age;

        }

        //定义属性“age”的获取方法

        public int getAge()

        {

                return age;

        }

        //主方法

        public static void main(String[] args)

        {

                Student s = new Student();

                s.setName("张三");

                s.setSex("男");

                s.setGrade(1);

                s.setAge(20);

                System.out.println("姓名："+s.getName()+"  性别:"+s.getSex()+"  年级:"+s.getGrade()+"  年龄"+s.getAge());

        }

}