Java笔试题摘录-基础中的基础

1.存在使i + 1 < i的数吗()
答案:存在
解析:如果i为int型,那么当i为int能表示的最大整数时,i+1就溢出变成负数了,此时不就<i了吗。
2.存在使i > j || i <= j不成立的数吗()
答案:存在
解析:比如Double.NaN或Float.NaN
3.下面哪个流类属于面向字符的输入流( )
A BufferedWriter B FileInputStream C ObjectInputStream D InputStreamReader
答案:D

解析:Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。
以InputStream(输入)/OutputStream(输出)为后缀的是字节流; 以Reader(输入)/Writer(输出)为后缀的是字符流。
4. ArrayList list = new ArrayList(20);中的list扩充几次()
5.下面程序的运行结果是什么()
class HelloA { public HelloA() {
        System.out.println("HelloA");
    }

    { System.out.println("I'm A class"); } static { System.out.println("static A"); }


public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }

    { System.out.println("I'm B class"); } 
    static { System.out.println("static B"); }
    public static void main(String[] args) { new HelloB(); 
   }

}
答案:
static A
static B
I'm A class
HelloA
I'm B class
HelloB
6.下面代码的运行结果为:()
import java.io.*; 
import java.util.*; 
public class foo{ 
    public static void main (String[] args){

        String s;

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

    }

}
答案:由于String s没有初始化,代码不能编译通过;Java中所有定义的基本类型或对象都必须初始化才能输出值。

7.选项中哪一行代码可以替换题目中//add code here而不产生编译错误?()
Apublic abstract void method(int a);

B constInt = constInt + 5;

C public int method();

D public abstract void anotherMethod() {}

答案:A

解析:考察抽象类的使用。
8. 阅读Shape和Circle两个类的定义。在序列化一个Circle的对象circle到文件时,下面哪个字段会被保存到文件中? ( )
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Shape 

    public String name;

}
public class Circle extends Shape implements Serializable{ 
    
private float radius; 

transient int color; 
public static String type = "Circle";

public static void main(String[] args) {
     //1.try-with-resource创建文件流
     try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:/eclipse/workspace/work/circle.txt"))){
         
         Circle circle = new Circle();
        //2.将对象序列化到文件
         oos.writeObject(circle);
         
     } catch (Exception e) {
         e.printStackTrace();
     }
    
 }
}

A name

B radius

C color

D type

答案:B
解析 1.父类无序列化,2.transient 3.static (反序列化时可以看到这个值,不过值为类的静态值而不是反序列化值)

9.输出内容
public class Dervied extends Base { 
        private String name = "dervied"; 
    public Dervied() {
              tellName();
              printName();
    } 
    public void tellName() {
        System.out.println("Dervied tell name: " + name);
    }
    public void printName() {
        System.out.println("Dervied print name: " + name);
    }
    public static void main(String[] args){ new Dervied();    
    }
}
class Base { 
    private String name = "base"; 
    public Base() {
        tellName();
        printName();
    } public void tellName() {
        System.out.println("Base tell name: " + name);
    } public void printName() {
        System.out.println("Base print name: " + name);
    }
}
答案:
Dervied tell name: null
Dervied print name: null
Dervied tell name: dervied
Dervied print name: dervied
10.以下程序的执行结果是什么
class Base{

    void test() {

      System.out.println(“Base.test()”);

    }

  }

  public class Child extends Base {

    void test() {

      System.out.println(“Child.test()”);

    }

    public static void main(String[] a) {

      Child anObj = new Child();

      Base baseObj = (Base)anObj;

      baseObj.test();

    }

  }

A Child.test() Base.test()

B Base.test() Child.test()

C Base.test()

D Child.test()

解答:D

测试代码相当于:Base baseObj = new Child();父类的引用指向子类的实例,子类又重写了父类的test方法,因此调用子类的test方法。
11.以下程序的执行结果是什么
class Base{

    static void test() {

      System.out.println(“Base.test()”);

    }

  }

  public class Child extends Base {

    void test() {

      System.out.println(“Child.test()”);

      Base.test(); //Call the parent method

    }

    static public void main(String[] a) {

      new Child().test();

    }

  }

A Child.test() Base.test()

B Child.test() Child.test()

C 编译报错. 

D 运行报错. 

解答:C

静态方法不能在子类中被重写

12.以下程序的执行结果是什么;’ ?’ 是空格的意思.
public class Base{

    private void test() {

      String aStr = “?One?”;

      String bStr = aStr;

      aStr.toUpperCase();

      aStr.trim();

      System.out.println(“[" + aStr + "," + bStr + "]“);

    }

    static public void main(String[] a) {

      new Base().test();

    }

  }

A [ONE,?One?]

B [?One?,One]

C [ONE,One]

D [ONE,ONE]

E [?One?,?One?]

解答:E

13.下面关于变量及其范围的陈述哪些是不正确的( )
A.实例变量是类的成员变量

B.实例变量用关键字static声明

C.在方法中定义的局部变量在该方法被执行时创建

D.局部变量在使用前必须被初始化

解答:BC

由static修饰的变量称为类变量或是静态变量;方法加载的时候创建局部变量
14.编译运行以下程序后,关于输出结果的说明正确的是
public class Conditional{

    public static void main(String args[ ]){

    int x=4;

    System.out.println(“value is “+ ((x>4) ? 99.9 :9));

    }

  }

A、 输出结果为:value is 99.99

B、 输出结果为:value is 9

C、 输出结果为:value is 9.0

D、 编译错误

解答:C

三目运算符中:第二个表达式和第三个表达式中如果都为基本数据类型,整个表达式的运算结果由容量高的决定。99.9是double类型 而9是int类型,double容量高。
15.关于以下程序代码的说明正确的是( ):
class HasStatic{

     private static int x=100;

     public static void main(String args[ ]){

       HasStatic hs1=new HasStatic( );

       hs1.x++;

       HasStatic hs2=new HasStatic( );

       hs2.x++;

       hs1=new HasStatic( );

       hs1.x++;

       HasStatic.x - -;

       System.out.println(“x=”+x);

     }

  }

A、5行不能通过编译,因为引用了私有静态变量

B、10行不能通过编译,因为x是私有静态变量

C、程序通过编译,输出结果为:x=101

D、程序通过编译,输出结果为:x=102

E、程序通过编译,输出结果为:x=103

解答:D

静态变量是所有对象所共享的,所以上述代码中的几个对象操作是同一静态变量x, 静态变量可以通过类名调用。

16.下列哪种说法是正确的()

A.实例方法可直接调用超类的实例方法

B.实例方法可直接调用超类的类方法

C.实例方法可直接调用其他类的实例方法

D.实例方法可直接调用本类的类方法

解答:D

A. 实例方法不可直接调用超类的私有实例方法

B. 实例方法不可直接调用超类的私有的类方法

C.要看访问权限

17.下面代码的执行结果是?
import java.util.*;

  public class ShortSet{

    public static void main(String args[]){

      Set<Short> s=new HashSet<Short>();

      for(Short i=0;i<100;i++){

        s.add(i);

        s.remove(i-1);

      }

      System.out.println(s.size());

    }

  }

A.1

B.100

C.Throws Exception

D.None of the Above

解答:B

i是Short类型, i-1是int类型,其包装类为Integer,所以s.remove(i-1)不能移除Set集合中Short类型对象;只有将(i-1)强转为Short类型的时候,才能移除Set集合中的对象

18.以下关于面向对象概念的描述中,不正确的一项是()
A.在现实生活中,对象是指客观世界的实体

B.程序中的对象就是现实生活中的对象

C.在程序中,对象是通过一种抽象数据类型来描述的,这种抽象数据类型称为类(class)

D.在程序中,对象是一组变量和相关方法的集合

解答:B

面向过程强调的是每一个功能的具体实现步骤,面向对象强调的是对象调用功能

19.插入排序算法,将元素插入一个有序队列:第一步取数,第二步插入

  public static void injectionSort(int[] number) {

  // 第一个元素作为一部分,对后面的部分进行循环

  for (int j = 1; j < number.length; j++) {

    int tmp = number[ j ];

    int i = j – 1;

    while (tmp < number[ i ]) {

      number[i + 1] = number[ i ];

      i - -;

      if (i == -1)

        break;

    }

    number[i + 1] = tmp;

  }

  }
20.冒泡排序,元素上浮:第一步循环次数,第二步元素上浮
//N个数字冒泡排序,总共要进行N-1趟比较,每趟的排序次数为(N-i)次比较
    public static void bubbleSort(int[] arr){
        //一定要记住判断边界条件,很多人不注意这些细节,面试官看到你的代码的时候都懒得往下看,你的代码哪个项目敢往里面加?
        if(arr==null||arr.length<2){
            return;
        }
        //需要进行arr.length趟比较

        for(int i = 0 ;i<arr.length-1;i++){
            //第i趟比较
            for(int j = 0 ;j<arr.length-i-1;j++){
                //开始进行比较,如果arr[j]比arr[j+1]的值大,那就交换位置
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }

        }
//        System.out.println("最终得出的数组为:");
//        for (int k =0 ; k < arr.length;k++){
//            System.out.print(arr[k]+" ");
//        }
    }
21.选择排序:挑选元素放到指定位置。第一步,选择位置;第二步,选择元素
public static void selectSort(int [] arr,int n){
        for (int i = 0; i < n - 1; i++) {
            int index = i;
            int j;
            // 找出最小值得元素下标
            for (j = i + 1; j < n; j++) {
                if (arr[j] < arr[index]) {
                    index = j;
                }
            }
            int tmp = arr[index];
            arr[index] = arr[i];
            arr[i] = tmp;
            System.out.println(Arrays.toString(arr));
        }
 
    }
22.下列程序的运行结果是什么?
public class Test {

    public static void main(String[] args) {

      String str = NULL;

      System.out.println(str);

    }

  }

A. NULL

B. 编译时报错

C. ""

D.运行时报错
23、下列程序执行结果是什么?
public class Text{

    public static void main(String[] args){

      int a=10,b=4,c=20,d=6;

      System.out.println(a++*b+c*--d);

    }

  }

A、144

B、164

C、140

D、160

解答:C

在java中执行加减乘除基本运算时,已就遵循先乘除后加减的原则,而++a与a++的区别在于,++a是先自增后在参与运算,a++是先参与运算之后在自增,所以最终答案是10*4+20*5=140
24、下列哪两个选项不能直接导致线程停止?

A. 跳出同步代码块

B. 调用wait方法

 C. 调用notify方法

 D. 调用读取流的方法

 E. 设置线程的优先权

25.下列程序的运行结果是什么:
public class TestInner {
    class Foo {

           public int i = 3;

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

    

    Object o = (Object) new TestInner().new Foo();

    Foo foo = (Foo)o;

    System.out.println(foo.i);

    }

}

26.public class Text{

    public static void main(String[] args){
      int i=12;

      System.out.println(i+=i-=i*=i);

    }

  }

A、程序无法编译

B、100

C、0

D、-120

解答:D
本题我们先将i+=i-+i*=i编号 => i1+=i2-=i3*=i4;在计算之前先明白i1=i2=i3=i4=i=12;先计算i3=i*i=144,;再计算i1+=i2即为i1=i1+i2=24,此时i1=i2=24;最后计算i2-=i3即为i2=i2-i3=-120;

总结出下来就是,对于同一个变量,左边变量变化对右边
变量产生影响,而右边变量的变化对左边变量不产生影响。

27、 下列选项中,哪些选项与第2行相等:
1.   public interface Foo{

2.     int k = 4;

3.   }

A. final int k = 4;

B. Public int k = 4;

C. static int k = 4;

D. Private int k = 4;

E. Abstract int k = 4;

F. Volatile int k = 4;

G. Transient int k = 4;

H. protected int k = 4;
ABC
解析:Interface 变量等同于 public static final int k = 4;
28、 下列代码的执行结果是什么:

  public class foo {

    static String s;

    public static void main (String[]args) {

    System.out.println (“s=” + s);

    }

  }

A. 代码编译成功并输出“s=”

B. 代码编译成功并输出“s=null”

C. 因为变量s没有初始化,所以代码编译失败

D. 代码编译成功,但在调用toString的时候抛出NullPointerException异常

解答:B

String为引用数据类型,引用类型数据成员的默认值为null
29.从下面代码中选择出错误的代码段()

public class Something {

    void doSomething () {

      private String s ="";

      int l = s.length();

    }

    }
30.请看如下代码

  class Person {

    private int a;

    public int change(int m){

      return m;

    }

  }

  public class Teacher extends Person{

    public int b;

    public static void main(String arg[]){

      Person p = new Person();

      Teacher t = new Teacher();

      int i;

       // point x

    }

  }

下面哪些放在// point x?行是正确的?

A, i = m;

B, i = b;

C, i = p.a;

D, i = p.change(3);

E, i = t.b;

解答:DE

A.不同的作用域

B.静态方法中不能直接使用非静态成员变量

C.类外不能访问其它类私有的成员

D,E.在类方法中可以通过实例化对象调用类中的实例成员。

展开阅读全文
©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值