每日一题 day01

文章目录

• 选择题
• • 1.在Java中，存放字符串常量的变量属于（）类对象
  • 2.已知如下类定义
  • 3.下列选项中属于面向对象设计方法主要特征的是()
  • 4.关于下列程序段的输出结果,说法正确的是()
  • 5.下列代码的执行结果是:
  • 6.在基本Java类型中,如果不明确指定,整数型的默认是( )类型,带小数的默认为( ) 类型
  • 7.方法通常存储在进程中的哪一区中（）
  • 8.不考虑反射，关于私有访问修饰符private修饰的成员变量，以下说法正确的是（）
  • 9.类声明种，声明一个类不能再被继承的关键字是（）
  • 10.假设A类有如下定义，设a是A类的一个实例，下列语句调用哪个是错误的？（）
• 编程题
• • 题目1
  • 题目2

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

A.Character B. String C.StringBuffer D.Vactor

A是一个字符类型的包装类，肯定不能存放字符串常量

C StringBuffer 只能new一个字符串，不可以存放字符串常量

D 是一个集合类，更不可能

所以正确答案是B String

2.已知如下类定义

class Base{
    public Base(){
        //...
    }
    public Base(int m) {
        //...
    }
    public void fun(int n) {
        //...
    }
}
public class Child extend 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,所以Child类是Base类的子类

由题目和选项可知,此题考的是关于方法的重写

重写规则:

1. 重写的方法方法名,参数列表和返回值必须和父类的被重写方法一致.
2. 子类的访问修饰符的权限要大于或等于父类被重写的方法
3. 如果父类的方法的访问修饰符为private,子类无法重写该方法
4. 子类抛出的异常必须小于父类抛出的异常

根据以上的规则可以得出,最后的D选项为正确答案

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

首先我们需要知道,i的前面有一个static,所以i是一个静态成员变量,又因为他是int类型的,所以它的默认初始化值为0

在A选项中,需要初始化的变量为局部变量,全局变量在声明没有初始化的时候,会有一个默认初始化值.

5.下列代码的执行结果是:

public class Test3{
    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是int类型,3.0是double类型,所以结果会自动提升为double类型

6.在基本Java类型中,如果不明确指定,整数型的默认是( )类型,带小数的默认为( ) 类型

A int float

B int double

C long float

D long double

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

A 堆区

B 栈区

C 全局区

D 方法区

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

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

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

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

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

本题考查的值访问修饰符的访问权限的大小

访问修饰符	访问权限大小
private	只能被该类自身
default	可以被同一个包 下的所有类访问
protected	可以被同一个包下的所有类和其他包下的子类访问
public	可以被同一个项目的所有类访问。

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

A public

B abstract

C final

D static

关键字的使用：

public访问修饰符，可以被继承

abstract修饰的类是抽象类，可以被继承，同时子类还必须重写抽象类种的所有抽象方法。

final 修饰的类不可以被继承，final修饰的变量不可以更改

static修饰的类是一个静态类，可以被继承

10.假设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();

因为method1是一个普通方法，需要实例化对象来调用，所以A。method1是错误的

编程题 题目1

链接：组队竞赛
来源：牛客网

牛牛举办了一次编程比赛,参加比赛的有3*n个选手,每个选手都有一个水平值a_i.现在要将这些选手进行组队,一共组成n个队伍,即每个队伍3人.牛牛发现队伍的水平值等于该队伍队员中第二高水平值。
例如:
一个队伍三个队员的水平值分别是3,3,3.那么队伍的水平值是3
一个队伍三个队员的水平值分别是3,2,3.那么队伍的水平值是3
一个队伍三个队员的水平值分别是1,5,2.那么队伍的水平值是2
为了让比赛更有看点,牛牛想安排队伍使所有队伍的水平值总和最大。
如样例所示:
如果牛牛把6个队员划分到两个队伍
如果方案为:
team1:{1,2,5}, team2:{5,5,8}, 这时候水平值总和为7.
而如果方案为:
team1:{2,5,8}, team2:{1,5,5}, 这时候水平值总和为10.
没有比总和为10更大的方案,所以输出10.

输入描述:

输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)
第二行包括3*n个整数a_i(1 ≤ a_i ≤ 10^9),表示每个参赛选手的水平值.

输出描述:

输出一个整数表示所有队伍的水平值总和最大值.

示例1

输入

2
5 2 8 5 1 5

输出

10

---

题目分析

一个队伍有三个人，整个队伍的水平值是队伍成员第二高水平值。此时牛牛给n个队伍，要找出n个队中的水平值总和最大。

代码：

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[] array = new int[3*n];
        for(int i = 0; i < array.length; i++) {
            array[i] = scan.nextInt();
        }
        Arrays.sort(array);
        long ret = 0;
        for(int i = 0; i < n; i++) {
            ret += array[array.length -2*(i+1)];
        }
        System.out.println(ret);
    }
}

题目2

[删除公共字符]
链接：删除公共字符
来源：牛客网

输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.”

输入描述:

每个测试输入包含2个字符串

输出描述:

输出删除后的字符串

示例1

输入

They are students. 
aeiou

输出

Thy r stdnts.

---

题目分析:

输入两个字符串,如果第一个字符串中存在和第二个字符串相同的字符,将其删除,最后删除后字符串1不在存在字符串2中的字符.

题解思路:

使用HashMap,用for循环将str2(字符串2)中所有的字符写入,然后在遍历str1(字符串1),如果map中已经存在的字符在str1中存在,则将其删去,直到遍历结束,最后str1中剩下的就是删除完毕后的字符串.

代码

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String str1 = scan.nextLine();
        String str2 = scan.nextLine();
        HashMap map = new HashMap<>();
        for(int i = 0; i 
            char ch = str2.charAt(i);
            if(map.get(ch) == null) {
                map.put(ch,1);
            }else{
                map.put(ch,map.get(ch)+1);
            }
        }
        String ret = "";
        for(int i = 0; i 
            if(map.get(str1.charAt(i)) == null) {
                ret += str1.charAt(i);
            }
        }
        System.out.println(ret);
    }
}

需要注意的地方:

第10行和第18行的位置,如果将null改为0的话,会报空指针异常,因为此时HashMap中放入的是Integer,是一个包装类,所以此处写为null,而不是0