1、类Person和类Student的关系是（）
class Person {}
class Student extends Person {
public int id; //学号
public int score; //总分
public String name; // 姓名
public int getScore(){return score;}
}
包含关系
继承关系
关联关系
无关系，上述类定义有语法错误
Java中类之间的六种关系：
第一种：继承关系，例如：子类继承父类，子接口继承父接口。
第二种：实现关系，例如：类实现接口。
第三种：依赖关系，例如：一个类作为另一个类中方法的参数存在，这种关系具有偶然性和临时性。
第四种：关联关系，例如：一个类作为另一个类中的成员变量存在，它是一种强依赖关系。
第五种：聚合关系，例如：整体和部分之间，他们是可以分离的拥有各自的生命周期，并且部分是相同的。像鸟群和鸟。
第六种：组合关系，它是一种强聚合，并且整体和部分之间不可分离，具有相同的生命周期，整体包含该部分，也包含其他部分，其他部分和该部分是不相同的，像cpu和计算机，计算机除了包括cpu还有键盘和显示器等。
B
2、以下关于java封装的描述中，正确的是：
封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性
封装的意义不大，因此在编码中尽量不要使用
如果子类继承父类，对于父类中进行封装的方法，子类仍然可以直接调用
只能对一个类中的方法进行封装，不能对属性进行封装
封装主要是隐藏内部代码；
继承主要是复用现有代码；
多态主要是改写对象行为。
封装就是将属性私有化，提供公有的方法访问私有属性。------------------- 所以CD错误。
做法就是：修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值（ getter ）方法和赋值（ setter ）方法，用于对这些属性的访问。
通过封装，可以实现对属性的数据访问限制，同时增加了程序的可维护性。
由于取值方法和赋值方法隐藏了实现的变更，因此并不会影响读取或修改该属性的类，避免了大规模的修改，程序的可维护性增强
A
3、下面关于 new 关键字的表述错误的是（）
new关键字在生成一个对象时会为对象开辟内存空间
new关键字在生成一个对象时会调用类的构造方法
new关键字在生成一个对象时会将生成的对象的地址返回
Java中只能通过new关键字来生成一个对象
使用new关键字来生成对象只是最常用的方式；除此之外，还可以：
1，使用反射创建对象，调用java.lang.Class或者java.lang.reflect.Constructor类的new Instance()实例方法；
2，调用对象的clone()方法（要拷贝的对象需要实现Cloneable接口，并重写clone()方法）；
3，使用反序列化方式，通过让类实现Serializable接口，然后使用new ObjectInputStream().readObject()来创建对象
D
4、一个类可以有多个不同名的构造函数 （不考虑内部类的情况）。（ ）
正确
错误
只有与类名相同的方法可以叫构造函数
java 构造函数，可以被访问修饰符修饰，而不能被特殊修饰符修饰；（在编译器经过测试） 访问修饰符： public （最常用，其他类的任何位置都可以访问） protected（能够在同一包中被子类访问） 什么都不写，“”(能够被同一包里的类访问) private（经常使用的单例模式中） 特殊修饰符： static (静态) final(最终) abstract(抽象) synchronized(同步) 这些都不能够放在构造函数前使用
B
5、在为传统面向对象语言的程序做单元测试的时候,经常用到mock对象。Mock对象通过反射数。请问反射最大程度破坏了面向对象的以下哪个特性？
封装
多态
继承
抽象
mock对象：也成为伪对象，在测试中的利用mock对象来代替真实对象，方便测试的进行。
java的封装性：指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，通过该类提供的方法实现对内部信息的操作访问。
反射机制：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法和属性
反射可以访问原类的私有方法，私有成员变量，因此，反射破坏了Java的A
A
6、abstract和final可以同时作为一个类的修饰符。（ ）
正确
错误
abstract修饰的类需要被继承，而final修饰的类不可被继承，自相矛盾。
拓展：
一、抽象类的使用原则如下：
（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
（4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。
二、final关键字：
（1）修饰变量 ： 变量不可修改；
（1）修饰方法 ： 方法不可重写；
（1）修饰类 ：类不可继承。
7、以下代码的输出的正确结果是
public class Test {
public static void main(String args[]) {
String s = “祝你考出好成绩！”;
System.out.println(s.length());
}
}
24
16
15
8
length得到的是字符，不是字节。
中文和英文一样的，看作一个字符。
D
8、instanceof运算符能够用来判断一个对象是否为:
一个类的实例
一个实现指定接口的类的实例
全部正确
一个子类的实例
instanceof是JAVA中的关键字，用来判断一个对象是不是一个类的实例，是不是一个类的子类，是不是一个接口的实现类
C
9、下列程序test 类中的变量c 的最后结果为
public class Test {
public static void main(String args[]) {
int a = 10;
int b;
int c;
if (a > 50) {
b = 9;
}
c = b + a;
}
}
10
0
19
编译出错
方法内定义的变量没有初始值，必须要进行初始化。 类中定义的变量可以不需要赋予初始值，默认初始值为0。
D
10、顺序执行下列程序语句后，则b的值是（）
String a=“Hello”;
String b=a.substring(0,2);
Hello
Hel
He
null
substring 方法将返回一个包含从 start 到最后（不包含_end_）的子字符串的字符串。
C
11、输出结果为：
String str = “”;
System.out.print(str.split(“,”).length);
0
1
出现异常
/** * String split 这个方法默认返回一个数组， * 如果没有找到分隔符， * 会把整个字符串当成一个长度为1的字符串数组 * 返回到结果， 所以此处结果就是1
*/ private static void testSpringSpilte(){
String str = “12,3”;
String str2 = “123”;
System.out.print(str.split(“,”).length);
System.out.print(str2.split(“,”).length);
}
}
结果 2 1
B
12、下面字段声明中哪一个在interface主体内是合法的? （）
private final static int answer = 42;
public static int answer = 42;
final static answer = 42;
int answer;
在接口中，属性都是默认public static final修饰的，所以：
A（错误）：不能用private修饰；
B（正确）：在接口中，属性默认public static final，这三个关键字可以省略；
C（错误）：没写属性的类型；
D（错误）：final修饰的属性必须赋值；
接口中的属性在不提供修饰符修饰的情况下，会自动加上public static final
注意（在1.8的编译器下可试）：
（1）属性不能用private，protected,default 修饰，因为默认是public
（2）如果属性是基本数据类型，需要赋初始值，若是引用类型，也需要初始化，因为默认有final修饰，必须赋初始值；
（3）接口中常规的来说不能够定义方法体，所以无法通过get和set方法获取属性值，所以属性不属于对象，属于类（接口），因为默认使用static修饰。
B
13、以下代码执行的结果显示是多少（）？
public static void main(String[] args) {
int count = 0;
int num = 0;
for (int i = 0; i <= 100; i++){
num = num + i;
count = count++;
}
System.out.println(“bcz=” + (num*count));
}
num * count = 505000
num * count = 0
运行时错误
num * count = 5050
count=count++就是先把局部变量表中count的值0放入操作数栈中，然后直接对局部变量表中的count加1，然后再把操作数栈中的0出栈赋值给局部变量表中的count，最终局部变量表中的count值仍为0
count = count ++;这个先将count这个值0暂存起来，然后count自加1变成1，最后将暂存的值赋值给count，count最终的值为0
B
14、假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？
public class Base
{
public void methodOne()
{
System.out.print(“A”);
methodTwo();
}
public void methodTwo()
{
System.out.print(“B”);
}
}
public class Derived extends Base
{
public void methodOne()
{
super.methodOne();
System.out.print(“C”);
}
public void methodTwo()
{
super.methodTwo();
System.out.print(“D”);
}
}
向上转型：父类只能调用父类方法或者子类覆写后的方法,而子类中的单独方法则是无法调用的。
因此：
调用的顺序是：(1)、(2)、(3)、(4)、(5)、(6)、(7) ; 得到的结果是：ABDC
最后
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！
如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
oid methodTwo()
{
super.methodTwo();
System.out.print(“D”);
}
}
向上转型：父类只能调用父类方法或者子类覆写后的方法,而子类中的单独方法则是无法调用的。
因此：
调用的顺序是：(1)、(2)、(3)、(4)、(5)、(6)、(7) ; 得到的结果是：ABDC
最后
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-aORvUinb-1714834271381)]
[外链图片转存中…(img-VYeb7Beo-1714834271381)]
[外链图片转存中…(img-m3XNPEss-1714834271382)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！
如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
8412
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
