create database springtest;
use springtest;

drop table if exists  student;
create table student(
    id int auto_increment primary key,
    username varchar(100) not null comment "用户名",
    telephone varchar(11) comment "电话号码",
    myclassid int comment "所属班级id"

)ENGINE = InnoDB auto_increment=10 charset = utf8;

create table myclass(
    id int auto_increment primary key,
    classname varchar(100) not null,
    headmasterid int

)ENGINE = InnoDB auto_increment=0 charset = utf8;

create table headmaster(
    id int auto_increment primary key,
    mastername varchar(100) not null,
    telephone varchar(11)
)ENGINE= InnoDB auto_increment=0 charset = utf8;

create table course(
    id int auto_increment primary key,
    coursename varchar(100) not null

)ENGINE = InnoDB auto_increment=0 charset = utf8;

create table courseStudent(
    courseStudentid int,
    studentid int
)ENGINE =  InnoDB auto_increment=0 charset = utf8;

设计模式

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

更加全面的介绍！！！

Object.java(jdk1.7)

package java.lang;

/**
 * Class {@code Object} is the root of the class hierarchy.
 * Every class has {@code Object} as a superclass. All objects,
 * including arrays, implement the methods of this class.
 *
 * @author  unascribed
 * @see     java.lang.Class
 * @since   JDK1.0
 */
public class Object {

    //native修饰，本地方法，作用是注册该类中的本地方法
    private static native void registerNatives();
    static {
        registerNatives();
    }

    /**
     * 本地方法，返回一个对象的运行时类
     */
    public final native Class<?> getClass();

    /**
     *这也是一个本地方法，返回值是对象的一个哈希值。 
     *在编写实现hashCode()方法时，我们需要遵守一些约定：
     * 在应用程序执行期间，如果一个对象用于equals()方法的属性没有被修改的话，那么要保证对该对象多次返回的hashcode值要相等。
    * 如果2个对象通过equals()方法判断的结果为true，那么要保证二者的hashcode值相等。
    * 如果2个对象通过equals()方法判断的结果为false，那么对二者hashcode值是否相等并没有明确要求。如果不相**等，那么能够提升散列表的性能。
     */
    public native int hashCode();

    /**
     * 对象比较，注意String.java中的重写
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }

    /**
     * 对象克隆（浅拷贝），子类需要深克隆，需要实现克隆接口，重写此方法（改为public）
     */
    protected native Object clone() throws CloneNotSupportedException;

    /**
    * tostring方法，经常需要重写
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    /**
     *唤醒一个在当前对象监视器上等待的线程
     */
    public final native void notify();

    /**
     *唤醒所有在当前对象监视器上等待的线程
     */
    public final native void notifyAll();

    /**
     * wait方法，会释放已经获取的锁
     */
    public final native void wait(long timeout) throws InterruptedException;

    /**
    *
     */
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
        //四舍五入，nanos为
        if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
            timeout++;
        }

        wait(timeout);
    }

    /**
    *
     */
    public final void wait() throws InterruptedException {
        wait(0);
    }

    /**
    *垃圾回收器在认为该对象是垃圾对象的时候会调用该方法。子类可以通过重写该方法来达到资源释放的目的。 
    *在方法调用过程中出现的异常会被忽略且方法调用会被终止。 
    *任何对象的该方法只会被调用一次。
    * 不推荐使用：1.jvm不保证被执行;2.加长gc时间

         */
    protected void finalize() throws Throwable { }
}

一些闲话

作为程序猿，工作中经常用到正则表达式，每次用时也都是网上去搜一些相关的东西，以解决问题为目的，这样做的效率很低。此次，趁有空好好整理一番。
参考文档：正则表达式30分钟入门教程

正则表达式学习

###定义

正则表达式（regular expression）描述了一种字符串匹配的模式，可以用来检查一个串中是否包含某种子串、将匹配的子串做替换、从某个串中取出符合某个条件的子串等

常用元字符

• . 匹配除了换行符以外的任意字符
• \w 匹配字母或者数字或者下划线或者汉字
• \s 匹配任意的空白符
• \d 匹配数字
• \b 匹配单词的开始或者结束
• ^ 匹配字符串的开始
• $ 匹配字符串的结束

如果想单纯的匹配这些元字符（下面的、[]等等也是元字符），需要加*转义符号”\”。例如，kevinlsui\.com匹配的是kevinlsui.com。这里的.不是表示元字符。
“\”单纯作为斜杠去匹配，需要写成”\\“。

重复相关的元字符

• * 重复零次或者多次
• + 重复一次或者多次
• ？ 重复零次或者一次
• {n} 重复n次
• {n,} 重复n次或者更多次（大于等于n次）
• {n,m} 重复n到m次（大于等于n，小于等于m）

字符类中[]的使用

1. 需要匹配某一些字符中的一个，可以使用[]。
   例如：[aeiou]匹配任何一个元音字母，[.?!]匹配这三种符号中的一个（这里做为元字符，可以不加转义，即可匹配符号本身）。
2. 指定字符范围
   例如：[0-9]代表0到9这十个数中的一个，[a-zA-Z]代表大写和小写24个字母中的一个

分枝条件

1.分枝条件使用符号”|”。例如：a|b,a或者b，满足一者即可
2.使用分支注意各个条件的顺序。原因是：匹配分枝条件时，会从左到右测试每一个分枝条件，如果有满足的，则后面的不再匹配。
例如：\d{5}|\d{5}-\d{4}的话，那么就只会匹配5位的邮编(以及9位邮编的前5位)。

分组

我们使用符号“()”，来进行分组。
例如：(\d{1,3}){3},对（）中的子表达式进行整体的3次重复

反义

• \W 大写的W，表示\w的反义，匹配任意不是字母，数字，下划线，汉字的字符
• \S 大写的S，表示\s的反义，匹配任意不是空白符的字符
• \D 大写的D，表示\d的反义，匹配任意不是数字的字符
• \B 大写的B，表示\b的反义，匹配不是单词开头或者结束的位置
• [^a] 匹配除了a以外的任意字符
• [^aeiou] 匹配除了这几个元音字符以外的任意字符

后向引用，零宽断言，负向零宽断言

属于比较高级的应用了，这个用到相对较少。
几种常见的案例：

1. \b(\w+)\b\s+\1\b，当需要使用已经匹配的子表达式（使用()的表达式），后面使用\1来引用
2. 2[0-4]\d(?#200-249)|250-5|[01]?\d\d?(?#0-199)，使用（？#comment）来注释
3. \b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I’m singing while you’re dancing.时，它会匹配sing和danc。零宽断言
4. (?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。零宽断言
5. \b\wq(?!u)\w\b，负向零宽断言

贪婪与懒惰

这个工作中多次遇到。
贪婪模式：尽可能多的匹配字符。【默认是贪婪模式】
例如：a.*b,对于字符串aababa,结果是aabab
懒惰模式：尽可能少的匹配字符，在重复符号后面加”?”
例如：a.*?b,对于字符串aababa,结果是aab,ab

懒惰限定符

• *？ 重复任意次，但是尽可能少重复
• +？ 重复一次或者多次，但是尽可能少重复
• ？？ 重复零次或者一次，但是尽可能少重复
• {n,m}? 重复n到m次，但是尽可能少重复
• {n,}? 重复n次及以上，但是尽可能少重复

平衡组/递归匹配

高级用法。

java中正则的使用

java的正则表达式相关，均在java.util.regex 包中，主要包括以下三个类：

• Pattern 类：
  pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
• Matcher 类：
  Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
• PatternSyntaxException：
  PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

使用示例：

//字符串包含验证
 Pattern pattern = Pattern.compile("^Java.*");
 Matcher matcher = pattern.matcher("Java不是人");
 boolean b= matcher.matches();//当条件满足时，将返回true，否则返回false
 System.out.println(b);

//字符串分割
Pattern pattern = Pattern.compile("[, |]+");
String[] strs = pattern.split("Java Hello World Java,Hello,,World|Sun");
for (int i=0;i<strs.length;i++) {
    System.out.println(strs[i]);
}

//文本替换（替换首个，或者替换全部）
Pattern pattern = Pattern.compile("正则表达式");
Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");
//替换第一个符合正则的数据
System.out.println(matcher.replaceFirst("Java"));
////替换全部符合正则的数据
System.out.println(matcher.replaceAll("Java"));

//提取子串
Pattern pattern = Pattern.compile("href=/"(.+?)/"");
Matcher matcher = pattern.matcher("<a href=/"index.html/">主页</a>");
if(matcher.find())
     System.out.println(matcher.group(1));
}

js中正则的使用