秋招备战笔试Day1

目录

单选

1. 在 Java 中，存放字符串常量的对象属于（ ）类对象。

2.已知如下类定义： 如下哪句可以正确地加入子类中？

3. 下列选项中属于面向对象编程主要特征的是（）

4.关于下列程序段的输出结果，说法正确的是：（ ）

5.下列代码的执行结果是：（ ）

6.方法通常存储在进程中的哪一区（）

7.不考虑反射，关于私有访问控制符 private 修饰的成员变量，以下说法正确的是（）

8.类声明中，声明一个类不能再被继承的关键字是（）

9.假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（）

编程题

1.组队竞赛

题目重现

思路

代码

2.删除公共字符

题目重现

思路

代码

---

单选

1. 在 Java 中，存放字符串常量的对象属于（ ）类对象。

A. Character

B. String

C. StringBuffer

D. Vector

A.Character是字符类型的包装类，

C.StringBuffer 不是字符串常量，字符串常量应该是String s ="str"；这样的形式，而StringBuffer 必须要new一下。

D.Vector是一个集合类

2.已知如下类定义： 如下哪句可以正确地加入子类中？

class Base { 
 public Base (){
 //...
 } 
 public Base ( int m ){
 //...
 } 
 public void fun( int n ){
 //...
 }
} 
public class Child extends Base{ 
 // member methods 
}

A. private void fun( int n ){ //...}

B. void fun ( int n ){ //... }

C. protected void fun ( int n ) { //... }

D. public void fun ( int n ) { //... }

首先这是一个叫Base的类，有不带参数的构造方法，带一个参数的构造方法，这里构成了重载。有一个fun方法，还有一个Child继承了Base类。

选项中所有的方法全是fun的方法，也就是说这里要与父类的fun方法构成一个重写的关系，重写的特点是：

1、必须是在继承里，

2、方法名、返回值类型、参数个数和参数类型 都必须相同

3、派生类重写的方法的访问权限不能低于基类的权限

4、派生类抛出的异常应该和基类相等或比基类更小

也就是说，这道题其实考察的是访问权限修饰符的权限大小，众所周知:public>protected>defaut（默认）>private

3. 下列选项中属于面向对象编程主要特征的是（）

A. 继承

B. 自顶向下

C. 模块化

D. 逐步求精

很简单的一道常识题：面向对象编程的主要特性是：继承，多态，封装，组合。

剩下的选项都是结构化程序设计原则。

4.关于下列程序段的输出结果，说法正确的是：（ ）

public class MyClass{
static int i;
public static void main(String argv[]){
System.out.println(i);
}
}

A. 有错误，变量i没有初始化。

B. null

C. 1

D. 0

首先，MyClass类中有一个静态的成员变量i，在main中输出这个i。

如果成员变量没有初识化会默认赋予一个0值。

5.下列代码的执行结果是：（ ）

public class Test{
 public static void main(String args[]){
System.out.println(100%3);
System.out.println(100%3.0);
 }
}

A. 1和1

B. 1和1.0

C. 1.0和1

D. 1.0和1.0

还是很简单的题。

这里考的是一个%求余数的问题。100%3 = 1；100%3.0 = 1.0；

6.方法通常存储在进程中的哪一区（）

A. 堆区

B. 栈区

C. 全局区

D. 方法区

Java堆区存储的是对象实例，而栈区存储的是基本数据类型和引用变量 。

方法本身不占内存，方法的指令都会放到方法区。

public void fun（）{

float f = 12.5f；

}

这里，f存储于栈区，而这个方法指令存储在方法区。

7.不考虑反射，关于私有访问控制符 private 修饰的成员变量，以下说法正确的是（）

A. 可以三种类所引用：该类自身、与它在同一包中的其他类，在其他包中的该类的子类

B. 可以被两种类访问和引用：该类本身、该类的所有子类

C. 只能被该类自身所访问和修改

D. 只能被同一个包中的类访问

private修饰的成员变量只能在本类中访问，其他类无法直接访问。

如果需要在其他类中访问，可以通过getter和setter方法进行访问 。

8.类声明中，声明一个类不能再被继承的关键字是（）

A. public

B. abstract

C. final

D. static

abstract关键字可以用来修饰类和方法，表示抽象类和抽象方法。它的作用是将子类的公共属性和不能确认的方法提取到抽象类，确认的方法也可以写到抽象类，子类继承抽象类，简化代码操作 。

final关键字可以用来修饰类、方法和变量(包括成员变量和局部变量)。当用final修饰一个类时，表明这个类不能被继承。当用final修饰一个方法时，表明这个方法不能被重写。当用final修饰一个变量时，表明这个变量只能被赋值一次，即常量 。

static关键字可以用来修饰变量和方法。当用static修饰一个变量时，这个变量就成为了一个类的成员变量，而不是实例变量。这意味着，这个变量在所有实例之间共享，而不仅仅是在某个特定的实例中。

9.假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（）

public class A
{
public int i;
static String s;
void method1(){}
static void method2(){}
}

A. System.out.println(a.i);

B. a.method1();

C. A.method1();

D. A.method2()

i是成员变量，通过对象的引用来访问肯定没问题。A正确

method1是成员方法，通过对象的引用来访问也没问题，B正确

类名去访问method1是错误的，类名可以去访问静态方法。而method1很明显不是静态方法。C错误。D正确。

编程题

1.组队竞赛

相关题目链接：组队竞赛_牛客笔试题_牛客网

题目重现

思路

这样分组能组成最大的sum。

这个水平值的数组下标可以推导出一个公式 ： nums[nums.length-(2*(i+1))]

代码

    public static void main(String[] args) {
        //进行数据的接收
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            int n = scanner.nextInt();
            //处理空格
            scanner.nextLine();
            int[] nums = new int[3*n];

            //接收数组数据
            for (int i = 0; i < 3*n; i++) {
                nums[i] = scanner.nextInt();
            }

            //对数组进行排序，挑出最小的前n个数
            Arrays.sort(nums);
            long sum = 0;
            for (int i = 0; i < n; i++) {
                //水平值是三数排序后第二大的数   举例 5 2 8 5 1 5
                //排序后 1 2 5 5 5 8
                //当前n=2 取出的最小的两个数是 1 2
                //1 5 5     2 5 8
                //也就是说  水平值是 数组的长度-（2*（i+1））
                sum += nums[nums.length-(2*(i+1))];
            }
            System.out.println(sum);
        }

    }

2.删除公共字符

相关题目链接：删除公共字符_牛客题霸_牛客网

题目重现

思路

首先，我们使用一个哈希表来存储要删除的字符串s2中的字符，然后再次循环，查看s1中的字符是否在哈希表中出现了，如果出现则表示这个字符是要删除的字符，如果没有出现表示这是不需要被删除的字符，然后将其添加到stringBuffer中，最后输出stringBuffer。

代码

    //删除公共字符
    public static void main1(String[] args) {
        //接收处理
        Scanner scanner = new Scanner(System.in);
        String s1 = scanner.nextLine();
        String s2 = scanner.nextLine();
        //开始进行字符串的处理
        HashMap hashMap = new HashMap<>();

        //构建要输出的
        StringBuffer stringBuffer = new StringBuffer();
        //开始进行操作
        //查看要删除的字符是什么
        for (int i = 0; i < s2.length(); i++) {
            if (hashMap.get(s2.charAt(i)) == null){
                hashMap.put(s2.charAt(i),1);
            }
        }

        for (int i = 0; i < s1.length(); i++) {
            if (hashMap.get(s1.charAt(i)) == null){
                stringBuffer.append(s1.charAt(i));
            }
    
        System.out.println(stringBuffer);
    }