1.汉字编码表地址以及各种编码的区域

1.汉字编码
2.各种编码范围
outer（标签）：就相当于表示它现在代表的某个循环。如果想跳出它所代表的循环，那么就break outer;如果想结束它所代表的此次循环，那么就continue outer;

2.String的两种实例化方式

方式一：直接赋值（创建的对象存放在字符串对象池里，假如存在就不会再创建）
方式二：new对象（每一次都创建一个新的对象）
字符串内容具有不可变性：不能改变字符串的内容，只能通过指向一个新的内存地址。

3.内部类与外部类

1）内部类唯一的好处是可以方便地使用外部类的属性。缺点是破坏了类的基本结构（方法+属性）。

2）外部类实例化内部类语法：先外部类实例化对象；外部类名.内部类名 对象名=外部类对象.new 内部类（）

3）为什么在匿名内部类中引用外部对象要加final修饰符

在匿名内部类中引用的外部对象受到外部线程的作用域的制约有其特定的生命周期，以线程为例，当外部的变量生命周期已经完结之后，内部的线程还在运行，怎么样解决这个外部生命周期已经结束而在内部却需要继续使用呢，这个时候就需要在外部变量中添加final修饰符，其实内部匿名类使用的这个变量就是外部变量的一个“复制品”，即使外部变量生命周期已经结束，内部的“复制品“依然可用。

4.静态工厂

静态（简单）工厂模式：

优点：隐藏了对象创建的细节，将实例化过程放到了工厂类中实现，起到了解耦的作用。客户端基本不用关心使用的是哪个产品，只需要知道用工厂的哪个方法(或者传入什么参数)就行了。方便添加新的子类，只需要在工厂类的创建方法添加分支，或者增加创建方法就可以了。遵循了依赖倒转原则，即不用自己负责对象的创建。
缺点：适用于产品子类型差不多, 使用的方法名都相同的情况。每添加一个产品子类，都必须在工厂类中添加一个判断分支(或一个方法)，这违背了OCP(开放-封闭原则)。

5.单列模式

单件模式用途：

单件模式属于工厂模式的特例，只是它不需要输入参数并且始终返回同一对象的引用。
单件模式能够保证某一类型对象在系统中的唯一性，即某类在系统中只有一个实例。它的用途十分广泛，打个比方，我们开发了一个简单的留言板，用户的每一次留言都要将留言信息写入到数据库中，最直观的方法是没次写入都建立一个数据库的链接。这是个简单的方法，在不考虑并发的时候这也是个不错的选择。但实际上，一个网站是并发的，并且有可能是存在大量并发操作的。如果我们对每次写入都创建一个数据库连接，那么很容易的系统会出现瓶颈，系统的精力将会很多的放在维护链接上而非直接查询操作上。这显然是不可取的。
如果我们能够保证系统中自始至终只有唯一一个数据库连接对象，显然我们会节省很多内存开销和cpu利用率。这就是单件模式的用途。当然单件模式不仅仅只用于这样的情况。在《设计模式：可复用面向对象软件的基础》一书中对单件模式的适用性有如下描述：
1、当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
2、当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

对单件模式的懒汉式与饿汉式进行简单介绍：

1）饿汉式：在程序启动或单件模式类被加载的时候，单件模式实例就已经被创建。

    public Simple(){                                
        private static Single s=new Single();        
        private Single(){

        }  
        public static Simple getSimple(){
            return s;
        } 
    }  
    /*枚举法：*/enum Single {
        Single;

        private Single() {

        }

        public void print(){
            System.out.println("hello world");
        }
    }
    public class SingleDemo {
        public static void main(String[] args) {
            Single a = Single.Single;
            a.print();
        }
    /*反之如果单件模式在系统中会很少用到或者几乎不会用到，那么懒汉式是一个不错的选择。*/

2)懒汉式

懒汉式:class Single{
    private static Single s = null;

    public Single() {
        if (s == null)
           s = new Single();
           return s;
    }
}

    懒汉模式在使用时，容易引起不同步问题，所以应该创建同步"锁",
    class Single1 {
        private static Single1 s = null;
        public Single1() {
        }
           //同步函数的demo
        public static synchronized Single1 getInstance() {
            if (s == null)
                s = new Single1();
            return s;
        }
        //同步代码快的demo加锁，安全高效
        public static Single1 getInStanceBlock(){
            if(s==null)
                synchronized (Single1.class) {
                    if(s==null)
                        s = new Single1();
                }
            return s；
        }
    }

6.异常

Exception是检查型异常，例如Exception在程序中必须使用try..catch进行处理；RuntimeException是非检查型异常，例如NumberFormatException，可以不使用try..catch进行处理，但是如果产生异常，则异常将由JVM进行处理，RuntimeException最好也用try…catch捕获

7.集合的遍历

1）LinkedList集合实现遍历使用get（）方法，迭代器遍历集合的方法代码实现

    /**
     * 用iterator遍历集合
     */
    Iterator<Student> it=list.iterator();//返回一个迭代器
        while(it.hasNext())
        {
            Student s=it.next();//返回迭代的下一个元素
            System.out.println("姓名: "+s.getName()+"年龄: "+s.getAge());
        }

2）foreach遍历

/**
 * 用foreach遍历集合
 */
    for(Student s:list)
    {
        System.out.println("姓名: "+s.getName()+"年龄: "+s.getAge());
    }

8.线程状态

(1)，创建状态

在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，它已经有了相应的
内存空间和其他资源，但还处于不可运行状态。新建一个线程对象可采用 Thread 类的构造方法来实现，例
如，“Thread thread=new Thread();”。
(2)，就绪状态
新建线程对象后，调用该线程的 start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，
线程将进入线程队列排队，等待 CPU 服务，这表明它已经具备了运行条件。
(3)，运行状态
当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象
的 run()方法。run()方法定义了该线程的操作和功能。
(4)，堵塞状态
一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作时，将让出
CPU 并暂时中止自己的执行，进入堵塞状态。堵塞时，线程不能进入排队队列，只有当引起堵塞的原因被
消除后，线程才可以转入就绪状态。
(5)，死亡状态
线程调用 stop()方法时或 run()方法执行结束后，即处于死亡状态。处于死亡状态的线程不具有继续运
行的能力。
加油！！！