java知识点（考试版）

一、 语法基础
 关键字：JAVA 语言定义的，具有特殊含义的单词
 保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词
 标示符： 0-9、a-z、$、_
注： 数字不可以开头 、 不可以使用关键字
数据类型：
 数据：描述客观事物的数字、字符以及所有能输入到计算机中并能被计算机
接受的各种符号集合
 类型：具有相同逻辑意义的一组值的集合
 数据类型：一个类型和定义在这个类型上的操作集合
（1） 基本 （原始、简单） 数据类型：
整数类型：byte、short、int、long 浮点数类型：float、double
字符类型：char 布尔类型：boolean
byte,char,short(这三个平级)-->int-->float-->long-->double
自动类型转换：低级别到高级别
强制类型转换：高级->低级：int i=123,long=456 i=(int)j
（2 2 ） 引用 （复杂） 数据类型: 数组、类（class）、接口（interface）
 变量：其实就是内存中的一个存储空间，用于存储常量数据
 最终变量：只能进行一次赋值 final int value=100;
运算符与表达式：
运算符：
 算术运算符：+ - ++ -- * / %
 赋值运算符：= += -= *= /= %=
 比较运算符：==（等于）、！=（不等于）、>、<、>=、<=
特点：运算完的结果，要么是 true，要么是 false
 位运算符:用于操作二进制位的运算符 ~（非） &（与） |（或）
^（异或）<<（左移位） >>（右移位） >>>(无符号右移位)
 逻辑运算符 & | ^ ! &&（条件与） ||（条件或）
逻辑运算符除了!外都是用于连接两个 boolean 类型表达式。
& & 和 && 区别：
&：无论左边结果是什么，右边都参与运算
&&：短路与，如果左边为 false，那么右边不参数与运算。
| | 和 || 区别：
|：两边都运算
||：短路或，如果左边为 true，那么右边不参与运算
 Instanceof：判断一个对象是否属于指定类或其子类【布尔型】
运算的兼容性原则：
类型兼容：两个不同的数据类型具有某些相同的性质，其数据能够参加相同的运
算，运算结果的数据类型为范围大、精度高的那种数据类型。
赋值相容：一种数据类型的值可以通过赋值操作赋给另一种数据类型的值
语句 ：
结构化程序设计的三种基本流程控制结构： 顺序 、 分支、循环结构
If switch do while while for
 switch( 变量) ){
case 值:要执行的语句;break
…
default:要执行的语句
}
break: 跳出当前所在循环 continue:跳出本次循环
函 数 ：
修饰符 返回值类型 函数名(类型 参数 1，类型 参数 2，…)
{
执行语句;
return 返回值;
}
数 组：
类型[] 变量=new 类型[N][ [={元素组}] ][ [=new 元类型[]{元素组}] ];
 参数传递：基本数据类型：传递值；引用数据类型：传递引用
 递归算法：直间或间接调用自身的算法

第三章、类的继承、封装和多态
 类
访问权限：public 和缺省 public class MyDate[class MyDate_ ex]
 类 类：既包括数据又包括作用于数据的一组操作的封装体
 面向对象程序设计的思想：将现实世界中的实体单位抽象成对象
（object），对象具有属性和行为能力
属性：对象所持有的值或状态
行为：对象在持有值上所进行的操作
 对象之间的关系：包含、继承、和关联
 声明：[修饰符] class 类名[<泛型>][extends 父类] [implements 接
口列表]
 类中成员访问权限：
 对象：
类是一种数据类型，声明一个类就是定义了一种数据类型。类的实例是类的
取值，对象就是类的变量，一个对象能够引用一个类的实例。
 声明： 类名 对象名
 构造实例：对象名=new 类的构造方法（[参数列表]）
 对象.成员变量||对象.成员方法（[参数列表]）
类的封装性 ：
 将数据和对数据的操作包装成一个对象类型，使对象成为包含一组属性和操
作的运行单位
 实现信息隐藏，类既要提供与外部联系的方法，又要尽可能地隐藏类中某些
数据和实现细节，以约束外部的可见性。
 拷贝构造方法：参数是该类对象的构造方法
public MyDate(MyDate d){
year = d.year;
month = d.month;
day = d.day;}
 析构方法：public void finalize()
 This：代表对象，就是所在函数所属对象的引用
this. 成员变量 /this. . 成员方法：调用的是成员属性和方法(一般方法);
this([ [ 参数列表] ]) )：调用本类已定义的构造方法
注：用 this 调用构造函数，必须定义在构造函数的第一行， 不能使用 this
调用当前的构造方法。
 浅拷贝：传递引用，不能复制实例
 static：类名.静态成员变量/方法
 实现对象中的共性数据的对象共享
 随着类的加载而加载，而且优先于对象存在
 静态方法只能访问静态成员，不可以访问非静态成员
 静态方法中不能使用 this ，r super 关键字
成员 （实例） 变量和静态变量的区别：
 成员（实例）变量所属于对象；静态（类）变量所属于类
 成员变量存在于堆内存中；静态变量存在于方法区中
 成员变量随着对象创建而存在，随着对象被回收而消失
静态变量随着类的加载而存在，随着类的消失而消失
 成员变量只能被对象所调用静态变量可以被对象调用，也可以被类名调用
所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据
类的继承 性 ：
（1 1 ） 继承原则：
 子类继承父类所有的成员变量
 子类继承父类除构造方法外的成员方法
 子类不能继承符类的构造方法
 子类可增加成员，可重定义从父类继承的成员，但不能删除它们
（2 2 ）r super 引用 ：
 调用父类的构造方法：super([参数列表])【 默认执行 super()】
public Student(String name, MyDate birthday, String spec)
{
super(name,birthday); //调用父类同参数的构造方法
this.speciality = spec;
}
 引用父类同名成员
子类隐藏父类成员变量:super.成员变量
子类覆盖父类成员方法:super.成员方法([参数列表])
类的多态性：
（1 1 ） 子类重定义父类成员：
 重定义父类的成员变量，则隐藏父类的成员变量
 重定义父类的成员方法：
覆盖：参数列表和返回值相同
重载：参数列表不同
（2 2 ） 类型的多态
 子类对象即是父类对象：
new Student() instanceof Person //true
 父类对象引用子类实例：Person p= new Student();
（3 3 ）编译时多态 ：运行时能确定执行方法中的哪一个【否则为运行时多态】
 equals 方法：比较两个对象是否引用同一个实例
public boolean equals(Object obj)
{
return this == obj;
}
 子类覆盖 t Object 类的 equals （ Object ）方法：
public boolean equals(Object obj)
{ if(this==obj)
return ture;
if(obj instanceof Person)
{Person p=(Person)obj;
return this.name.equals(p.name)&&this.birthday.equals(p.birthday);
}}
类的抽象性：
public abstract class ClosedFigure//闭合图形抽象类
{public abstract double area();//计算面积，抽象方法}
（1 1 ） 抽象类的特点：
 构造方法、静态成员方法不能被声明为抽象方法
 一个非抽象类必须实现从父类继承来的所有抽象方法
 不能创建抽象类的实例。例如:Figureg = new ClosedFigure()（错 错）
（2 2 ） 抽象类与抽象方法的作用：
抽象类属于描述抽象概念，抽象方法提供方法声明与方法实现分离机制。
抽象类声明抽象方法，是为同一个操作约定一种方法声明；子类继承抽象类的抽
象方法，继承了父类约定，子类可以根据自身实际的需要，给出抽象方法的具体
实现，不同的子类可以有不同的方法实现。因此，一个抽象方法在多个子类中表
现出多态性，使子类具有共同的行为能力。
（3 3 ） 最终类：不能被继承
public final class Math extends Object//数学类，最终类
最终方法 ：public final double area()// 不能被子类覆盖
第四章
一、 接口： 多继承
（1 1 ） 声明： [public] interface 接口s [extends 父接口列表] ]
{[public] [static] [final] 数据类型 成员变量=常量值;
[public] [abstract] 返回值类型 成员方法[(参数列表)]; }
注： 接口不能被实例化
（2 2 ）声明实现接口的类：public abstract class ClosedFigure extends Figure
implements Area, Perimeter
实现接口的非抽象类必须实现所有接口中的所有抽象方法，否则声明为抽象类
（3 3 ） 接口是引用数据类型
closedFigure fig = new Ellipse(point,10,20);
Area ar = fig;
ar.area() //运行时多态
 一个类所继承的父类以及所实现的全部接口，称为它的父类型，一个父类对
象那个可以引用子类实例， 一个接口对象可引用实现该接口的类及其子类实
例。
（4 4 ） 接口与抽象类的区别
 抽象类为子类约定方法声明，抽象类可以给出部分实现，包括构造方法等;
抽象方法在多个子类中表现出多态性。类的单继承，使得一个类只能继承一
个父类的约定和实现
 接口为多个互不相关的类约定某一特性的方法声明，在类型层次中表达对象
拥有的属性。接口没有实现部分。接口是多继承的。一个类实现多个接口，
就具有多种特性，也是多继承的。
二、 内部类和内部接口
public class Pixel //像素类，外层类型，外部类
{
public static interface ColorConstant
//颜色常量接口，静态内部接口，类型嵌套
public static class Color extends Object
implements ColorConstant //颜色类，静态内部类
}
类型嵌套:静态内嵌类型
Pixel.Color color = = new Pixel.Color(255,255,255);
对象嵌套:实例内嵌类型
（1）作为类型的特性：
 内嵌类型不能与外层类型同名
 可以声明内部类为抽象类，该抽象类必须被其他内部类继承;内部接
口必须被其他内部类实现
（2）作为成员的特性：
 使用点运算符“.”引用内嵌类型：Pixel.Color
 调用外部类当前实例的成员变量或实例成员方法:
外部类 .this. 成员变量 //引用外部类当前实例的成员变量
外部类 .this. 实例成员方法( ( 参数列表) ) //调用外部类当前实例的成员方法
三、 java .lang 包中的基础类库：
 h Math 数学类
Double：Math.PI[= 3.14159265358979323846];
Double: Math.abs(double a) //求绝对值
Double: Math.random() //返回一个 0.0~1.0 之间的随机数 double:
Math.sqrt(double a) //返回 a 的平方根值
 e Comparable 可比较接口
public interface Comparable<T>
{ int compareTo(T cobj) //比较对象大小，返回-1、0、1}
其中，<T>是 Comparable 接口的参数，表示一个类
r Comparator 比较器接口
public interface Comparator<T>
{public abstract boolean equals(Object obj);//两个对象是否相等
public abstract int compare(T cobj1,T cobj2); //指定比较规则}
例：e MyDate 类对象比较大小
public class MyDate implements Comparable <MyDate>
{public int compareTo(MyDate d) //约定比较日期大小的规则
{if(this.year==d.year && this.month==d.month&&this.day==d.day)；
return 0;
return (this.year>d.year||this.year==d.year&&this.month>d.month
||this.year==d.year &&this.month==d.month&&this.day>d.day)
? 1: -1;
}
}
 Integer
int：Integer.parseInt(String s):将串 s 按十进制转换为整数
int：Integer. parseInt(String s, , int radix):按 按 x radix 进制转换为正整数
string:toString:返回整数值的十进制字符串
String：toBinaryString(int i)：将 i 转换成二进制字符串
String：toOctalString(int i)：将 i 转换成八进制字符串
String：toHexString(int i)：将 i 转换成十六进制字符串
 e Double 类
Double：parseDouble(String s)：将串 s 转换为浮点数
 g String 字符串类
Int：str.length() //返回字符串的长度
Char：str.charAt(int i):返回第 i（i>=0）个字符
String：str. substring(int begin,int end):截取取字符串
String：str.format(…,…):返回指定格式字符串
===========================================================
boolean：equals(Object obj) //比较字符串是否相等
boolean：equalsIgnoreCase(String s)//忽略字母大小写
int：compareTo(String s) //比较字符串的大小， 返回两者差 值
int：compareToIgnoreCase(String s)
int：indexOf(String s) //返回当前串首次与 s 串匹配的序号
 s Class 类
String：getName() //返回当前类名字符串
this.getClass().getName()
this.getClass().getSuperclass().getName()：当前类父类名
this.getClass().getPackage().getName()：当前类所属包名
 Calendar
Int:Calendar.getInstance().get(Calendar.YEAR/MONTH[外+1]/DATE)
Boolean:GregorianCalendar . isleapYear(int year)
四、 泛型：
[ [ 修饰符 ]class 类< < 类型参数列表> >s [extends 父类 ][implements 接口列表] ]
[public] interface 接口< < 类型参数列表> > s [extends 父接口列表] ]
[public] [static] < < 类型参数列表> > 返回值 类型方法 ([ 参数 列表] ] )
[throws 异常类列表] ]
泛型的继承性及通配符
Comparator<?>是所有<Comparator T> 的父 类型
“?"称为通配符，表示通配类型，代表能够匹配任何类型。
? ? extends T T：?表示 T T 及其任意一种子类型，T 称为?的上界?
？ super T T：?表示 T T 及其任意一种父类型，T 称为?的下界
第五章 异常处理
1 1 、 错误：指程序遇到的硬件错误，或操作系统、虚拟机等系统软件错误，或操
作错误，错误将导致程序无法运行。
2 2 、 异常：指在硬件、操作系统或虚拟机等系统软件运行正常时，程序产生的运
行错误
3 3 、 RuntimeException ： 运行时异常 类
 ArithmeticException 算术运算异常: 如除数为 0
 NullPointerException 空对象异常
 IllegalArgumentException 非法参数异常
 NumberIndexOutOfBoundsException 数值格式异常
4 4 、 程序对错误和异常的三种处理方式：
程序不能处理错误；程序应避免而不捕获的异常；必须处理的异常
5 5 、 异常处理措施
异常处理机制：异常类体系、异常处理的 try 语句、抛出自定义异常的 throw
语句、声明方法抛出异常的 throws 子句和自定义异常类
异常处理语句语法
try{语句 1 //存在潜在异常的代码}
catch(异常类异常对象){语句 2 //捕获到异常并进行处理的语句}
finally{语句 3 //最后必须执行的代码，无论是否捕获到异常}
抛出异常& & 自定义异常类 ：程序
第七章 多线程
1 1 、 进程 （ process ）
 进程：一个可并发执行的具有独立功能的程序（program），关于某个数据
集合的一次执行过程，也是操作系统进行资源分配和保护的基本单位。
 特性：结构性、独立性、动态性、并发性、交互性
 进程的状态：就绪(ready)态、运行(running)态、阻塞(blocked)态
2 2 、线程 (thread)
 线程：操作系统进程中能够独立执行的实体(控制流)，是处理器调度和分派
的基本单位
 特性：并发性、共享性、动态性、结构性
 状态：新建、就绪、运行、阻塞、终止
 剥夺原则：高优先级线程可以剥夺低优先级线程运行、运行线程时间使用完
后被剥夺处理器
3 3 、并发程序设计：
（1 1： ）顺序程序设计： （并发与其相反）
 执行的顺序性。
 环境的封闭性。
 执行结果的确定性
 计算结果的可再现性
4 4 、创建线程：
（1 1 ）e Runnable 接口
public interface Runnable
{public abstract void run();}
（2 2 ）T Td hread 线程类
public class Thread extends Object implements Runnable
{
public Thread(String name) e //name 指定线程 名
public Thread(Runnable target) //target 指定线程的目标对象
public Thread(Runnable target, String name)
public void run() // 描述线程操作的线程体
public final String getName() //返回线程名
public final void setName(String name) //设置线程名
public static int activeCount() //返回当前活动线程个 数
public static Thread currentThread() //返回当前执行线程 对 象
public Sting toString() //返回线程的字符串信息
public void start() // 启动已创建的线程对象
}
 线程启动：public void start() //启动线程对象
public final boolean isAlive() //是否启动
 线程睡眠：public static void sleep(long millis) throws
InterruptedException
 线程中断：public void interrupt() //设置中断标记
public boolean isInterrupted() //判断是否中断
public static boolean interrupted() //判断是否中断
 线程优先级：
public static final int MIN PRIORITY =1 //最低优先级
[MAX_ PRIORITY =10//最高优先级][NORM_ PRIORITY=5 //默认优先级
public final int getPriority() //获得线程优先级
public final void setPriority(int newPriority)// 设置线程优先级
无关的并发线程：线程在不同的集合上操作，一个线程的执行与其他并发线程的
进展无关。
交互的并发线程：线程间共享某变量，一个线程的执行可能会影响其他线程的执
行结果，交互的并发线程之间具有制约关系
线程之间的竞争关系：
 死锁问题：一组线程都获得了部分资源，还想得到其他线程所占用的资
源。最终所有线程将陷入死锁
 饥饿问题：一个线程由于其他线程总是优先于它而被无期限拖延
线程互斥与临界区管理：
 线程互斥：解决线程间竞争关系的手段，指若干线程要使用同一
共享资源时，任何时刻最多允许一个线程去使用，其他要使用该
资源的线程必须等待，直到占有资源的线程释放该资源
 临界资源：共享变量代表的资源
 临界区：并发线程中与共享变量有关的程序段
临界区调度原则: :
 一次至多一个线程能够在它的临界区内
 不能让一个线程无限地留在它的临界区内
 不能强迫一个线程无限地等待进入它的临界区，进入临界区的任一线程
不能妨碍正等待进入的其他线程的进展
互斥实现 ：
 同步语句：对象为需要锁定的共享资源，语句是临界区
synchronized (对象)
语句
 同步方法：方法体成为临界区，互斥使用（锁定）的是调用该方法的 对象
synchronized 方法声明
： 线程间的协作关系：一个进程中多个线程为了完成同一个任务而分工协作彼此之
间有联系，受其他线程执行的影响
线程同步：两个以上线程基于某个条件来协调它们的活动
线程同步机制：信号量和 P P （测试信号量状态）V V （改变信号量状态）操作
线程通信方法：
public final void wait() throws InterruptedException//等待
public final void wait(long time) throws InterruptedException
public final native void notify();//唤醒一个等待当前临界资源线程
public final native void notifyAll();//唤醒所有等待线程
int num = new Scanner(System.in).nextInt();
String user = new Scanner(System.in).next();
double banlance = new Scanner(System.in).nextDouble();
布局管理：FlowLayout、BorderLayout(边布局)、GridLayout（网格布局）
事件 (event)：一个状态的改变，或者一个活动的发生
事件源(event source)产生事件的组件称为
事件监听器接口
public interface ActionListener extendsEventListener//单击事…
{ public void actionPerformed(ActionEvent e); //单击事件处理方法}
public class Button extends Component implements Accessibl{
public void addActionListener(ActionListener I) //注册事件监听器
public void removeActionListener(ActionListener I) //取消注册}
第三章：
public class DateFormatException extends IllegalArgumentException
{public DateFormatException(String s){super(s);}
public DateFormatException(){super();}}
public class MyDate
{private int year,month,day;
public static boolean isLeapYear(int year) //判断指定年份是否为闰年
{return year%400==0||year%100!=0&&year%4==0;}
public boolean isLeapYear() //判断当前日期是否是闰年，重载
{return isLeapYear(this.year); //调用静态方法}
public static int daysOfMonth(int year,int month) //返回指定年月的天数
{
switch(month)
{
case 1:case 3:case 5:case 7:case 8:case 10:case 12:return 31;
case 4:case 6:case 9:case 11:return 30;
case 2:return MyDate.isLeapYear(year)?29:28;
default:return 0;
}
}
public void set(int year,int month,int day) throws DateFormatException
//设置日期
{
if(year<=-2000||year>2500)
throw new DateFormatException(year+",年份不合适，有效年份为-2000~2500。");
if(month<1||month>12)
throw new DateFormatException(month+"月，月份错误！");
if(day<1||day>daysOfMonth(year,month))
throw new DateFormatException(year+"年"+month+"月"+day+"日，日期错误！");
this.year=year;this.month=month;this.day=day;
}
public MyDate(int year,int month,int day) throws DateFormatException
{this.set(year, month, day);}
public MyDate(MyDate d) throws DateFormatException
{this.set(d.year,d.month,d.day);}
 public MyDate(String s) throwsDateFormatException,NumberFormatException
{
this.set(Integer.parseInt(s.substring(0, 4)),
Integer.parseInt(s.substring(5, 7)), Integer.parseInt(s.substring(8, 10)));
}
public static void main(String args[])
{System.out.println(new MyDate("2013-02-29").toString())}
}
第六章
import java.awt.*;import java.awt.event.*;
public class QueryFrame extends Frame implements ActionListener
{private TextField text_char,text_uni; //两个文本行
private Button button_char,button_uni; //两个按钮
public QueryFrame()
{
super("Unicode 字符查询器");
this.setBounds(300, 240, 280, 90); //设置框架位置和尺寸
this.setBackground(Color.lightGray);
this.setLayout(new GridLayout(2,3,2,2)); // 2行3列，组件间距为2
this.add(new Label("字符：",Label.RIGHT)); //标签组件右对齐
text_char=new TextField("汉字",10);this.add(text_char);
button_char=new Button("查询Unicode码");this.add(button_char);
button_char.addActionListener(this);//注册动作事件监听器，委托当前对象处理事件
this.add(new Label("Unicode编码：",Label.RIGHT));
text_uni=new TextField(10);this.add(text_uni);
button_uni=new Button("查询字符");this.add(button_uni);
button_uni.addActionListener(this);
this.addWindowListener(new WinClose());//注册窗口事件监听器，委托Winclose对象
this.setVisible(true);
 }
public void actionPerformed(ActionEvent ev)
{
if(ev.getSource()==button_char)//ev.getSource()获得当前事件源组件，计较引用
{
String str=text_char.getText(); //获得文本行的字符串
if(str.equals(""))
return; //输入空串不执行操作
char ch=str.charAt(0); //获得首字符
text_char.setText(""+ch); //重新设置文本，显示字符
text_uni.setText(""+(int)ch); //显示ch的Unicode码
}
else if(ev.getSource()==button_uni) //ev.getSource()获得当前事件源组件，
计较引用
{
String str=text_uni.getText(); //获得文本行的字符串
if(str.equals(""))
return;
int uni=Integer.parseInt(str); //将文本行字符串转换成整数，
未处理异常
text_char.setText(""+(char)uni); //显示Unicode码对应的字符
}
}
class WinClose implements WindowListener //实现窗口事件监听器窗口
{public void windowClosing(WindowEvent ev) //关闭窗口时执行的事件处理方法
{System.exit(0);}
public void windowClosed(WindowEvent ev) {}
}}
第七章：
public class NumberRunnable implements Runnable
{private int first;
private NumberRunnable(int first)
{this.first=first;}
public void run() //线程体，实现Runnable接口
{System.out.println();
for(int i=first;i<50;i+=2)
{System.out.print(i+" ");}
System.out.println("结束！");}
public static void main(String[] args)
{NumberRunnable target=new NumberRunnable(1); //创建具有线程体的目标对象
Thread thread_odd=new Thread(target,"奇数线程"); //以目标对象创建线程对象
thread_odd.start();
new Thread(new NumberRunnable(2),"偶数线程").start();;}}
同步语句：
synchronized(this.account)
{double howmatch=this.account.balance;
try {Thread.sleep(1);}
catch (InterruptedException ex){}
System.out.println(this.account.name+"账户：现有"+howmatch+",取走
"+this.account.get(value)+",余额"+this.account.balance);}
采用信号量和同步方法是发送线程和接受线程同步运行：
public class Buffer //缓冲区类
{
private int value; //共享变量，临界资源
private boolean isEmpty=true; //value是否为空信号量
synchronized void put(int i)
{
while(!this.isEmpty)
try {this.wait();}
catch (InterruptedException e) {}
this.value=i; //当value为空，value获得值
this.isEmpty=false;
 this.notify(); //唤醒一个等待当前临界资源的线程
}
synchronized int get()
{
while(this.isEmpty) //当value为空，等待
try {this.wait();}
catch (InterruptedException e) {}
this.isEmpty=true; //设置value为空，并返回值this.notify();
return this.value;}
public static void main(String[] args)
{Buffer buffer=new Buffer();
(new SendThread(buffer)).start();(new ReceiveThread(buffer)).start();}}
public class SendThread extends Thread //发送线程类
{
private Buffer buffer;
public SendThread(Buffer buffer)
{this.buffer=buffer; //指定缓冲区}
public void run()
{for(int i=1;i<5;i++)
buffer.put(i); //连续向缓冲区发送若干数据
System.out.println(this.getClass().getName()+"put:"+i);}
}
public class ReceiveThread extends Thread //发送线程类
{
private Buffer buffer;
public ReceiveThread(Buffer buffer)
{
this.buffer=buffer; //指定缓冲区
}
public void run()
{
for(int i=1;i<5;i++)
{
System.out.println("\t\t\t\t"+this.getClass().getName()+"get:"+buffer.get()
);
}
 }
}
起始日1979-12-31 是星期一
int total=y-1980+(y-1980+3)/4; //求平（闰）年累计的总天数
for(int i=m-1;i>0;i--) //计算当年前month-1个月累计的天数
{
switch(i)
{case 1:case 3:case 5:case 7:case 8:case 10:total+=31;break;
case 4:case 6:case 9:case 11:total+=30;break;
case 2:total+=leap ?29:28;}
}
total+=d;
int week=1; //起始日1979-12-31 是星期一week=(week+total)%7;return week;