Java核心技术精讲-优快云博客

1.面向对象的特征

继承：层次模型，类的重用

抽象：为了更好代码的重用，部分用来继承重用，部分让子类实现

封装：过程和数据封装，安全

多态：更好的扩展：接口继承，通过接口传参，重载，重写。

2.String长度不可变（ String底层代码final修饰，方法用new的方式重新创建）

StringBuffer内容可以进行修改

StringBuilder等价StringBuffer,但是StringBuilder类支持线程安全，效率低一些。

注：特殊情况：

String str="string1"+"string2";

StringBuffer sb=new StringBuffer();

sb.append("string1").append("string2");

str编译期间生成 str="string1string2"

3.overloaded?

4.JVM加载class文件的原理：ClassLoader

5.静态变量与实例变量：

静态变量：全类所有

实例变量：对象实例所有

6.Gc垃圾回收：垃圾手机方法：System.gc()或Runtime.getRuntime().gc().

原理：引用作用域，垃圾回收器在一个单独的低级的线程运行，在不可预知的情况下进行清除,清除时调用finalize()。

回收机制：分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

程序员手动System.gc(),通知gc运行，但是不保证一定会执行。

7.接口可以继承接口。

抽象类可以实现接口，抽象类可继承

实体类，但前提是实体类必须有明确的构造函数。

8.Java和C++相比，Java不允许多继承

9.常用的类：Integer,String,Thread,BufferedWriter ,

常用的包：lang,awt,io,sql,util

常用的接口：List,Map,Runnable

10.final表示该类不能被继承，是顶级类

11.UML是标准建模语言

常用图：用例图，静态图（类图，对象图和包图），交互图，实现图

12.单例模式：

直接对象成员直接new

静态方法内部直接new

13.xml

作用：信息存储（在某种程度上介于文档与数据库之间）

形式：dtd,schema

本质区别：scheme本身是xml,可以被xml解析器解析

解析方式：DOM,SAX,STAX

14.分页

mysql limit （起始与数量）

oracle between start and end

15.Servlet中service方法可以服务于多个请求，而CGI每个请求都会产生新的进程，效率低下。

16.数据库连接池：

j2EE服务器启动时会建立一定量的池连接，并维持不少于此数目的池连接。客户端程序需要连接时，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。

17.集合框架

18.ArrayList和Vector的区别

同步性：ArrayList不是线程是线程安全的 Vector是线程安全的

数据增长：Vector增长原来的一倍，ArrayList是原来一半

19.HashMap和Hashtable的区别

历史原因：Hashtable是基于陈旧的dictionary类的，HashMap基于Map接口实现的

同步性:Hashtable是线程安全的，HashMap是线程不安全的

值：只有HashMap可以将null作为条目的key或value

20.Collection和Collections区别

Collection是集合类的上级接口

Collections是针对集合类的一个帮助类，它提供了一系列静态方法实现对各种集合的搜索，排序，线程安全化等操作。

21.实现同步的方法

synchronized,wait与notify

22.序列化：将对象转变为字节流，反序列化就是重建对象的过程。

不使用序列化在网络传输中次序可能打乱

23.Class.fromName()作用

1.装载一个类并且对其进行实例化的操作

2.装载过程中使用到的类加载器是当前类。

24.创建对象的方式

new 反射反序列化 Clone

25.mysql优化

1.mysql所在服务器内核优化----运维

2.my.cnf参数优化

3.sql语句优化

(1) 当只要一行的这时候时候limit 1；

(2)为搜索字段建立索引；

(3)在join表的时候使用相当类型的列

(4)千万不要Order by rand()

(5)避免select*

(6)永远为每张表设置一个ID

(7)使用enum而不是varchar

(8)尽可能的使用not null

(9)固定长度的表会更长

26.线程池(Executors创建线程池类)

由来：在传统的应用程序在执行时，对于每一个任务都需要创建新的的线程。

在这种情况下，（1）线程的创建和销毁的开销很大；（2)jvm管理太多的线程，必须要进行切换

优点：通过避免创建更多的线程，重复利用已有的线程，解决线程生命周期开销问题 ，为资源不足问题提供了解决方案
风险： (1)死锁：任何多线程应用程序都有死锁的风险;

(2) 并发错误：线程池和其他排队机制依靠使用wait()和notify()方法。使用时如果编码不正确，那么很可能丢失通知，导致线程保持空闲状态，尽管队列有有工作要处理。最好使用现有的util.concurrent包。

(3) 线程泄露：线程没有返回

(4) 请求过载：过多的请求导致队列得不到及时处理，从而消耗太多的系统资源缺乏。处理办法：拒绝请求

常用的几种线程池

（1）newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

这种类型的线程池特点是：

工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。

如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。

在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   try {
    Thread.sleep(index * 1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   cachedThreadPool.execute(new Runnable() {
    public void run() {
     System.out.println(index);
    }
   });
  }
 }
}

(2) newFixedThreadPool

创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。 FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
  for (int i = 0; i < 10; i++) {
   final int index = i;
   fixedThreadPool.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

(3)newSingleThreadExecutor

创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

(4)newScheduleThreadPool

创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

延迟3秒执行，延迟执行示例代码如下：

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}

表示延迟1秒后每3秒执行一次，定期执行示例代码如下：

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}