Java学习二十一

今天的内容为数据库表的约束和实例练习。

一、约束

　　概念：顾名思义，约束便是对表中的数据进行限定，以此来保证数据的正确性、有效性和完整性。我们平常百度到的信息均进行了约束。

　　约束分为四大类：1、非空约束(not null)；2、唯一约束(unique)；3、主键约束(primary key)；4、外键约束(foreign key)。

　　1、非空约束：数据不能为空

　　　　（1）创建表时添加非空约束：create table stu(id int,name varchar(20) not null);

　　　　（2）创建完表后添加非空约束：alter table stu modify name varchar(20) not null; 相当于一个修改

　　　　（3）解除非空约束：alter table stu modify name varchar(20);

　　2、唯一约束：限制数据的唯一性

　　　　（1）语法：create table stu(id int,phone varchar(20) unique);

　　　　（2）创建完表后添加唯一约束：alter table stu modify phone;

　　　　（3）解除唯一约束：alter table stu drop index phone;

　　　　注：唯一约束可以存在null,但只能有一条。

　　3、主键约束：非空且唯一，相当于非空和唯一的合并，一张表只能有一个字段为主键；主键是表中记录的唯一标识。

　　　　（1）添加主键约束：create table stu(id int primary key,name varchar(20));

　　　　（2）创建表后添加主键：alter table stu modify id int primary key;

　　　　（3）解除主键：alter table stu drop primary key;

　　　　（4）自动增长：如果某一列是数值类型，使用auto_increment来完成自动增长

　　　　　　①创建自动增长：create table stu(id int primary key auto_increment,name varchar(20));

　　　　　　②创建表之后添加自动增长：alter table stu modify id int auto_increment;

　　4、外键约束：多张表操作，表与表之间产生联系，保证数据的正确性。

　　　　（1）创建表时添加外键：create table 表名(...外键列 constraint 外键名 foreign key(外键列名) references 主表名（主表列名）);

　　　　（2）创建表后添加外键：alter table 表名 add constraint 外键名 foreign key （外键字段名）references 主表名（主表列名）;

　　　　（3）删除外键：alter table 表名 drop foreign key 外键名：

　　　　（4）级联操作

　　　　　　①添加级联操作：alter table 表名 add constraint 外键名 foreign key （外键字段名）references主表名（主表列名）on update cascade on delete cascade;

　　　　　　②分类：1）更新：on update cascade;

　　　　　　　　　　2）删除：on delete cascade;

二、实例练习，代码中有所用方法的注释

1、

package Java时间处理;

import java.text.SimpleDateFormat;
import java.util.Date;


/*
格式化时间（SimpleDateFormat）
使用 SimpleDateFormat 类的 format(date) 方法来格式化时间
会返回系统时间
 */
public class _1timeFormat {
    public static void main(String[] args) {
        Date d=new Date();
        String str="yyyy-MM-dd HH:mm:ss";//年月日，时分秒
        SimpleDateFormat s=new SimpleDateFormat(str);//设置格式
        System.out.println(s.format(d));
    }
}

2、

package Java时间处理;

import java.text.SimpleDateFormat;
import java.util.Date;

/*
获取当前时间
使用 Date 类及 SimpleDateFormat 类的 format(date) 方法来输出当前时间
 */
public class _2time {
    public static void main(String[] args) {
        SimpleDateFormat s=new SimpleDateFormat();//格式化时间
        s.applyPattern("yyyy-MM-dd HH:mm:ss");//a 为am/pm标记
        Date data=new Date();//获取当前时间
        System.out.println("当前时间"+s.format(data));
    }
}

3、

package Java时间处理;

import java.util.Calendar;

/*
获取年份、月份等
使用 Calendar 类来输出年份、月份等
 */
public class _3getCalendar {
    public static void main(String[] args) {
        Calendar cal=Calendar.getInstance();
        int day = cal.get(Calendar.DATE);
        int month = cal.get(Calendar.MONTH) + 1;
        int year = cal.get(Calendar.YEAR);
        int dow = cal.get(Calendar.DAY_OF_WEEK);//一周的第几天
        int dom = cal.get(Calendar.DAY_OF_MONTH);//一月的第几天
        int doy = cal.get(Calendar.DAY_OF_YEAR);//一年的第几天

        System.out.println("当期时间: " + cal.getTime());
        System.out.println("日期: " + day);
        System.out.println("月份: " + month);
        System.out.println("年份: " + year);
        System.out.println("一周的第几天: " + dow);  // 星期日为一周的第一天输出为 1，星期一输出为 2，以此类推
        System.out.println("一月中的第几天: " + dom);
        System.out.println("一年的第几天: " + doy);
    }
    /*
    Calendar.getInstance()不仅能获取当前的时间，还能指定需要获取的时间点
     */
}

4、

package Java时间处理;

import java.awt.dnd.DropTarget;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
时间戳转换成时间
使用 SimpleDateFormat 类的 format() 方法将时间戳转换成时间
 */
public class _4timechange {
    public static void main(String[] args) {
        long timeStamp=System.currentTimeMillis();//获取当前时间戳
        SimpleDateFormat s=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String sd=s.format(new Date(Long.parseLong(String.valueOf(timeStamp))));
        System.out.println("格式化结果："+sd);

        SimpleDateFormat s2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String sd2=s2.format(new Date(Long.parseLong(String.valueOf(timeStamp))));
        System.out.println("格式化结果："+sd2);
    }
}
/*
（1）String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串
（2）String.valueOf(char c) : 将 char 变量 c 转换成字符串
（3）String.valueOf(char[] data) : 将 char 数组 data 转换成字符串
（4）String.valueOf(char[] data, int offset, int count) : 将 char 数组 data 中 由 data[offset] 开始取 count 个元素 转换成字符串

（5）String.valueOf(double d) : 将 double 变量 d 转换成字符串
（6）String.valueOf(float f) : 将 float 变量 f 转换成字符串
（7）String.valueOf(int i) : 将 int 变量 i 转换成字符串
（8）String.valueOf(long l) : 将 long 变量 l 转换成字符串
（9）String.valueOf(Object obj) : 将 obj 对象转换成 字符串, 等于 obj.toString()

    parseLong()是将字符串转化为数字的方法

    yyyy：年
MM：月
dd：日
hh：1~12小时制(1-12)
HH：24小时制(0-23)
mm：分
ss：秒
S：毫秒
E：星期几
D：一年中的第几天
F：一月中的第几个星期(会把这个月总共过的天数除以7)
w：一年中的第几个星期
W：一月中的第几星期(会根据实际情况来算)
a：上下午标识
k：和HH差不多，表示一天24小时制(1-24)
K：和hh差不多，表示一天12小时制(0-11)
z：表示时区
 */

5、

package Java方法;
/*
方法重载
如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。 具体说明如下：

方法名相同
方法的参数类型，参数个不一样
方法的返回类型可以不相同
方法的修饰符可以不相同
main 方法也可以被重载
 */
public class _1methodOverloading {
    public static void main(String[] args) {
        myclass t=new myclass();
        t.info();
        t.info("重载方法");
        //重载构造函数
        new myclass();
    }
}

class myclass{//myclass类
    int height;
    myclass(){
        System.out.println("无参构造函数");
        height=4;
    }
    myclass(int i){
        System.out.println("带参构造函数");
        height=i;
        System.out.println("房子高度："+i+"米");
    }

    void info(){
        System.out.println("房子高度："+height+"米");

    }
    void info(String s){
        System.out.println(s+":房子高度"+height+"米");
    }
}

6、

package Java方法;
/*
输出数组元素
通过重载 MainClass 类的 printArray 方法输出不同类型(整型, 双精度及字符型)的数组
 */
public class _2arrayoutput {
    public static void main(String[] args) {
        Integer[] i={1,2,3,4,5,6};
        Double[] d={1.1,2.2,3.2,4.5,5.6,7.8};
        Character[] c={'h','c','u','e','o'};
        System.out.println("输出整型数组");
        printArray(i);
        System.out.println("输出双精度数组");
        printArray(d);
        System.out.println("输出字符型数组");
        printArray(c);
    }

    public static void printArray(Integer[] input){//包装类
        for(Integer element:input){
            System.out.printf("%s",element);
            System.out.println();
        }
    }


    public static void printArray(Double[] inputArray){
        for(Double element:inputArray){
            System.out.printf("%s",element);
            System.out.println();
        }
    }
    public static void printArray(Character[] input){
        for(Character element:input){
            System.out.printf("%s",element);
            System.out.println();
        }
    }
}

7、

package Java方法;
/*
汉诺塔算法
1.有三根杆子A,B,C。A杆上有若干碟子
2.每次移动一块碟子,小的只能叠在大的上面
3.把所有碟子从A杆全部移到C杆上
 */
public class _3HNT {
    public static void main(String[] args) {
        int nDisks = 3;
        doTowers(nDisks, 'A', 'B', 'C');
    }

    public static void doTowers(int topN,char from,char inter,char to){
        if(topN==1){
            System.out.println("Disk 1 from"+from+"to"+to);
        }else{
            doTowers(topN-1,from,to,inter);
            System.out.println("Disk "
                    + topN + " from " + from + " to " + to);
            doTowers(topN - 1, inter, from, to);
        }
    }
}

8、

package Java方法;
/*
斐波那契数列
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368……

特别指出：第0项是0，第1项是第一个1。

这个数列从第三项开始，每一项都等于前两项之和
 */
public class _4mainclass {
    public static void main(String[] args) {
        for(int count=0;count<10;count++){
            System.out.println("斐波那契数列第"+(count+1)+"位是："+fibonacci(count));
        }
    }

    public static long fibonacci(long number){
        if(number==0||number==1){
            return number;
        }else{
            return fibonacci(number-1)+fibonacci(number-2);
        }
    }
}

9、

package Java方法;
/*
阶乘
一个正整数的阶乘（英语：factorial）是所有小于及等于该数的正整数的积，并且有0的阶乘为1。自然数n的阶乘写作n!。

亦即n!=1×2×3×...×n。阶乘亦可以递归方式定义：0!=1，n!=(n-1)!×n
 */
public class _5Factorial {
    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            System.out.println(i+"!="+factorial(i));
        }
    }

    public static long factorial(long num){
        if(num<=1){
            return 1;
        }else{
            return factorial(num-1)*num;
        }
    }
}

10、

package Java方法;
/*
方法覆盖
方法重载(Overloading)：如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。
方法覆盖（Overriding）：如果在子类中定义一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。
 */
public class _6Cover {
    public static void main(String[] args) {
        Figure f=new Figure(10,10);
        Rectangle r=new Rectangle(10,10);
        Figure f1;
        f1=f;
        System.out.println(f1.area());
        f1=f;
        System.out.println(f1.area());
    }

    //定义父类
    static class Figure{
        double d1;
        double d2;
        Figure(double a,double b){
            d1=a;
            d2=b;
        }
        Double area(){
            System.out.println("Inside area for figure.");
            return d1*d2;
        }
    }

    //定义子类
    static class Rectangle extends Figure{
        Rectangle(double a,double b){
            super(a,b);
        }
        Double area(){
            System.out.println("Inside area for rectangle.");
            return d1*d2;
        }
    }
}

11、

package Java方法;

import java.util.ArrayList;
import java.util.Vector;

/*
instanceof 关键字用法
instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。

instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
 */
public class _7Instanceof {
    public static void main(String[] args) {
        Object testObject = new ArrayList();
        displayObjectClass(testObject);
    }

    public static void displayObjectClass(Object o) {
        if (o instanceof Vector)
            System.out.println("对象是 java.util.Vector 类的实例");
        else if (o instanceof ArrayList)
            System.out.println("对象是 java.util.ArrayList 类的实例");
        else
            System.out.println("对象是 " + o.getClass() + " 类的实例");
    }
}

12、

package Java方法;
/*
break 关键字用法
Java break 语句可以直接强行退出当前的循环，忽略循环体中任何其他语句和循环条件测试。
 */
public class _8Break {
    public static void main(String[] args) {
        int[] intary = { 99,12,22,34,45,67,5678,8990 };
        int no = 5678;
        int i = 0;
        boolean flag=false;
        for(;i<intary.length;i++){
            if(intary[i]==no){
                flag=true;
                break;
            }
        }
        if(flag){
            System.out.println(no+"索引位置在"+i+"处");
        }else{
            System.out.println("元素不在数组中");
        }
    }
}

13、

package Java方法;
/*
continue 关键字用法
Java continue 语句语句用来结束当前循环，并进入下一次循环，即仅仅这一次循环结束了，不是所有循环结束了，后边的循环依旧进行
 */
public class _9continue {
    public static void main(String[] args) {
        StringBuffer s=new StringBuffer("hello,how are you?");
        int length=s.length();
        int count=0;
        for(int i=0;i<length;i++){
            if(s.charAt(i)!='h')
                continue;
            count++;
            s.setCharAt(i,'h');
        }
        System.out.println("发现 " + count
                + " 个 h 字符");
        System.out.println(s);
    }
}