您的位置:首页 > 职场人生

笔试面试前的总结,未完待续

2019-08-09 18:34 731 查看

Review

笔试题不懂的东西:

[外链图片转存失败(img-o8tAP5bE-1565346722870)(C:\Users\Administrator\Desktop\1564650956527.jpg)]

~:按位取反 eg:~101010 == 010101

&:有0则0,全1才1

|:有1则1,全0才0

&&:一假即假

||:一真即真

<<:乘以2的n次方 >>:除以2d的n次方 顾明思议,移位运算要是整型数据类型

^按位异或

split("\\d"):转义字符\ 加上\d匹配0-9,按照0-9中任意数字进行拆分

super表示调用父类构造器
私有方法不可以被子类访问所以不能重写

构造方法:

1、构造方法方法名必须和类名相同

2、构造方法没有返回类型,也不能定义void(方法名前不声明方法类型)

3、构造方法用来给对象初始化赋值

4、一个类中可以有多个构造方法(重载),若没有定义构造方法,系统会自动插入无参构造器

String regex = “\.\s*“是指匹配”.(任意空格)”

构造器参数与成员变量相同时必须用this区别,不然该构造器视为无用(eg:name=name)

子类重写父类方法权限问题:

子类不能缩小父类方法的访问权限(你继承了就够了,不要变本加厉想要占为己有)

java中数据的运算:

如果进行运算的是两个变量:会先进行类型的提升,然后在进行运算赋值(byte short char)

其中+=这种运算符在赋值运算时会自动转换

如果进行运算的是两个常量:会先进性运算,然后判断是否满足类型范围,满足之后在进行赋值。

String 定长字符串及地址问题:

public static void main (String [] args) {

String foo = “blue”;

String bar = foo;

foo = “green”;

System.out.println(bar);

}

分析:

1、foo指向的地址值是“blue"

2、bar的地址值和foo的地址值相同

3、foo的地址值指向新的地址值green了,但是这跟bar地址值又有什么关系呢

注:String类是定长字符串,调用一个字符串的方法以后也会形成一个新的字符串。不再是以前的字符串了。

三目运算符结果问题:

三目运算符中:第二个表达式和第三个表达式中如果都为基本数据类型,整个表达式的运算结果

由容量高的决定。eg:(x>4) ? 99.9 :9 99.9是double类型 而9是int类型,double容量高输出为9.0。

构造方法:类中可以有与类名相同的方法。

一道很容易出错的题:

Set s=new HashSet();

for(Short i=0;i<100;i++)

{

s.add(i);

s.remove(i-1);

}

/*

i是Short类型,i-1是int类型,自动装箱成Integer类型。所以remove方法失效,不能对集合进行操作,所以只有add方法

*/

**栈:**栈是先进后出线性表

子父类重写的问题:

子类中有和父类方法名相同参数列表不同,可以。可以认为是新定义的方法;

但是如果方法名相同,参数列表相同,访问权限,异常都相同,只有返回类型不同,编译则不答应。

面试不懂的东西:

线程安全是什么意思?要多线程干嘛?
什么情况下使用JavaBean?

1、JavaBean 是一种规范的标准Java对象:其中必须包括私有成员变量和getter setter方法,公共的构造器,无参构造器,实现序列化接口。

2、它是一种编程思想。实现了数据的封装,我们使用数据的时候只要调用该对象即可。

3、同时访问数据库是可以作为接收类型存储数据库取出的数据,也可以作为传入对象将javabean类型的对象往数据库里放。

讲讲你对java反射机制的了解:

反射就是对于任意一个类我们都能获取其属性和方法;对于任意一个对象,我们都能调用其属性和方法;动态地获取属性及调用方法就是Java反射

加载类:Class myClass = Class.forName(“包名.类名”);

======================================================

获取私有成员变量:Field f = myClass.getDeclareField(“name”);

调用成员变量:Object obj1 = myClass.getConstructor().newInstance();

​ f.setAccessible(true);

​ f.set(obj,“打不死的小强哈哈哈哈”);

==========================================================

获取公共的构造器:Contructor c = myClass.getConstructor();//传参就是有参构造器,传null就是无参构造器;

​ 私有的构造器:myClass.getDeclareConstructor(String name);

调用公共构造器:Object obj2 = myClass.getContructor(char.class);

​ c.newInstance(“男”);//获取传入一个参数的构造器

===========================================================

获取方法:Methd m = myClass.getMethod(“show1”,String .class);//获取方法名是show1,传入的参数是String类型的方法

调用方法:Object obj = myClass.getConstructor().newInstance();

​ m.invoke(obj,“打不死的小强”);

包装类和基本数据类型用“==”比较:

Integer a =100;//或者是1000

int b= 100;//或者是1000

sout(a == b);//都为true

Linux基本操作符:

pwd:查看当前目录完整路径

ls:查看目录

cd:切换当前路径位置

ctrl+insert:复制

shift+insert:粘贴

mkdir:创建目录

rmdir:删除目录(空目录)

find + ‘文件名/目录名’:查找文件或目录

grep:查找文件内容

json dto vo是什么?

vo是View Object视图对象

dto:Data Transfer Object 是数据传输对象

json是轻量级的简洁的文本形式存储和表示数据的数据交换格式

什么时候用多线程?

程序包含复杂的计算任务时;处理速度较慢的外围设备时,用独立的线程处理任务,让程序不需要专门等待结果而耗费时间。

一般servelet框架本身是有多线程的,只是是由webserver帮我们启动了,不需要我们自己去启动;

一般处理网络通信问题,都是需要自己做多线程处理的;

多线程主要作用就是两个:

1.不阻塞主线程任务

2.并发,提高吞吐量

多线程的意义:提高任务执行效率

​ 多线程要考虑数据安全。不能同时处理同个数据的时候就要考虑到锁机制

sql注入:

欺骗服务器执行恶意的sql命令,欺骗服务器授予其权限。比如在登录时用户名和密码输入一些关于永远成立 的语句‘1‘ =’1‘这样的语句。web提交表单给服务器,服务器进行后台操作时sql语句会被修改。

basic:

变量命名规则:

1、字母、数字、$、_组成;

2、不能以数字开头;

3、不能有java中保留字:if、for等;

4、大小写敏感;

5、中文最好不要用。

8中基本数据类型:可以进行转换(隐式和显式)

byte(1)–short(2)–int(4)–long(8)–float(4)–double(8)

​ char(2)(0~65535)—

其中char支持:

char a = ‘A’ ; char b= 32 ; char c = ‘\u0041’

分支结构:

if-else ; switch-case(优势:可以用break跳出分支结构;很明显结构很清晰;因此执行效率高。)1.7之后接受switch中可以使用字符串表达式。本来只能接受整型直接量。

循环结构:

两要素:循环条件boolean表达式;循环体

while;doWhile;for;

break:只能使用在switch和循环结构中;break表示终止循环执行循环后面的语句。

continue:只能使用在循环语句中;continue表示跳过当前循环体中剩余语句而去执行下一次循环。

程序:算法+数据结构
数组:

1、最基本的数据结构
2、同种数据类型元素的集合

3、线性顺序排列,一个接一个

4、有索引下表

三种数组初始化方式:

简单的:int[] arr1 = {1,2,3,4,4};//只能声明时进行初始化

静态的:int[] arr2 = new int[] {2,54,57,6};

//或者:

​ int[] arr2 ;

​ arr2 = new int[]{2,54,57,6};

动态的:int[] arr3 = new int[5];

其中都使用8种基本数据类型的默认值:

long int byte short 都是0 char类型是空字符串;double float是0.0

数组复制问题:

Arrays.copyOf(srcName,int length)//可以实现数组的扩容,只要src.length+1;进行截取只要小于src.length

System.arrayCopy(src,int index,dest,int index,int length)

流程:先将目标数组写好,然后将原数组复制到目标数组的dest位置上,复制的元素是src数组 index位置长度为length的元素们

数组排序:

冒泡排序:

public class BubbleSort{

​ public static void main(String[] args){
​ //随机产生11个元素

​ int[] arr = new int[11];

​ for (int i = 0 ; i < arr.length ; i ++){

​ Random r= new Random();

​ int elem = r.nextInt(100);

​ arr[i] = elem ;

​ }

​ //进行冒泡排序 : 11个元素排序10次
for(int j = 10 ; j > 0 ; j --){

​ for(int i = 1 ; i <= j ; i++){
​ if(arr[i-1] > arr[i]){
​ int temp = arr[i-1];

​ arr[i - 1] = arr[i];

​ arr[i] = temp;

​ }

​ }

​ }

//增强for循环遍历出数组内容

​ }

}

return作用:

将值返回给调用方

结束当前方法

oop

什么是类?

类是抽象数据类型:不仅定义了抽象数据类型组合(成员变量),还定义了针对抽象数据类型的操作(方法),说到底类时对象的概括,对象是类的具体实现。======类时对象的模子;是具有相属性和方法的对象的集合

方法签名:

1、方法名

2、参数列表(类型和数量)

对象内存管理:

对象存储在堆中,没有任何引用指向的对象被视为被废弃的对象,Java中gc(Garbage Collection)垃圾回收机制针对没有任何引用指向的对象会进行回收。这是Java自带的自动运行这的线程。如果没有被即使回收,会因为内存占用过多而导致内存泄漏

局部变量和成员变量的区别:

1、局部变量存储在方法中,成员变量存储在方法外;

2、局部变量声明时必须设定初始值,成员变量可以不设置初始值;

3、局部变量在方法被加载时创建,存储在栈中,方法调用结束,被清除;成员变量在被实例化后存储在堆中,对象被回收,成员变量失效。

实例变量:是类的成员变量;类变量或静态成员变量必须用static修饰;

静态变量:是所有对象所共享的,所以上述代码中的几个对象操作是同一静态变量x, 静态变量可以通过类名调用。

重写和重载的区别:

重写:

子类重写父类,方法名相同参数列表也相同,只是方法的实现不同。子类重写父类方法后,无论是子类调用还是父类调用,执行的都是重写后的版本。

重写遵循编译器绑定,程序根据调用该方法的引用指向的对象绑定哪个方法

子类方法的返回值必须和父类保持一致,子类方法的访问修饰符不能严于父类,子类的异常不能比父类大。

重载:

方法名相同参数列表不同;常见的有构造器的重载。程序在运行时根据参数个数或参数类型决定调用哪个方法。

重载遵循运行期绑定,程序根据参数个数和参数类型的不同决定绑定哪个方法

抽象类和接口的区别:

1、抽象类和接口都不能直接实例化。如果要实例化,该抽象变量必须指向实现该抽象类的抽象实现类。接口变量必须指向实现该接口的接口实现类。

2、接口可以做方法的申明,不能做方法的实现。而抽象类既可以做方法的申明又可以做方法的实现,且在方法的申明的时候不能做方法的实现。

3、接口中只有抽象方法,而抽象类中即可以有抽象方法也可以有普通方法,抽象类中也可以一个抽象方法也没有,这个不会有语法错误。但是毫无意义,说到方法:抽象类中的抽象方法不能是静态的私有的。因为这些方法要被子类实现。抽象类中可以有静态方法,但静态和抽象不能共存在同一个方法上。

4、接口中的变量只能是公共的静态的常量,而抽象类中的变量是普通成员变量(也就是说可以有private修饰的成员变量)

5、接口可以继承接口并且可以多继承,抽象类只能单继承

访问控制修饰符访问权限:

从打到小依次是:public protected,默认 ,private
最大能访问的:其他包中的类,子类,同一个包中的类,本类。

static:

static是属于类的,static修饰的成员变量和方法都存放在方法区,static方法中不能调用非static方法,必须new 出该非static类,然后用该类去调用

非static的内部类不可以使用static成员;只有在顶层类中或者static修饰的内部类中可以使用static,当内部类用static修饰了,就不能调用外部类的非static成员

final:

修饰局部变量是常量

修饰成员变量是地址值不可以被改变:final规定了一旦你指向一个对象了就不要乱指了;当然你阻挡不了你对象发生改变,那他随意。

修饰方法是不可以被重写

修饰类不可以被继承

final初始化:构造器中进行初始化;声明同时进行初始化:

封装:

口语表达:简单来说就是功能都给你实现好了,你不用了解他是怎么实现的只要直接去用就可以了,但这是对于使用者来说,对于开发者,封装就得我们自己干。那怎么实现封装呢?这个问题我们应该反过来问使用者,对于使用者自然希望越简单越好,所以我们开发者要将复杂的代码封死不让啊使用者接触。为什么不让使用者去接触呢?因为大多数使用者都是不大专业的,如果暴露了太多的接口给他们,就会出现一些稀奇古怪的问题,就好比让啊一个不会做酸菜鱼的人去做酸菜鱼,肯定是不会做的,但是如果我们给它一条鱼和调料,让她直接放进锅里就会简单很多,所以,我们将复杂代码封装起来,就会避免一些不必要的麻烦。

继承:

继承的作用简单来说就是实现代码的重用;子类继承父类后可以使用父类的方法,还可以在原有的基础上进行功能的补充;比如说学生一定是人,但是比人有更多的属性和方法,所以继承在一定程度上消除了机构上的重复;Java中只能实现单继承,不能多继承。

多态:

多态靠的是父类接口中的引用变量指向具体实现类的实例对象。而程序调用的是引用变量指向的具体实现类的方法而不是引用变量的类型中定义的方法。

j2se:

String 是什么?常用api?

String是静态字符串常量。一旦创建不可以被改变;创建在常量池中;是用final修饰的,不可以被继承。

对于重复出现的字符串,jvm会首先在常量池中查找,找到后知己返回这一个对象,不会创建新对象。

api:substring(),indexOf();lastIndexOf();charAt();split();startsWith();endsWith();toUpperCase();toLowerCase();replace();replaceAll();int indexOf(String s , int index):返回指定字符串s在字符串中从index开始第一出现的索引

==:

对于基本数据类型:比较的是值得大小

对于引用类型:比较的是引用的地址值

equals:

默认情况下;不进行重写比较的是地址值(Object)

重写后(String, Date, Integer)比较的是值内容

StringBuilder和StringBuffer区别:

他们都是可变字符串

StringBuilder是非线程安全的,StringBuffer是线程安全的,他们几乎无差别,差别就在于StringBuffer里的大部分方法都是synchronize修饰的,他们拥有的方法:charAt();delete(int i1,int i2);indexOf(String s);

append();reverse();replace()

执行效率:StringBuider>String BUffer>String

String和StringBuilder区别:

[外链图片转存失败(img-hBYFkhwd-1565346722874)(C:\Users\Administrator\Desktop\14ce36d3d539b60078c4295def50352ac75cb7d5.jpg)]

1、String是不可变字符串,其内容不可变,引用变量名字可变;StringBuilder是可变字符串

2、StringApi中没有reverse方法,delete(),insert();;StringBuilder中没有replaceAll方法
3、String中重写了equals()方法,StringBuilder没有重写,比较的还是地址值

Date:

Date()中的方法:setTime();getTime()getTime()返回类型是Date类型

SimpleDateFormat:格式化:new SimpleDateFormat(“yyyy-MMM-dd HH:mm:ss”).format(Date date)

​ 解析:new SimpleDateFormat(“yyyy-MM-dd”).parse(String date)

Canlendar();静态工厂方法:getInstance();

Collection:
List:Map下的接口

List是有序的(存储顺序和取出顺序一致);

List存储的元素可以重复;

List接口常用子类有:

ArrayLiist LinkedList vector

List中常用方法:

add(E elem);add(int Index,Object o)//可以插入一个新的集合 ;remove(int index);remove(E elme);set(Int index,E elem);get(int Index);

List中的遍历可以用迭代器:

Iterator it = list.Iterator();

while(it.hasNext){

sout(it.next)

}

这其中不能对list进行增删改的操作,会产生ConcurrentModificationException异常,产生数据的不确定性,解决方法:可以使用ListIterator代替

List存储数据结构有哪些?

堆栈、队列、数组、链表

堆栈:先进后出 队列:先进先出

数组:增删慢,查询快。

增的话必须先创建一个新的数组 将新插入的元素放到指定位置,旧数组的元素按照索引一一对应到新数组上

而对于链表:增删就比较块,查询速度慢:要进行遍历,时间复杂度是o(n)

链表的增:加入现在有两个元素,每个元素都有两个引用,第一个引用指向前一个元素,第二个引用指向后一个元素,将新插入的元素的后一个引用的地址值该为第二个引用的地址,即让其指向第二个元素;让啊第一个元素的后一个引用地址值改为插入的元素的前驱索引值,即让其指向新插入的元素;

所以只要改变地址值即可实现插入和删除

ArrayList和LinkedList的区别就在于数组和链表的区别

而他们都是非线程安全的,都是非同步的

而Vector是同步的线程安全的

Vextor是早期的迭代器,有独特的枚举取出元素方式。

集合转数组:list.toArray()

数组转集合:Arrays.asList();

Set:Collection接口下的子接口

set是存储既可以有序又可以无序,但是不能重复的集合。存储有序的set集合有LinkedHashSet:底层是哈希表和链表的结构,所以他可以保证元素的不重复且有序;存储无序的set集合有HashSet:

set中保证数据不重复的规则是:先判断新增的元素的hashcode值是否和集合中的元素的hashCode值相等?如果不相等,不是同一个元素,直接添加进set结合中;如果相等,再对equals()方法进行判断,如果返回truz则是相同元素,不可以添加进集合中,如果返回false则是不同元素,可以添加集合;因此。想要使得set集合实现存储不重复元素,必须让自定义类实现equals和hashCode方法,否则比较的只是地址值,不是元素内容。

至于它的方法大致和List相同,实际操作中可以用.获取到,但是不一样的是他没有get方法,因为他是无序的存储进的元素没有索引值。

锁机制包括哪两个部分?

锁的对象

锁的代码块

锁的对象可以包括哪三种?

锁对象、锁普通方法、锁静态方法(相当于锁类对象)

线程安全的API:

Map中:HashTableConcurrentHashTable;

List中:Vector

io中:StringBuffer

让线程停止执行的方法:

sleep() ; wait() ; notify() ; stop() ; synchronized() ; yield() ;

线程生命周期:

[外链图片转存失败(img-wcVKndsx-1565346722878)(C:\Users\Administrator\Desktop\线程生命周期.png)]

Jdbc访问数据库基本操作:

加载驱动Class.forName----创建连接-----创建preparestatement–定义sql语句 ----数据库操作 ---- 返回结果集并进行操作 ---- 关闭连接

PrepareStatement和statement的区别:

preparestatement是预编译,支持批处理,效率高,安全性高,但是其开销比sattement大。

jdbc访问数据库具体实现代码:

jdbc:oracle:thin:@localhost:1521:XE

public static void main(String[] args) {
//加载驱动
Class.forName("oracle.jdbc.driver");
//创建连接
Connection conn  = DriverManager.getConnection("jdbc:oracle:thin:@192.168.0.226:1522:itek",
"java12",
"itek");
//创建ststament
Statement state = conn.createStatement
//创建sql语句
String sql = "select id ,name from emp where id = 1;
//执行sql语句
ResultSet rs = state.executeQuery(sql);
//读取语句
while(rs.next){
rs.getString("name")+":"+rs.getInt("id");
}
//关闭资源
conn.close();
}
public static void main(String[] args) {
Class.forName("com.mysql.jdbc.driver");
Connection conn = DriverManeger.getConnection("jdbc:MySql://localhost:3306/wpzhang"
"root",
"ITEK");
PrepareStatement ps = conn.prepareStatement("select id , name from emp_wpzhang");
ResultSet rs = ps.executeQuery();
while(rrs.next()){
rs.getString("name")+":"+rs.getInt("id");
}
conn.close();
}

======================================================对比正确的
/*
执行过程:
1、加载驱动,创建连接
2、创建语句对象
3、执行sql语句
4、解析结果集
*/
Class.forName("com.mysql.jdbc.Driver");//加载驱动
Connection conn = DriverManager.getConnection("jdbc:MySql://localhost:3306/wpzhang",//建立连接
"root",
"ITEK");
Statement stat =  conn.createStatement();//创建语句对象
String sql = "select empno,ename,job from emp_wpzhang";//用创建出来的对象执行sql语句
ResultSet rs  = stat.executeQuery(sql);//查询结果是一个结果集,所以用ResultSet接收
/*
解析结果集
next()当前指针指向的下一行是否有数据
-有:返回true
-无:返回false
-并且指针向下移动一位
-打印输出字段对应的值:
-getXxx("字段名"):用来获取当前rs指针指向的记录中字段名对应的数据,
并且该数据能自动转换成Xxx类型,若不能转换会出错
-getXxx(字段的索引值):用来获取当前rs指针指向的记录中字段索引值对应的数据。
并且该数据能自动转换成 Xxx类型,否则会出错
*/
while(rs.next()) {
System.out.println(rs.getInt("empno") + ":" + rs.getString("ename") + ":" + rs.getString("job"));
}
conn.close();
jdbc脏读:
jdbc幻读:

数据库

数据库中模糊查询所需通配符:

_匹配单个字符

%匹配0-多个字符

查询语句的执行顺序:from–where–group by-- having-- order by-- select
排序关键字:ASC DESC
查询条件中的where中可用关键字8:

±&/ and/or in/not in is null/is not null between…and… like…_/%… distinct去重 all/any

聚合函数(只能在select中使用)min max avg sum nvl(comm,0)配合sum avg使用 count
子查询可以在哪几个语句中?

select from where having

子查询返回结果可以分为哪三种?

单行单列:一个数据

多行单列:集合

多行多列:表

分页查询:起始值start= (pageNo - 1)*pageSize

​ 终点值end = pageSize*pageNo

数据库事务控制:ACID

A:Atomicity原子性。事务的各项操作都是要么全部成功,要么全部失败。江湖义气一点说:就是同生共死

C:Consistence:一致性。事务的执行结果应该从一个一致性状态到另一个一致性状态。例如存钱和取钱后金额总数保持不变。

I:Isolation:隔离性。并发执行的事务之间不会相互影响。比如多个用户同时向一个账户转钱,最后的结果应该和他们按先后顺序转钱的结果一样。

D:Duration:持久性。事务一旦提交,其对数据库的更新就是永久性的。

序:from–where–group by-- having-- order by-- select

排序关键字:ASC DESC
查询条件中的where中可用关键字8:

±&/ and/or in/not in is null/is not null between…and… like…_/%… distinct去重 all/any

聚合函数(只能在select中使用)min max avg sum nvl(comm,0)配合sum avg使用 count
子查询可以在哪几个语句中?

select from where having

子查询返回结果可以分为哪三种?

单行单列:一个数据

多行单列:集合

多行多列:表

分页查询:起始值start= (pageNo - 1)*pageSize

​ 终点值end = pageSize*pageNo

数据库事务控制:ACID

A:Atomicity原子性。事务的各项操作都是要么全部成功,要么全部失败。江湖义气一点说:就是同生共死

C:Consistence:一致性。事务的执行结果应该从一个一致性状态到另一个一致性状态。例如存钱和取钱后金额总数保持不变。

I:Isolation:隔离性。并发执行的事务之间不会相互影响。比如多个用户同时向一个账户转钱,最后的结果应该和他们按先后顺序转钱的结果一样。

D:Duration:持久性。事务一旦提交,其对数据库的更新就是永久性的。

内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: