A牛客题目整理

65 阅读 0 评论 43 点赞

我是靠谱客的博主野性酒窝，最近开发中收集的这篇文章主要介绍A牛客题目整理，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

public class MYClass{
long var;
public void MYClass(long parm){
var = parm;
}
public static void main(String [] args){
MYClass a , b;
a =new MYClass();
b= new MYClass(5);//错误 
}
}

注意，构造函数的定义应该是

public MYClass(long parm){
var = parm;
}

而上面的void MYClass只是一个普通的方法。
编译器向MYClass提供一个无参的构造函数。所以b中向构造方法中传入参数错误

1.1）abstract只能用来修饰类和方法（抽象方法没有方法体）
abstract sum(int x,int y);
字段（属性）可以用public、static、final修饰
2）接口的方法默认是public、abstract的
2.构造方法可以用public、default、private、protected修饰
3.1）一位数组定义（一维数组必须定义其长度）
int[] arr = new int[]{1,2,3};
int[] arr = {1,2,3};
int[] arr = new int [3];//动态初始化
2）二维数组第一个框中一定要有值
int[][] a = new int [6][6]
int []a[] = new int[6][6]
int a[][] = new int[6][6]
int [][]a = new int[6][]
4.数组a.equals(数组b)//比较的是地址，相当于=
Array.equals(数组a，数组b)是逐个比较元素
5.java相等性规则
：用于基本数据类型时比较元素的值，用于引用型时比较的是地址
equals和相同，但String类重写equals，比较的是对象的值。
注意：x.equals(y)，要求x与y的类型必须相同，而且不能是基本数据类型。
6.
1）抽象类：
必须有abstract class修饰
可以被初始化（通过构造函数），但不可以被实例化
可以被继承（即抽象类的子类为抽象类或非抽象类）
可以有构造方法
可以存在普通属性和静态属性（可以定义成员）
抽象类中不一定有抽象方法。如果一个类中有抽象方法，一定是抽象类
2）接口（用来实现多继承）
实现一个接口必须实现它的所有方法
一个类只能继承一个类，但可以实现多个接口。
接口没有构造方法。
接口可以定义成员，但接口定义的成员必须是常量（static final）。
7.构造方法：
构造方法名必须与类名相同
构造方法没有返回值类型，也不能定义为void类型不能在方法名前声明方法类型
构造方法可以被重载（所以一个类中可以有多个构造函数）
如果一个类中没有构造函数，编译系统会自动给一个无参的构造函数

8.一个类可以有一个以上的构造器
构造器可以有0个或一个或一个以上的参数

9.编译器javac.exe：java代码–>class字节码
jvm:class字节码(类)–>可执行代码
OS：可执行代码–>机器码
javadoc.exe–>用来生成java文档
执行程序java.exe,用于执行编译好的class文件
10.栈中数据可以共享
11.子类的访问权限不能低于父类
12.JVM内存：
虚拟栈区、本地栈区、方法区、堆区、PC寄存器
方法区和堆区是线程共享的
所有线程共享堆，而不是每个线程都有一个堆内存。堆存放对象实例以及数组
类信息存放在方法区中

13.1）当程序运行时，至少会有两个线程启动，一个是main线程，一个是垃圾回收线程，垃圾回收线程的优先级较低。
2）程序开发者只能通过gc()方法提醒系统回收线程
3）进入dead状态的线程有可能恢复，不一定被回收

14.多态：提高可重用性
扩展代码模块

15.Throwable:分为Error和Exception
Error：程序无法处理的异常
Throwable：程序本身可以处理的异常。分为RuntimeError和检查异常
Throwable处理：可以用try{}catch块
可以用throws抛出

16.用static修饰的是类方法、类变量
1）类方法通过类名.方法名调用；普通方法（无static修饰的方法）通过实例化对象调用
2）成员变量（在堆中）包括类变量和实例变量，可以不用初始化（默认值为0或者null）；
局部变量（在栈中）必须初始化
3）成员变量和局部变量同时使用时（同名），局部变量有更高的优先级
17.泛式：
只会使程序运行期间更加安全（类型安全、消除强制类型转换）；不会改变程序运行期间的性能

18.通过-Xmx参数来增加堆的大小
19.静态方法：
静态方法属于一个类而不属于对象
只能访问静态数据，无法访问非静态数据（实例数据）
只能调用其他静态方法

20.互斥锁：
关键字：synchronized

21.创建子类对象时，会默认调用父类的无参构造函数。
如果父类没有无参构造函数，则需要用super显式调用
也就是说，super用来显式调用父类构造方法
super可以访问父类中用public、protected、default修饰的成员变量、实例方法、构造方法
成员变量：super.成员名称
实例方法：super.实例方法
构造方法：super（参数）
22.异常：分为运行时异常（RuntimeException）和检查时异常。运行时异常编译器不会对其进行捕获，
会把异常一直向上抛。检查时异常通常通过try-catch语句或者throws抛出。
catch中允许再次出现异常，处理方法：要么嵌套catch再次处理异常，要么打印异常信息，停止处理。
23.java里默认浮点类型为double。
float会加后缀f或F
long会加后缀L或l
24.ArrayList默认数组大小为10，扩容后大小为扩容前的1.5倍。
StringBuffer默认大小为16，扩容为原大小左移一位+2
ArrayList和StringBuffer一样，如果创建对象时传入了初始容量大小x，则初始容量大小就为x
String Bufferstr = new StringBuffer(5);//初始容量大小为5
25.方法默认访问权限：
关于抽象类：
jdk1.8以前：默认protected
jdk1.8时，默认default
关于接口：
jdk1.8以前：默认public
jdk1.8时，public或default
jdk1.8以后，默认private

26.以stream结尾的一般是字节流，以reader和writer结尾的一般是字符流

27.while用法：java和c的区别
java中while内必须是boolean型
c中while可以是int型或boolean等（只要非0或非null都可以）

28.下面这条语句一共创建了多少个对象：String s=“welcome”+“to”+360;
首先，==对于基本数据类型比较的是值是否相同。对于引用型比较的是内存地址
对于字面量的"+“拼接是在编译期间执行的，拼接后的字符串放在常量池中
对于字符串的”+"拼接是在运行期间执行的，拼接后的字符串放在堆中。

String test="javaandpython";
String str1="java";
String str2="and";
String str3="python";
System. out. println(test=="java"+"and"+"python"): //true
System. out. println(test ==str1 + str2 + str3);//false
第5句：字面量拼接，在编译期间，创建一个字符串常量"javaandpython"，放在常量池中。所以test和"java"+"and"+"python"内存地址相同
第6句：字符串拼接，在运行期间，创建一个字符串常量"javaandpython"，放在堆中。所以test和str1 + str2 + str3内存地址不同

String s=“welcome”+“to”+360;
所以，在程序编译期间，创建"welcometo360"常量放在常量池中，共一个对象。

29.类方法
类方法是指静态方法，可以直接调用。属于整个类。
静态变量也可以直接通过类名调用。
对象方法，也叫实例方法，属于类的某个对象
30.map.size()返回的是元素（键值对）的个数
31.class类可以装载其他类
32.java实现多线程的三种方式：
继承thread类。继承了thread类后就不能再继承其他类
实现runnable接口
实现callable接口
thread是类，runnable和callable都是接口。
33.Parameter是参数的意思。
getParameter用来获取客户端通过get或post传过来的参数值
getInitParameter用来获取Serlvet配置文件初始化的参数值
getInitParameter()是ServletConfig接口的方法

34.jre判断程序是否执行结束的标志：前台线程是否执行完。
后台线程是守护线程(实际操控者)，前台线程是用户线程(傀儡)
jre的垃圾回收站就是一个后台线程
35.静态方法和静态变量可以直接通过类名调用，但是普通方法和普通变量需要通过实例化对象调用
36.++操作前面或后面应该是一个变量。i++为-5，是一个字面量，编译错误。
字面量：一个固定值的表示。

.public class Test {
public static void main(String args[]) {
int i = -5;
i =
++(i++);
System.out.println(i);
}
}

37.java特点：
一次编写，到处运行。与其他编程语言相比，java具有独特的跨平台性
java致力于检查程序在编译和运行出错的可能。（例如：局部变量定义时必须初始化；如果检测到可能出现异常，需要throws或try-catch引出异常）
java自己操纵内存，减少了内存出错的可能
java实现了真数组，避免覆盖数据的可能（避免减少的是覆盖数据而不是覆盖数据类型）

38.Java标识符命名规则：
只能以英文字母，数字，_ ，$ 开头。
java区分大小写，关键字都是小写

39.java体系结构：包括四个，他们相互独立又相关
java程序设计语言
java.class文件格式
java应用编程接口：API
java虚拟机（JVM）
当我们编写并运行一个Java文件时，就运用了这四种技术：通过java程序设计语言编写源代码，把源代码编译成.class文件格式，然后在java虚拟机里运行class文件。当程序在jvm中运行时，它通过调用。class文件实现了API接口中的方法。

40.客户端通过 new Socket()创建通信的Socket对象
服务器端通过 new Serversocket()创建TCP通信对象，通过accept接受客户端请求

50.无效等价类：指不满足程序输入要求或无效的输入数据组成的集合
有效等价类：指完全满足程序说明、有效的有意义的输入数据组成的集合。
示例：

题目：：某程序要求每次输入只能是正整数，并且每次输入的数值要求必须是100的倍数且小于等于500，则下列哪个是正确的无效等价类(
)
答案：：（-∞，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）;

60.Maven遵循约定，是声明式，要把源代码放在指定的目录下，这样maven知道你的源代码所在的位置。
Maven有生命周期。maven的默认构建文件是pom.xml
Ant没有约定，是命令式。没有指定的源代码存放路径，也没有生命周期。ant默认的构建文件是build.xml
61.Iterator 支持从集合中安全删除元素。删除方法 Iterator_obj.remove()
62. mvc： module-view-controller。是将不同功能的逻辑业务进行隔离。
mvc模式设计web应用程序优点：
可维护性、可扩展性、代码重复性少。
代码重复量少不代表代码量少。
一般来说，使用设计模式会增加代码量。
63.java一律采用Unicode编码。不论是中文还是英文字符，都用两个字节。
不同的编码类型之间可以转换，并不固定于一种编码形式
实现国际化应用常用的手段是利用ResourceBundle类
Java的char类型，通常以UTF-16 Big Endian的方式保存一个字符。

在这里插入图片描述

65.定义在方法中的局部变量，必须初始化。
66.可以用在WEB开发中实现会话跟踪实现的技术：隐藏域、地址重写、session、cookie
67.java中下面哪些是Object类的方法：nofity、nofytyAll、wait
68.代码优化循环方法：复写传播、删除归纳变量、代码外提、强度削弱。
69. 在这里插入图片描述
70.java内存泄漏的最直接表现：程序抛内存溢出的Exception。

71.下面的方法可用在 Servlet 程序中读取 HTTP 头。这些方法通过 HttpServletRequest 对象可用：
1）Cookie[] getCookies()
返回一个数组，包含客户端发送该请求的所有的 Cookie 对象。
2）Object getAttribute(String name)—属性
以对象形式返回已命名属性的值，如果没有给定名称的属性存在，则返回 null。
3）String getHeader(String name)
以字符串形式返回指定的请求头的值。Cookie也是头的一种；
4）String getParameter(String name)–参数
以字符串形式返回请求参数的值，或者如果参数不存在则返回 null。

72.静态方法可以通过类名调用，也可以通过实例对象调用
73.final
final可以用来修饰类、方法、变量
finally是java保证重点代码一定要被执行的一种机制
变量被final修饰后不能再指向其他对象，不可以重写
finalize设计的目的是保证对象在被垃圾收集前完成特定资源的回收
74.

public class Test
{
private int a=10;
int b=20; //默认权限修饰(fridently)
static int c=1;
public static void main(String arg[])
{
Test t = new Test();
//可以在此后调用：
t.a;
√
private权限范围为本类，可以在本类中访问private对象。
this.c; ×
this和super不能使用在静态资源中
Test.b; ×
t.c;
√
静态变量可以通过类名、实例对象调用
}
}

75.java创建对象：
用new语句创建对象，是最常见的创建对象的方法。
运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
调用对象的clone()方法。
运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。
76.抽象类和接口中的方法都没有方法体 ×
抽象方法没有方法体。
接口中都是抽象方法。
抽象类中可能有抽象方法、非抽象方法。

77.类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。
boolean类型默认值是false

78.volatile能保证数据的可见性、有序性，但不能完全保证数据的原子性
synchronized保证了数据的可见性、原子性、有序性
79.Java使用了中间缓存变量机制：
1）i = i ++ ;相当于
temp = i (temp暂存等式右边)
i = i+1; ( i通过i++自增 )
i = temp;
所以其实通过i = i++；i没有变化
2）i = ++i ;相当于：
temp = ++i；（temp暂存等式右边）
i = i+1;( i通过i++自增 )
i = temp;
所以i = ++i；相当于++i;
80.以下方式实现的单例是线程安全的：
懒汉式、双检锁模式、静态内部类、枚举
81
示例1：

public class Demo {
class Super {
int flag = 1;
Super() {
test();
}
void test() {
System.out.println("Super.test() flag=" + flag);
}
}
class Sub extends Super {
Sub(int i) {
flag = i;
System.out.println("Sub.Sub()flag=" + flag);
}
void test() {
System.out.println("Sub.test()flag=" + flag);
}
}
public static void main(String[] args) {
new Demo().new Sub(5);
}
}

分析：首先，flag是全局变量
1）首先调用父类构造函数，在Super()中，flag改为1。由于子类Sub重写了父类的test()方法，所以调用Sub的test()。输出：
Sub.Sub()flag=1
2）然后调用子类Sub的构造方法，输出 Sub.Sub()flag=5

重点要时刻记得子类重写父类方法，调用时会调用子类重写之后的方法
只要是被子类重写的方法，不被super调用都是调用子类方法。

示例2：

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");
}
}

假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果：
1）首先，调用子类Derived的方法b.methodOne（）。由于super.methodOne()，执行父类Base的methodOne()方法。
输出A，由于Base的子类重写了methodTwo()方法。调用子类的methodTwo()方法。
2）调用子类Derived的方法methodTwo（）。由于super.methodTwo();执行父类Base的methodTwo()方法。
输出B。
3）最后，依次返回子类的methodTwo()、methodOne()方法，输出DC

82.instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
示例：

Integer integ =new Integer(9);
boolean b = integ
instanceof
Object;//true

83.javadoc用来识别注释。
javac用来识别代码。
到编译阶段没有注释。
84.java中用final定义常量。
c++中用const、#define定义常量。
85.java多线程实现方式：
继承Thread类；实现Runable接口
86.java中基本的编程单元：类
基本的存储单元：变量
87.Java运行异常，一般由jvm自行处理。
非运行时异常，应该抛出或捕捉异常。

88.可以把任何一种数据类型的变量赋给Object类型变量。（自动封箱）
89.要将一个文件内容写到另一个文件：首先把文件内容读入内存（FileinputStream），然后再从内存读出到新文件中（FileoutputStream）

90.System.out.println((-12) % (-5));//-2
% 取余，余数和被除数符号一致
mod 取模，结果和除数符号一致。
示例：

System.out.println((-3)%2);
//-1
System.out.println(4%3);
//1
System.out.println((-3)%(-2));
//-1
System.out.println(4%(-3));
//1

91.C面向过程
C++面向对象
Java面向对象
汇编语言面向机器
92.AOP：面向方向编程，与源代码无关，AOP是Spring框架的一种重要内容。
OOP：面向对象编程
AOP是OOP的一种补充，不是替代关系。

93.Java和C++的三个特性：封装继承多态；
Java没有指针，只有引用
Java垃圾回收机制并不是程序结束后才会GC，GC的时间是不确定的。
94.类分为内部类和外部类。
内部类可以由：private、static、protected等修饰成员变量的修饰符修饰
外部类只能由：abstract、final、public修饰
95. 与InputStream流对应的java标准输入对象是 —> System.in
96. 当出现string类型时，后面的+都是字符串的拼接；
出现string之前，int类型之间使用"+"依然表示数值的相加。

System.out.println(1+"10"+3+"2");//11032
System.out.println(1+2+"10"+3+"2");//31032
System.out.println(1+"10"+3+1+"2");//110312

97.Java和C++之间的区别：
Java没有指针概念，Java使用的是引用。
Java不需要程序员管理内存，由JVM虚拟机管理内存。

98.abstract和final不能并列修饰同一个类
abstract类中不应该出现private修饰的成员变量（子类只能继承父类的非private资源。而abstract类的所有资源都应该被继承，如果abstract类中有private变量，该变量不能被继承）。

99.Json格式数据：由{“key” : value}格式组成。key可以加引号也可以不加。
100.Jdk1.7之前：switch()支持的数据类型：byte、char、short、int以及他们的封装类
Jdk1.7之后：加入String类型
101. 在静态资源中不能调用this、super
在静态方法中调用本类静态方法时，可直接调用（比如在main中调用本类静态方法）
在静态方法中可以调用本类静态资源（静态方法和静态变量）
在静态方法中可以调用实例方法（比如在man中调用 new.类名() ）。
102. Java 多线程有几种实现方法：继承Thread类、实现Runnable接口
103.
1）?: 三目运算符。 eg<表达式1>?<表达式2>:<表达式3>
2）instanceof可用来判断某个实例变量是否属于某个类（或子类）的类型
104.
1）A is-a B：表示A继承B
2）A has-a B：表示A里面引用了B
3）A like-a B：表示A实现了B（B是A的接口）
举例：

Gadget has-a Sprocket and Gadget has-a Spring and Gadget is-a Widget and Widget has-a
Sprocke
表示：
class Widget { Sprocket s; }
class Gadget extends Widget { Spring s; }
或者：
class Widget { Sprocket s1; Spring s2; }
class Gadget extends Widget { }

105.Object类的方法：
在这里插入图片描述
106.start()和run()方法：
1）start()方法会开启多线程。调用Thread类的start()方法开启线程，这是此线程会进入就绪状态，一旦分得CPU时间片，就会运行run方法。由于开启的是多线程，不需要等待run方法执行完毕，就可以执行下面的代码
2）run()方法只会开启主线程，程序执行路径依然只有一条。run不能实现多线程
107.

//a、b、x、y是四个指针，x和y分别指向a、b,
//在operate方法中，x指向的对象进行了append操作， y=x令指针y 指向的地址变成x指向的对象
//所以在operate中，a变化，但是b并没有变化
public class foo {
public static void main(String sgf[]) {
StringBuffer a=new StringBuffer("A");
StringBuffer b=new StringBuffer("B");
operate(a,b);
System.out.println(a+"."+b);//AB.B
}
static void operate(StringBuffer x,StringBuffer y) {
x.append(y);
y=x;
}
}