2017年5月小结

2017-06-09

　　这一个月时间过得很快，主要就是继续按照之前制定的计划进行学习和找实习。准备好好打理自己的博客和GitHub，所以把之前的一些东西整理到GitHub上面，也阅读了《图解HTTP》、《MYSQL必知必会》两本书，然后对Java进行了一个加强的学习。

Java加强学习

Java加强

找实习总结

众安保险：技术面，大概四十分钟。面试是在楼下的一个咖啡厅，主要的问的都是简历上写的内容：IO流、反射、多线程、集合泛型、动态代理、静态代理。笔试题：两道编程题，主要考察的是HashSet、TreeSet。
中软融鑫：Hr面，一个小时左右。其实也没聊什么，很快就伸出了橄榄枝。不过建议我去做数据库开发(这边的数据库开发是对数据进行一些处理，然后存储到Oracle中)。我的体会是：Hr完全不懂技术，然后我和另一个人同时面的都是Java岗位，她们缺做数据库开发的人，就说我们的经历更适合做数据库开发，跟我扯什么未来的规划，做数据库可以以后做项目经理，带团队，做Java开发就是个码农等等。最不能理解的是，说之前很多面试的人都不是很符合要求，说上海理工的学生跟我们的差距是不是因为学校的原因等等，总之给我留下的印象很差。

展开全文 >>

深入理解Java多线程及并发

2017-05-25

一、线程创建的两种方式及区别

1.扩展Thread类

2.实现Runnable接口

3.两者区别

采用继承Thread类方式：
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。
采用实现Runnable接口方式：
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况。
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

Runnable可以实现资源共享但Thread不能原因：

　　因为一个线程只能启动一次，通过Thread实现线程时，线程和线程所要执行的任务是捆绑在一起的。也就使得一个任务只能启动一个线程，不同的线程执行的任务是不相同的，所以没有必要，也不能让两个线程共享彼此任务中的资源。

　　一个任务可以启动多个线程，通过Runnable方式实现的线程，实际是开辟一个线程，将任务传递进去，由此线程执行。可以实例化多个 Thread对象，将同一任务传递进去，也就是一个任务可以启动多个线程来执行它。这些线程执行的是同一个任务，所以他们的资源是共享。

package test;
import java.io.IOException;
public class Test {
    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        // 第一种
        Thread t = new Thread(new Test2());
        t.start();
        // 第二种
        Thread t1 = new Thread(new Test3());
        t1.start();
    }
}
class Test2 implements Runnable {
    public void run() {
    }
}
class Test3 extends Thread {
    public void run() {
    }
}

展开全文 >>

深入理解Java动态代理

2017-05-25

一、静态代理

package common;
public class Test {
    static interface Subject{
        void sayHi();
        void sayHello();
    }
    
    static class SubjectImpl implements Subject{
        @Override
        public void sayHi() {
            System.out.println("hi");
        }
        @Override
        public void sayHello() {
            System.out.println("hello");
        }
    }
    
    static class SubjectImplProxy implements Subject{
        private Subject target;
        
        public SubjectImplProxy(Subject target) {
            this.target=target;
        }
        
        @Override
        public void sayHi() {
            System.out.print("say:");
            target.sayHi();
        }
        @Override
        public void sayHello() {
            System.out.print("say:");
            target.sayHello();
        }
    }
    
    public static void main(String[] args) {
        Subject subject=new SubjectImpl();
        Subject subjectProxy=new SubjectImplProxy(subject);
        subjectProxy.sayHi();
        subjectProxy.sayHello();
    }
}

　　这段代码中首先定义了一个Subject接口，接口中有两个方法。然后定义了SubjectImpl类实现Subject接口并实现其中的两个方法，到这里肯定是没问题的。现在再定义一个SubjuectImplProxy类，也实现Subject接口。这个SubjectImplProxy类的作用是包装SubjectImpl类的实例，它的内部定义一个变量target来保存一个SubjectImpl的实例。SubjectImplProxy也实现了接口规定的两个方法，并且在它的实现版本中，都调用了SubjectImpl的实现，但是又添加了自己的处理逻辑。相信这段代码不难理解，它通过对SubjectImpl进行包装，达到了给输出内容添加前缀的功能。这种代理方式叫做静态代理。

展开全文 >>

深入理解Java类加载器

2017-05-24

1. 类的加载过程

　　JVM将类加载过程分为三个步骤：装载（Load），链接（Link）和初始化(Initialize)链接又分为三个步骤：

装载：查找并加载类的二进制数据；
链接：

验证：确保被加载类的正确性；

准备：为类的静态变量分配内存，并将其初始化为默认值；

解析：把类中的符号引用转换为直接引用；
初始化：为类的静态变量赋予正确的初始值；

2. 类的初始化

类什么时候才被初始化：

1）创建类的实例，也就是new一个对象
2）访问某个类或接口的静态变量，或者对该静态变量赋值
3）调用类的静态方法
4）反射（Class.forName(“com.lyj.load”)）
5）初始化一个类的子类（会首先初始化子类的父类）
6）JVM启动时标明的启动类，即文件名和类名相同的那个类

只有这6中情况才会导致类的类的初始化。

类的初始化步骤：

1）如果这个类还没有被加载和链接，那先进行加载和链接
2）假如这个类存在直接父类，并且这个类还没有被初始化（注意：在一个类加载器中，类只能初始化一次），那就初始化直接的父类（不适用于接口）
3)加入类中存在初始化语句（如static变量和static块），那就依次执行这些初始化语句。

展开全文 >>

深入理解Java泛型

2017-05-24

一. 泛型概念的提出

public class GenericTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("qqyumidi");
        list.add("corn");
        list.add(100);
        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); // 1
            System.out.println("name:" + name);
        }
    }
}

　　定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Integer类型的值。这是完全允许的，因为此时list默认的类型为Object类型。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现。

在如上的编码过程中，我们发现主要存在两个问题：

当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。
因此，//1处取出集合元素时需要人为的强制类型转化到具体目标类型，且很容易出现“java.lang.ClassCastException”异常。

那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，运行时就不会出现“java.lang.ClassCastException”异常呢？答案就是使用泛型。

展开全文 >>