Java语言学习

温故而知新

1 面向对象语言特性

• 抽象
  
  • 关心对象有那些属性和行为，不关心具体实现。
  • abstrct class Animal与 class Dog之间的关系
• 继承
  
  • 获得现有对象属性和行为，减少实现难度
  • 让变化的软件系统获得延续性
  • class TonyDog与class Dog之间的关系
• 多态
  
  • 不同的子类型对象对同一个事件具备不同的反映
  • 前绑定编译时多态-方法重载（overload）对象内部关系
  • 后绑定运行时多态-方法重写（override）对象和子类的关系
  • 不改变逻辑代码的情况下替换实现
• 封装
  
  • 隐藏一切可以隐藏的，对外提供最简洁的接口

2 short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？

• short s1 = 1;s1 = s1 + 1; 1是int类型，s1+1需要强制转型才能赋值给s1
• s1 += 1;等价于 s1 = (short) (s1+1); 已经包含了强制转换

3 int和Integer的关系

        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;        Integer f5 = new Integer(100);        int f6 = 100;        System.out.println(f1 == f2);//true        System.out.println(f3 == f4);//false        System.out.println(f1 == f5);//false        System.out.println(f1 == f6);//true

1. int和Integer远算会自动拆箱，==的int比较是值比较
2. Integer对象之间的==比较，是地址比较
3. Integer赋值一个int型数值，会自动装箱，调用的是Integer类的valueOf方法。在Integer内部会自建一个缓存池，缓存Integer(-128)到Integer（127）的对象

 /**     * Returns a {@code Integer} instance for the specified integer value.     * <p>     * If it is not necessary to get a new {@code Integer} instance, it is     * recommended to use this method instead of the constructor, since it     * maintains a cache of instances which may result in better performance.     *     * @param i     *            the integer value to store in the instance.     * @return a {@code Integer} instance containing {@code i}.     * @since 1.5     */    public static Integer valueOf(int i) {        return  i >= 128 || i < -128 ? new Integer(i) : SMALL_VALUES[i + 128];    }    /**     * A cache of instances used by {@link Integer#valueOf(int)} and auto-boxing     */    private static final Integer[] SMALL_VALUES = new Integer[256];    static {        for (int i = -128; i < 128; i++) {            SMALL_VALUES[i + 128] = new Integer(i);        }    }

4 内存中的栈(stack)、堆(heap)和静态区(static area)

• stack 定义的变量、一个对象的引用、函数调用的现场保存
• heap 创建的对象、理论上整个内存，甚至虚拟内存都可以当作堆空间使用
• static area 定义的常量池
• Java6 开始有一种“逃逸分析”技术可以把局部对象放在stack上提升性能

5 重载的方法能否根据返回类型进行区分

假设可以通过返回值来实现重载
定义：

    public void fun(int n) {        // do something    }    // Overload    public int fun(int n) {        // do something    }

使用的时候直接使用 fun(); 现在编译器如何来推断使用的到底是那个方法？
所以不可以这样

6 JVM加载.class文件的原理

1. 把.class加载到内存，如果class存在父类先加载父类，在一次执行类的初始化操作
2. PDM-双亲委派机制。除了系统自带的Bootstrap加载器，每个加载器有且仅有一个父加载器，类加载的时候先请求父加载器加载，父加载器无能为力的时候再尝试子加载器加载
   
   1. Bootstrap 负责加载JVM的核心基础类库
   2. Extension 从系统属性的指定目录加载类库，它的父类是Bootstrap
   3. System 加载系统环境变量目录中的类库，父类是Extension
   4. 用户自定义加载器，父类是System
3. JVM不会向Java程序提供对Bootstrap的引用

7 抽象的（abstract）方法是否可同时是static,同时是本native，同时是synchronized

1. 静态方法 static 不属于类，不可被子类重写，abstract必须被重写，矛盾
2. 本地方法 native 需要使用C、C++代码实现，abstract在抽象类中不会实现，矛盾
3. 同步方法 synchronized 需要关注代码实现细节，abstract并没有代码，矛盾

8 如何把一个对象序列化到本地

1. 对象实现Serializable
2. 转换成Stream

9 GC

1. 可以有效的防止内存泄漏，尤其是在服务器端编程
2. 但是这都是自动实现的，如果程序代码存在问题还是会发生内存泄漏
3. 伊甸园（Eden） 这是对象诞生的地方，大多是对象只在这个地方出现过
4. 幸存者乐园（Survivor） 中生代。年轻代收集（Minor-GC）会把Eden对象移动到这
5. 终身颐养园（Tenured） Minor-GC不会触及到这，Major-GC（全GC）控制区域

当一个线程进入一个对象的synchronized方法A之后，其它线程是否可进入此对象的synchronized方法B

不能，如果一个线程进入一个对象的synchronized方法，表明这个对象锁已经被取走，所有的同步方法都不能进入，只能进入非同步方法。如果执行同步方法，只能在等锁池等待。

线程的基本状态以及状态之间的关系

JDBC操作数据库执行顺序

1. 加载驱动 Class.forName("oracle.jdbc.driver.OracleDriver");
2. 建立连接
Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
3. 创建语句

 PreparedStatement ps = con.prepareStatement("select * from emp where sal between ? and ?");    ps.setInt(1, 1000);    ps.setInt(2, 3000);

• 执行语句 ResultSet rs = ps.executeQuery();
• 处理结果
• 关闭资源

DAO

Data Access Object。数据不要暴露在外面直接操作，通过Accessor来操作

事务-ACID

• 原子性 要么成功 要么失败
• 一致性 不改变系统状态
• 隔离性 事务之间互不影响
• 持久性 执行结果可以固化
• 脏读 A执行的过程中，B回滚
• 不可重复读 A在从新读取前面读取过的数据，发现被B修改过了
• 幻读 A在查询数据的时候，发现插入被B提交的数据
• 第一类丢失更新 事务A撤销造成事务B提交的数据丢失
• 第二类丢失更新 A更新覆盖了B更新的数据