（一）授权
1.创建用户”S学号u1”，S学号u2，S学号u3，S学号U4,并为其赋予connect角色。
其中，学号是指你的学号，比如你的学号为20130001，则你创建的用户应该是S20130001u1，S20130001u2，S20130001u3,S20130001u4
2.假设你的用户名是S20130001（做实验时请根据你的账号修改），把你在数据库中创建的Student表的查询权限授给用户”S学号u1”， ”S学号u1”执行相应的查询。
（1）查询S20130001用户的Student表中全体学生的详细记录。
（2）查询S20130001用户Student表中所有姓刘的学生的姓名、学号和性别。
（3）查询S20130001用户Student表中名字中第二字为“阳”字的学生的姓名和学号。
3.把S20130001用户的Student表和Course表的全部权限授予用户”S学号u2”， ”S学号u3”；然后让”S学号u2”用户修改S20130001的数据。
4.把S20130001用户的表Student的修改学生学号的权限赋予用户” S学号U4”，然后让S20130001用户修改S20130001的student表的SNO数据。
5.把S20130001用户的SC表的插入权限授予“S学号U5”用户，然后让“S学号U5”用户向SC表插入一条记录。
6.把对表SC的查询权限授予所有用户。
（1）让“S学号u2”用户查询S20130001用户的SC表中选修了3号课程的学生的学号及其成绩，查询结果按分数的降序排列
（2）让“S学号u2”用户查询S20130001用户的SC表中各个课程号与相应的选课人数。
（首先应该以新创建的用户的身份重新登陆数据库，然后再进行授权）
（二）回收权限
1.收回用户”S学号u2”修改学生学号的权限
2.收回所有用户对表sc的查询权限
3.收回用户”S学号U5”sc表的insert权限
4.在回收权限之后验证用户是否真正丧失了该权限（查询表，插入记录）
（三）角色
1.创建一个角色
2.给角色授予权限
3.将角色授予某一用户
4.检查用户是否具有相应的权限
（四）完整性
1．建立教师表Teacher，要求教师名称Tname列取值唯一，教师编号TNO列为主码。
2．建立学生登记表Student，要求学号在9000至9999之间，年龄<29,性别只能是’男’或’女’，姓名非空。
3．修改表Student的结构，由年龄小于29改为小于40。
4．建立课程表COURSE，要求课程表中的每门课程的学分不得超过7分，且主讲教师字段TNO参照Teacher表TNO字段，且当删除教师表中一行记录时，如果它被参照，则将Course表中相应记录中TNO的值设置为空。5．建立表SC，要求SNO参照STUDENT表的学号，且当删除Student表中的一个学生记录时，级联删除学生的选课记录。对上述新建立和修改定义的表，每个表输入3条数据，其中1条数据符合完整性约束，2条违反约束条件的，验证和体会Oracle的实体完整性和参照完整性。

1.创建用户“S学号u1”，“S学号u2”，“S学号u3”，“S学号u4”，并为其赋予connect角色。
其中，学号是指你的学号，比如你的学号为2019214349，则你创建的用户应该是S2019214349u1，S2019214349u2，S2019214349u3，S2019214349u4。

create user S2019214349u1 identified by abc; # identified by 设置密码
grant connect to S2019214349u1;
create user S2019214349u2 identified by abc;
grant connect to S2019214349u2;
create user S2019214349u3 identified by abc;
grant connect to S2019214349u3;
create user S2019214349u4 identified by abc;
grant connect to S2019214349u4;
create user S2019214349u5 identified by abc;
grant connect to S2019214349u5;

SQL语言集数据定义、数据操纵、数据查询、数据控制功能于一体。
数据定义：create，drop，alter
数据操纵：增(insert into … )，删(delete from …)，改(update … set …)
数据查询：select
数据控制：grant(授予权限)，revoke(收回权限)

1.建立基本表
创建教材中的学生表（Student）、学生选课表（SC）、课程表（Course）
（1）学生表：Student (Sno，Sname，Sage，Ssex，Sdept），其中学号Sno为主码。

create table Student
(
    Sno number primary key,
    Sname varchar2(10),
    Sage int,
    Ssex char(2),
    Sdept varchar2(10)
);
（2）课程表：Course (Cno, Cname, Cpno, Ccredit)其中课程号Cno主码；先行课为外码参照Course表中Cno字段。

create table Course
(
    Cno number primary key,
    Cname varchar2(10),
    Cpno varchar2(10) references Course(Cno),
    Ccredit int
);
（3）学生选课表：SC(Sno, Cno, Grade)其中学号Sno、课程号Cno为主码；Sno为外码参照Student表中Sno字段；Cno为外码参照Course表中Cno字段。

create table SC
(
    Sno number references Student(Sno),
    Cno number references Course(Cno),
    Grade int,
    primary key (Sno,Cno)
);
2.修改基本表
（1）在Student表中加入属性BloodType【char(2)型】。

alter table Student add BloodType char(2);
（2）修改表Student中的Sdept属性的数据类型为varchar2(40)，注意和定义表的时候类型不同。

alter table Student modify Sdept varchar2(40);
（3）给表Student的sage列添加一个自定义约束，sage必须大于15且小于30。

alter table Student add constraint age_ck check(Sage>15 and Sage<30);
（4）删除（3）中新添加的约束。

alter table Student drop constraint age_ck;
（5）SC表中的sno增加外键约束f_sno，参照Student表中的sno字段。

alter table sc add constraint f_sno foreign key (sno) references student(sno);
（6）删除表Student中的字段BloodType。

alter table Student drop (BloodType);   #记得加括号，不加括号就要在drop前面写column
3.删除基本表
（1）删除基本表Student。

drop table Student;
（2）删除基本表SC。

drop table SC;
4.索引操作
（1）在SC表上建立关于Sno升序、Cno降序的唯一索引i_sc+学号后四位。

create unique index i_sc on SC(Sno asc,Cno desc,substr(Sno,-4));
（2）删除Course表上的索引i_sc。

drop index i_sc;

/**
 * 基于指定文件名称创建目录及文件
 * 如果文件已经存在，则忽略
 *
 * @param fileName
 * @throws IOException 
 */
private static void createFile(String fileName) throws IOException {
   
   
   
	Path dir = Paths.get(fileName);
	Files.createDirectories(dir.getParent());// 创建目录，存在目录也不会抛出异常
	try{
   
   
   
		Files.createFile(dir);// 创建文件，若文件已经存在则会抛出异常
		System.out.println("创建文件成功！文件位置：" + fileName);
	}
	catch(FileAlreadyExistsException e) {
   
   
   
		System.out.println("文件 " + fileName + " 已存在，无需创建！");
	}
	System.out.println();
}

/**
 * 提示：文件以字节操作，因此可以
 * 字符串，转字节数组，直接基于Files写入文件
 * 
 * @param fileName
 * @param content
 * @throws IOException 
 */
static void write(String target, String content) {
   
   
   
	byte[] buffer = content.getBytes();
	Path p = Paths.get(target);
	try {
   
   
   
		Files.write(p, buffer); // 默认是覆盖内容
		//Files.write(p, buffer, StandardOpenOption.APPEND); // 添加内容
		System.out.println("数据写入成功！文件位置：" + target);
	} catch (IOException e) {
   
   
   
		e.printStackTrace();
	}
}

class Race implements Runnable {
   
   
   
	final int total = 100; // 赛道长度
	volatile boolean isOver = false; // 比赛结束标志
	volatile int disRabbit = 0; // 兔子已走距离
	volatile int disTortoise = 0; // 乌龟已走距离
	@Override
	public void run() {
   
   
   
		for(int time = 1; isOver != true; time++) {
   
   
   
			if(Thread.currentThread().getName().equals("兔子")) {
   
   
   
				disRabbit = time * 10;
				if(disRabbit >= total) {
   
   
   
					isOver = true;
					System.out.println("兔子获胜！");
					break;
				}
				System.out.println("兔子距终点" + (total - disRabbit) + "米");
				if(disRabbit > disTortoise) {
   
   
   
					try {
   
   
   
						System.out.println("我跑得快，睡一觉\n");
						Thread.sleep((long) (Math.random()*2)); 
						// get a random number [0,1]
					} catch (InterruptedException e) {
   
   
   
						e.printStackTrace();
					}
				}
			}
			else {
   
   
   
				disTortoise = time;
				if(disTortoise >= total) {
   
   
   
					isOver = true;
					System.out.println("乌龟获胜！");
					break;
				}
				System.out.println("乌龟距终点" + (total - disTortoise) + "米");
			}
			synchronized (this) {
   
   
   
				if(!isOver) {
   
   
   
					if(disRabbit > disTortoise) {
   
   
   
						System.out.println("兔子领先");
					}
					else {
   
   
   
						System.out.println("乌龟领先");
					}
					System.out.println();
				}
			}
		}
	}	
}
public class Main {
   
   
   
	public static void main(String[] args) {
   
   
   
		Race r = new Race();
		Thread t1 = new Thread(r, "兔子");
		Thread t2 = new Thread(r, "乌龟");
		t1.start();
		t2.start();
	}
}

package shiyan6;
//@@author lubolin
import java.util.*;

public class i8619 {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		
		try {
			int m = Integer.parseInt(scan.next());
			System.out.println(10 - m);
		} catch (NumberFormatException e) {
			System.out.println("not int");
		} finally {
			System.out.println("end");
		}
		scan.close();
	}
}

import java.util.Scanner;
class DangerException extends Exception {
    //starts
    public void showError() {
		System.out.println("超重");
	}
	//end
} 
class CargoBoat {
   
   
   
    int realContent;  //装载的重量
    int maxContent;   //最大装载量
    public void setMaxContent(int c) {
    	maxContent = c;
    }
    public void loading(int m) throws DangerException {
   
  	//starts
    	realContent+=m;
    	if(realContent>maxContent)throw new DangerException();
    	System.out.printf("目前装载了%d吨货物\n",realContent);
	//end
    }
}
public class Main {
	public static void main(String args[]) {
		CargoBoat ship = new CargoBoat();
		Scanner s=new Scanner(System.in);
		ship.setMaxContent(1000);
		int m=0;
		try{
			//starts
			while(true) {
				m=s.nextInt();
				ship.loading(m);
			}
			//end
		}
		catch(DangerException e) {
			//starts
			e.showError();
			System.out.printf("无法再装载重量是%d吨的集装箱\n",m);
			//end
		}
		finally {
			System.out.printf("货船将正点启航");
		}
	}
}
 

package com.experiment05;
import com.experiment05.entity.College;
import com.experiment05.entity.Student;
import com.experiment05.entity.Teacher;
import com.experiment05.resource.DatabaseUtils;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        System.out.println(getCollegeName(DatabaseUtils.getStudents(),8888));
        
        System.out.print("\n");
        
        printCollegeName(DatabaseUtils.getStudents(), 201001, 1001);
    	
    	
    }

/**

 * author lubolin
 */
private static String getCollegeName(List<Student> students, int sNumber) {

	
	return  students.stream()
            .filter(a -> a.getNum() == sNumber)
            .collect(Collectors.toList())
            .stream()
            .findFirst()
            .map(Student::getT)
            .map(Teacher::getC)
            .map(College::getName)
            .orElse("************");
	 
}

/**

 * 
 *  * author lubolin
 */
private static void printCollegeName(List<Student> students, int sNumber, int tNumber) {
	System.out.println(students.stream()
            .filter(a -> a.getNum() == sNumber)
            .collect(Collectors.toList())
            .stream()
            .findFirst()
            .map(Student::getT)
            .filter(a -> a.getI() == tNumber)
            .map(Teacher::getC)
            .map(College::getName)
            .orElse("*************"));
   }
}

#include <stdio.h>
#include <stdlib.h>
struct stu{
    unsigned int num;
    char name[25];
    double classa;
    double classb;
    double classc;
    double aver;
    double sum;
    struct stu *next;
};
int main()
{
    int n,i;
    struct stu *head,*q,*p;
    while(scanf("%d",&n)!=-1)
    {
        for(i=0;i<n;i++)
        {
            p=(struct stu *)malloc(sizeof(struct stu));
            scanf("%u %s %lf %lf %lf",&p->num,
p->name,&p->classa,&p->classb,&p->classc);
            p->sum=(p->classa+p->classb+p->classc);
            p->aver=(p->sum)/3.0;
            if(i==0)
                head=q=p;
            else
                q->next=p;
            q=p;
            p->next=NULL;
        }
        p=head;
        while(p)
        {
            printf("%u  %s  %.2lf  %.2lf  %.2lf  %.2lf  %.2lf\n",p->num,p->name,
p->classa,p->classb,p->classc,p->aver,p->sum);
            p=p->next;
        }
    }
}