第一套
1.ResultSet中记录行的第一列索引为?
正确答案: C 你的答案: B (错误)
-1
0
1
以上都不是
答案:C
ResultSet跟普通的数组不同,索引从1开始而不是从0开始
2.下面叙述那个是正确的?()
正确答案: B 你的答案: B (正确)
java中的集合类(如Vector)可以用来存储任何类型的对象,且大小可以自动调整。但需要事先知道所存储对象的类型,才能正常使用。
在java中,我们可以用违例(Exception)来抛出一些并非错误的消息,但这样比直接从函数返回一个结果要更大的系统开销。
java接口包含函数声明和变量声明。
java中,子类不可以访问父类的私有成员和受保护的成员。
我就说下B选项和C选项。
B选项说的情况就是我们自定义异常的情况,请仔细读:我们可以用违例(Exception)来抛出一些并非错误的消息,可以,并非错误的消息。比如我自定义一个异常,若一个变量大于10就抛出一个异常,这样就对应了B选项说的情况,我用抛出异常说明这个变量大于10,而不是用一个函数体(函数体内判断是否大于10,然后返回true或false)判断,因为函数调用是入栈出栈,栈是在寄存器之下的速度最快,且占的空间少,而自定义异常是存在堆中,肯定异常的内存开销大!所以B对。
C选项说的是接口包含方法声明和变量声明。因为接口中方法默认是 abstract public,所以在接口只写函数声明是符合语法规则。但是变量默认是用public final static 修饰的,意思它是静态常量,常量不管在接口中还是类中必须在声明时初始化!所以C的后半句是错的,必须在声明时并给出初始化!、
第二套
1.下面这段java代码,当 T 分别是引用类型和值类型的时候,分别产生了多少个 T对象和T类型的值()
T t = new T();(值类型时:T t;)
Func(t);
Func 定义如下:
public void Func(T t) { }
正确答案: D 你的答案: B (错误)
1 1
2 1
2 2
1 2
D。引用类型作为函数的参数时,复制的是引用的地址,不会产生一个新的T;而如果T是值类型,其作为函数实参时会复制其值,也就是产生了一个新的T。所以D选项正确
值类型的对象我觉得并没有创建对象 而且值类型能叫对象吗?
答案在A和D之间 这个毫无悬念
主要就在值类型能否创建对象 能创建对象则又能创建几个对象
值类型即八大基础类型,基础类型在使用时是从常量池中获取,更严谨的而言其实是在-128~127之间 使用时是从常量池中获取,那么在使用的时候将常量池中的地址重复利用
但是在限制范围之外,得到的地址就会发生变化 代码为证
2.以下哪个命令用于查看tar(backup.tar)文件的内容而不提取它?()
正确答案: B 你的答案: C (错误)
tar -xvf backup.tar
tar -tvf backup.tar
tar -svf backup.tar
none of these
把常用的tar解压命令总结下,当作备忘:
tar
-c: 建立压缩档案
-x:解压
-t:查看内容
-r:向压缩归档文件末尾追加文件
-u:更新原压缩包中的文件
这五个是独立的命令,压缩解压都要用到其中一个,可以和别的命令连用但只能用其中一个。下面的参数是根据需要在压缩或解压档案时可选的。
-z:有gzip属性的
-j:有bz2属性的
-Z:有compress属性的
-v:显示所有过程
-O:将文件解开到标准输出
下面的参数-f是必须的
-f: 使用档案名字,切记,这个参数是最后一个参数,后面只能接档案名。
# tar -cf all.tar *.jpg
这条命令是将所有.jpg的文件打成一个名为all.tar的包。-c是表示产生新的包,-f指定包的文件名。
# tar -rf all.tar *.gif
这条命令是将所有.gif的文件增加到all.tar的包里面去。-r是表示增加文件的意思。
# tar -uf all.tar logo.gif
这条命令是更新原来tar包all.tar中logo.gif文件,-u是表示更新文件的意思。
# tar -tf all.tar
这条命令是列出all.tar包中所有文件,-t是列出文件的意思
# tar -xf all.tar
这条命令是解出all.tar包中所有文件,-x是解开的意思
压缩
tar –cvf jpg.tar *.jpg 将目录里所有jpg文件打包成tar.jpg
tar –czf jpg.tar.gz *.jpg 将目录里所有jpg文件打包成jpg.tar后,并且将其用gzip压缩,生成一个gzip压缩过的包,命名为jpg.tar.gz
tar –cjf jpg.tar.bz2 *.jpg 将目录里所有jpg文件打包成jpg.tar后,并且将其用bzip2压缩,生成一个bzip2压缩过的包,命名为jpg.tar.bz2
tar –cZf jpg.tar.Z *.jpg 将目录里所有jpg文件打包成jpg.tar后,并且将其用compress压缩,生成一个umcompress压缩过的包,命名为jpg.tar.Z
rar a jpg.rar *.jpg rar格式的压缩,需要先下载rar for linux
zip jpg.zip *.jpg zip格式的压缩,需要先下载zip for linux
解压
tar –xvf file.tar 解压 tar包
tar -xzvf file.tar.gz 解压tar.gz
tar -xjvf file.tar.bz2 解压 tar.bz2
tar –xZvf file.tar.Z 解压tar.Z
unrar e file.rar 解压rar
unzip file.zip 解压zip
总结
*.tar 用 tar –xvf 解压
*.gz 用 gzip -d或者gunzip 解压
*.tar.gz和*.tgz 用 tar –xzf 解压
*.bz2 用 bzip2 -d或者用bunzip2 解压
*.tar.bz2用tar –xjf 解压
*.Z 用 uncompress 解压
*.tar.Z 用tar –xZf 解压
*.rar 用 unrar e解压
*.zip 用 unzip 解压
-s 还原文件的顺序和备份文件内的存放顺序相同。
-t 列出备份文件的内容。
-v 显示指令执行过程。
-f 指定压缩文件
-x 从备份文件中还原文件。
3.单例模式中,两个基本要点是
正确答案: A D 你的答案: A B (错误)
构造函数私有
静态工厂方法
以上都不对
唯一实例
设计模式-单例模式
知识点
什么是单例模式?
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
单例模式有分为饿汉式和懒汉式
特点:
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
应用实例:
1、一个班级只有一个班主任。
2、Windows 是多进程多线程的,在操作一个文件的时候,就不可避免地出现多个进程或线程同时操作一个文件的现象,所以所有文件的处理必须通过唯一的实例来进行。
3、一些设备管理器常常设计为单例模式,比如一个电脑有两台打印机,在输出的时候就要处理不能两台打印机打印同一个文件。
优点:
1、在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例)。
2、避免对资源的多重占用(比如写文件操作)。
缺点:没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。
使用场景:
1、要求生产唯一序列号。
2、WEB 中的计数器,不用每次刷新都在数据库里加一次,用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多,比如 I/O 与数据库的连接等。
注意事项:getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
实例
单例模式-饿汉式
//单例模式-饿汉式
public class SingletonDemo {
public static void main(String[] args) {
//编译错误:无法实例化
// Singleton singleton = new Singleton();
//正确获取对象的方法
Singleton singleton = Singleton.getINSTANCE();
singleton.hello();
}
}
class Singleton{
//创建一个本身对象
private static final Singleton INSTANCE = new Singleton();
//让构造方法为private,这样该类就不会被实例化
private Singleton(){}
//创建一个获取对象的方法
public static Singleton getINSTANCE() {
return INSTANCE;
}
public void hello(){
System.out.println("Hello World! ——单例模式-饿汉式");
}
}
结果
Hello World! ——单例模式-饿汉式
单例模式-懒汉式(线程不安全版)
这种方式是最基本的实现方式,这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized,所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显,不要求线程安全,在多线程不能正常工作。
//单例模式-懒汉式
public class SingletonDemo2 {
public static void main(String[] args) {
Singleton2 singleton = Singleton2.getInstance();
singleton.hello();
}
}
class Singleton2{
private static Singleton2 instance;
private Singleton2(){}
public static Singleton2 getInstance() {
if (instance == null){
instance = new Singleton2();
}
return instance;
}
public void hello(){
System.out.println("Hello World! ——单例模式-懒汉式");
}
}
结果
Hello World! ——单例模式-懒汉式
单例模式-懒汉式(线程安全版)
描述:这种方式具备很好的 lazy loading,能够在多线程中很好的工作,但是,效率很低,99% 情况下不需要同步。
优点:第一次调用才初始化,避免内存浪费。
缺点:必须加锁 synchronized 才能保证单例,但加锁会影响效率。
getInstance() 的性能对应用程序不是很关键(该方法使用不太频繁)。
//单例模式-懒汉式
public class SingletonDemo3 {
public static void main(String[] args) {
Singleton3 singleton = Singleton3.getInstance();
singleton.hello();
}
}
class Singleton3{
private static Singleton3 instance;
private Singleton3(){}
public synchronized static Singleton3 getInstance() {
if (instance == null){
instance = new Singleton3();
}
return instance;
}
public void hello(){
System.out.println("Hello World! ——单例模式-懒汉式");
}
}
结果
Hello World! ——单例模式-懒汉式
饿汉式和懒汉式的区别
1.懒汉模式:顾名思义,他是一个懒汉,他不愿意动弹。什么时候需要吃饭了,他就什么时候开始想办法搞点食物。
即懒汉式一开始不会实例化,什么时候用就什么时候new,才进行实例化。
2.饿汉模式:顾名思义,他是一个饿汉,他很勤快就怕自己饿着。他总是先把食物准备好,什么时候需要吃了,他随时拿来吃,不需要临时去搞食物。
即饿汉式在一开始类加载的时候就已经实例化,并且创建单例对象,以后只管用即可。
懒汉式和饿汉式的安全和性能区别:
(1) 线程安全:饿汉式在线程还没出现之前就已经实例化了,所以饿汉式一定是线程安全的。懒汉式加载是在使用时才会去new 实例的,那么你去new的时候是一个动态的过程,是放到方法中实现的,比如:
public static synchronized Singleton getInstance(){
if(instance == null){
//什么时候用就什么时候new
instance = new Singleton();
}
如果这个时候有多个线程访问这个实例,这个时候实例还不存在,还在new,就会进入到方法中,有多少线程就会new出多少个实例。一个方法只能return一个实例,那最终return出哪个呢?是不是会覆盖很多new的实例?这种情况当然也可以解决,那就是加同步锁,避免这种情况发生 。
(2)执行效率:饿汉式没有加任何的锁,因此执行效率比较高。懒汉式一般使用都会加同步锁,效率比饿汉式差。
(3)内存使用:饿汉式在一开始类加载的时候就实例化,无论使用与否,都会实例化,所以会占据空间,浪费内存。懒汉式什么时候用就什么时候实例化,不浪费内存。
第三套
1.执行完以下代码 int [ ] x = new int[10] ;后,以下哪项说明是正确的( )
正确答案: A 你的答案: B (错误)
x[9]为0
x[9]未定义
x[10]为0
x[0]为空
数组引用类型的变量的默认值为 null。当数组变量的实例后,如果没有没有显示的为每个元素赋值,Java 就会把该数组的所有元素初始化为其相应类型的默认值。
int型的默认值为0
2.Consider the following code:
Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);
Which test would return true?
正确答案: C D E 你的答案: B C E (错误)
(s==u)
(s==t)
(s.equals(t))
(s.equals(9))
(s.equals(new Integer(9))
int和int之间,用==比较,肯定为true。基本数据类型没有equals方法
int和Integer比较,Integer会自动拆箱,== 和 equals都肯定为true
int和new Integer比较,Integer会自动拆箱,调用intValue方法, 所以 == 和 equals都肯定为true
Integer和Integer比较的时候,由于直接赋值的话会进行自动的装箱。所以当值在[-128,127]中的时候,由于值缓存在IntegerCache中,那么当赋值在这个区间的时候,不会创建新的Integer对象,而是直接从缓存中获取已经创建好的Integer对象。而当大于这个区间的时候,会直接new Integer。
当Integer和Integer进行==比较的时候,在[-128,127]区间的时候,为true。不在这个区间,则为false
当Integer和Integer进行equals比较的时候,由于Integer的equals方法进行了重写,比较的是内容,所以为true
Integer和new Integer : new Integer会创建对象,存储在堆中。而Integer在[-128,127]中,从缓存中取,否则会new Integer.
所以 Integer和new Integer 进行==比较的话,肯定为false ; Integer和new Integer 进行equals比较的话,肯定为true
new Integer和new Integer进行==比较的时候,肯定为false ; 进行equals比较的时候,肯定为true
原因是new的时候,会在堆中创建对象,分配的地址不同,==比较的是内存地址,所以肯定不同
装箱过程是通过调用包装器的valueOf方法实现的
拆箱过程是通过调用包装器的xxxValue方法实现的(xxx表示对应的基本数据类型)
总结:Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内,==比较的时候,值总是相等的(指向的是同一对象),在这个区间外是不等的。
而Float和Double则不相等, Boolean的值总是相等的