我不生产代码,我只是代码的搬运工
文章目录
-
- 1.Integer不同创建方法之间的区别
- 2.构造方法的几个特点
- 3.一个Java源程序文件中定义几个类和接口,则编译该文件后生成几个以.class为后缀的字节码文件
- 4.PreparedStatement知识点
- 5.Maven and Ant
- 6.正则表达式字符
- 7.Java中的修饰符
- 8.使用泛型的好处
- 9.类的加载顺序
- 10.垃圾收集机制
- 11.synchronized机制
- 12.try-catch-finally中return问题
- 13.String与==问题
- 13.Stream、File与IO
- 14. byte b = (byte)129
- 15.加载驱动程序的方法
- 16.Collection接口与Map接口
- 16.子进程与父进程
- 17.线程的锁机制
1.Integer不同创建方法之间的区别
Integer有三种创建方法,分别是
Integer a=new Integer(100);
Integer b=100;
Integer c=Integer.valueOf(100)
下面进行比较:
Integer a1=new Integer(100);
Integer b1=100;
Integer c1=Integer.valueOf(100)
a==a1 //Output:false 因为new创建的是引用对象,两个引用对象比较堆中地址,地址不同;
b==b1//Output:true,但是将b与b1改成400后结果为false
c==c1//结果与b相同
- 这是由于valueOf的源码导致的
public static Integer valueOf(int i) {
if(i >= -128 && i <= IntegerCache.high)
return IntegerCache.cache[i + 128];
else
return new Integer(i);
}
- 当valueOf或者自动装箱的数在-128到127之间时,会直接查看内存,因此并不会使用new新建对象,而超出范围,则会new,因此结果为false
举例:
Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);
// i01==i02==i03,i04与上述三个不相等
2.构造方法的几个特点
1.构造方法可以被重载,一个构造方法可以通过this关键字调用另一个构造方法,this语句必须位于构造方法的第一行;(但不可以被重写)
2.当一个类中没有定义任何构造方法,Java将自动提供一个缺省构造方法;
3.子类通过super关键字调用父类的一个构造方法;
4.当子类的某个构造方法没有通过super关键字调用父类的构造方法,通过这个构造方法创建子类对象时,会自动先调用父类的缺省构造方法
5,构造方法不能被static、final、synchronized、abstract、native修饰,但可以被public、protected,default,private修饰;
6.构造方法不是类的成员方法;
7.构造方法不能被继承。
3.一个Java源程序文件中定义几个类和接口,则编译该文件后生成几个以.class为后缀的字节码文件
4.PreparedStatement知识点
PreparedStatement是预编译的,使用PreparedStatement有几个好处
a. 在执行可变参数的一条SQL时,PreparedStatement比Statement的效率高,因为DBMS预编译一条SQL当然会比多次编译一条SQL的效率要高。
b. 安全性好,有效防止Sql注入等问题。
c. 对于多次重复执行的语句,使用PreparedStament效率会更高一点,并且在这种情况下也比较适合使用batch;
d. 代码的可读性和可维护性。
- CallableStatement接口扩展PreparedStatement,用来调用存储过程,它提供了对输出和输入/输出参数的支持。CallableStatement
接口还具有对 PreparedStatement 接口提供的输入参数的支持。
继承关系:
5.Maven and Ant
- Ant和Maven都是基于Java的构建(build)工具。理论上来说,有些类似于(Unix)C中的make ,但没有make的缺陷。Ant是软件构建工具,Maven的定位是软件项目管理和理解工具。
- Ant构建文件默认命名为build.xml,Maven默认构建文件为pom.xml
- Ant特点:
- 1.没有一个约定的目录结构
2.必须明确让ant做什么,什么时候做,然后编译,打包
3.没有生命周期,必须定义目标及其实现的任务序列
4.没有集成依赖管理 Maven特点:
1.拥有约定,知道你的代码在哪里,放到哪里去
2.拥有一个生命周期,例如执行 mvn install 就可以自动执行编译,测试,打包等构建过程
3.只需要定义一个pom.xml,然后把源码放到默认的目录,Maven帮你处理其他事情
4.拥有依赖管理,仓库管理
6.正则表达式字符
7.Java中的修饰符
8.使用泛型的好处
1,类型安全。
- 泛型的主要目标是提高 Java程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在一个高得多的程度上验证类型假设。没有泛型,这些假设就只存在于程序员的头脑中(或者如果幸运的话,还存在于代码注释中)。
2,消除强制类型转换。
- 泛型的一个附带好处是,消除源代码中的许多强制类型转换。这使得代码更加可读,并且减少了出错机会。
3,潜在的性能收益。
- 泛型为较大的优化带来可能。在泛型的初始实现中,编译器将强制类型转换(没有泛型的话,程序员会指定这些强制类型转换)插入生成的字节码中。但是更多类型信息可用于编译器这一事实,为未来版本的JVM 的优化带来可能。由于泛型的实现方式,支持泛型(几乎)不需要 JVM或类文件更改。所有工作都在编译器中完成,编译器生成类似于没有泛型(和强制类型转换)时所写的代码,只是更能确保类型安全而已。
9.类的加载顺序
public class Base
{
private String baseName = "base";
public Base()
{
callName();
}
public void callName()
{
System. out. println(baseName);
}
static class Sub extends Base
{
private String baseName = "sub";
public void callName()
{
System. out. println (baseName) ;
}
}
public static void main(String[] args)
{
Base b = new Sub();
}
}
1.类的加载顺序:
(1) 父类静态代码块(包括静态初始化块,静态属性,但不包括静态方法)
(2) 子类静态代码块(包括静态初始化块,静态属性,但不包括静态方法 )
(3) 父类非静态代码块( 包括非静态初始化块,非静态属性 )
(4) 父类构造函数
(5) 子类非静态代码块 ( 包括非静态初始化块,非静态属性 )
(6) 子类构造函数
其中:类中静态块按照声明顺序执行,并且(1)和(2)不需要调用new类实例的时候就执行了(意思就是在类加载到方法区的时候执行的)
2.其次,需要理解子类覆盖父类方法的问题,也就是方法重写实现多态问题。
Base b = new Sub();它为多态的一种表现形式,声明是Base,实现是Sub类, 理解为 b 编译时表现为Base类特性,运行时表现为Sub类特性。
当子类覆盖了父类的方法后,意思是父类的方法已经被重写,题中 父类初始化调用的方法为子类实现的方法,子类实现的方法中调用的baseName为子类中的私有属性。
由1.可知,此时只执行到步骤4.,子类非静态代码块和初始化步骤还没有到,子类中的baseName还没有被初始化。所以此时 baseName为空。 所以为null。
10.垃圾收集机制
1,新生代:
(1)所有对象创建在新生代的Eden区,当Eden区满后触发新生代的Minor GC,将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。
(2)保证一个Survivor区是空的,新生代Minor GC就是在两个Survivor区之间相互复制存活对象,直到Survivor区满为止。
2,老年代:
当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话,就将触发Full GC,针对整个堆(包括新生代、老年代、持久代)进行垃圾回收。
3,持久代:
持久代如果满了,将触发Full GC。
11.synchronized机制
public class Test {
private synchronized void a() {
}
private void b() {
synchronized (this) {
}
}
private synchronized static void c() {
}
private void d() {
synchronized (Test.class) {
}
}
}
//修饰非静态方法 锁的是this 对象
//修饰静态方法 锁的是class对象
12.try-catch-finally中return问题
情况1:
- try{} catch(){}finally{} return;
- 显然程序按顺序执行。
情况2:
- try{ return; }catch(){} finally{} return;
- 先执行try块中return语句(包括return语句中的表达式运算),但不返回;
- 执行finally语句中全部代码 最后执行try中return 返回
- finally块之后的语句return不执行,因为程序在try中已经return。
情况3:
- try{ } catch(){return;} finally{} return;
- 程序先执行try,如果遇到异常执行catch块,
- 有异常:
- 执行catch中return语句,但不返回
- 执行finally语句中全部代码, 最后执行catch块中return返回。
- finally块后的return语句不再执行。
- 无异常:
- 执行完try再finally再return…
情况4:
-
try{ return; }catch(){} finally{return;}
-
执行try块return语句(包括return语句中的表达式运算),但不返回;
-
再执行finally块,
-
执行finally块,有return,从这里返回。
-
此时finally块的return值,就是代码执行完后的值
情况5: -
try{} catch(){return;}finally{return;}
-
程序执行catch块中return语句(包括return语句中的表达式运算),但不返回;
-
再执行finally块,
-
执行finally块,有return,从这里返回。
情况6: -
try{ return;}catch(){return;} finally{return;}
-
程序执行try块中return语句(包括return语句中的表达式运算),但不返回
-
有异常:
-
执行catch块中return语句(包括return语句中的表达式运算),但不返回;
-
再执行finally块
-
执行finally块,有return,从这里返回。
-
无异常:
-
再执行finally块 执行finally块,有return,从这里返回。
13.String与==问题
public class Demo {
public static void main(String args[]) {
String str1 = new String("hello");
String str2 = new String("hello");
String str3 = "hello";
String str4 = "hello";
String str5 = "he"+"llo";
String str6 = "he";
String str7 = "llo";
System.out.println(str1==str2);
System.out.println(str1==str3);
System.out.println(str3==str4);
System.out.println(str3=="hello");
System.out.println(str4==(str6+str7));
}
}
new出的String对象存储在堆当中。
String str3=“hello"存储在字符串常量池中。
String str5=”he"+“llo” 因为String是不可更改的,因此这个String对象是new出的。
13.Stream、File与IO
14. byte b = (byte)129
1.强制类型转换
将int类型强制转换成byte类型
00000000 00000000 00000000 10000001只保留最后8位100000001
2.源码、补码、反码
源码:10000001
反码:11111110
补码:11111111
结果:-127
15.加载驱动程序的方法
-
加载驱动方法
-
1.Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);
2.DriverManager.registerDriver(new com.mysql.jdbc.Driver());
3.System.setProperty(“jdbc.drivers”, “com.mysql.jdbc.Driver”);
16.Collection接口与Map接口
16.子进程与父进程
- 子进程得到的是除了代码段是与父进程共享以外,其他所有的都是得到父进程的一个副本,子进程的所有资源都继承父进程,得到父进程资源的副本,子进程可获得父进程的所有堆和栈的数据,但二者并不共享地址空间。两个是单独的进程,继承了以后二者就没有什么关联了,子进程单独运行;进程的线程之间共享由进程获得的资源,但线程拥有属于自己的一小部分资源,就是栈空间,保存其运行状态和局部自动变量的。