J(notebook).JAVA初级知识总结

一、设计模式

1.单例模式

        饿汉式：对象加载时间过长、线程安全。

        懒汉式：延迟创建对象、线程不安全。

        1.1 饿汉模式

        将构造器私有化，外部无法直接实例化对象，在类中实例化一个对象（static修饰），然后提供个方法返回该对象（static修饰）。

        1.2 懒汉模式

       将构造器私有化，外部无法直接实例化对象，声明当前类对象（无实例化）。提供方法返回当前对象，方法内部进行判断，如果对象为空实例化一个对象，否则直接返回当前声明的对象。

---

二、异常处理

1.try-catch-finally

        使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配。

        一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构中（没写finally的情况）。继续执行其后的代码。

        catch中如果有子父类关系，上下顺序有要求。

        使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。

        真正将异常给解决掉。

try{
    // 可能出现异常的代码
}catch(异常类型 变量名){
    // 处理异常的方式
}finally{
    // 不管什么情况都会执行,不论你前面写的什么东西，即使是return
}

2.throws

        “thows + 异常类型”写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。thows的方式只是将异常抛给了方法的调用者，并没有将异常处理掉。

3.throw

        手动的生成一个异常对象，并抛出。

---

三、多线程

图3-1多线程脉络

1.线程创建

        1.1 继承Thread类方式

public class MyMain{
    public static void main(String[] args) {
        MyThread  th = new MyThread();
        th.start(); // 开启线程
    }
}

class MyThread extends Thread{
    @Override
    public void run(){
        // 重写的代码
    }
}

        1.2 实现Runnable接口

public class MyMain{
    public static void main(String[] args) {
        MyThread  th = new MyThread();
        Thread t1 = new Thread(th);
        t1.start(); // 启动线程
    }
}

class MyThread implements Runnable{
    @Override
    public void run(){
        // 重写的代码
    }
}

        1.3 省略缩减版

public class MyMain{
    public static void main(String[] args) {
        new Thread("哈尔滨"){
            @Override
            public void run() {
                // 代码块
            }
        }.start();
    }
}

        1.4 实现实现Callable接口

public class ThreadNew{
    public static void main(String[] args){
        NumThread numThread = new NumThread();
        FutureTask futureTask = new FutureTask();
        new Thread(futureTask).start();
    }
}

class NumThread implements Callable{
    @Override
    public Object call() throws Exception{
        // 实现的功能代码
    }

}

2.线程同步

        2.1 常用同步监视器(锁)

                (1)新创建的各种类的对象

                     一般可以使用Object类。

Object obj = new Object();

                (2)this

                    表示当前的类。

                (3)静态的类的对象

                    与上述创建Object类似，但用关键字static修饰（好用）。

                (4)当前类.class

                     不论新建多少个当前对象，此锁唯一（好用）。

四、常用类

1.枚举类

        1.1 自定义枚类

        （1）声明对象的属性：private final修饰

private final String seasonName;

        （2）私有类的构造器，并给对象属性赋值

private Season(){

}

        （3）提供当前枚举类的多个对象：public static finall的

public static final SPRING = new Season(/*属性赋值*/)

        1.2 使用enum关键字

        （1）格式

enum Season{
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","寒风凛冽");
    private final String name;
    private final String text;
    private Season(String name, String text){
        this.text = text;
        this.name = name;
    }
    //可以选择是否使用toString()方法
}

        （2）方法

                values()方法：返回枚举类型的对象数组；

                valueOf(String str)方法：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象；

                toString()方法：返回当前枚举类对象常量的名称；

五、注解

1.生成文档的相关注解

@author        //标明作者
@version       //标明该模块的版本
@see           //参考转向，也就是相关主题
@since         //从哪个版本开始增加的
@param         //对方法中某参数的说明
@return        //对方法的返回值进行说明
@exception     //对方法可能抛出的异常进行说明，只有用throws显式抛出可用

2.编译时格式检查

@Override            //限定重写父类方法，该注解只能用于方法
@Deprecated          //表示所修饰的元素（类，方法等）已过时
@SuppressWarnings    //抑制编译警告

六、常用的数据存储结构

 END