实验1
随机生成一个10个元素组成一维数组，输出数组中的最大值、最小值、所有元素总和，以及最大值和最小值在该数组中的位置，并实现数组的排序。
实验源程序:
public class ShuZu {
public static void main(String[] args) {
//生成一个数组,里面放十个整数
int[] array = new int[10];
//初始化整数i,j=0
int i,j = 0;
int temp;
int sum = 0;
int max,min;
//输出"随机生成的十个元素的数组为："这句话,并在后面的for循环生成随机十个数和他们的总和
System.out.print("随机生成的十个元素的数组为：");
//Math.random生成0到1伪随机浮点数,再乘100,生成0到100随机浮点数,然后用Math.round四舍五入取整数
//for循环中输出这随机十个数
for ( i = 0; i < array.length; i++) {
array[i] = (int) Math.round(Math.random()*100);
System.out.print(array[i] + " ");
sum += array[i];
}
//换行,或者用System.out.println();
System.out.print("\n");
//输出数组中所有元素的总和
System.out.println("数组中所有元素的总和为：" + sum);
//输出最大数
max = array[0];
for ( i = 0; i < array.length; i++) {
if(max < array[i]) {
max = array[i];
j = i;
}
}
System.out.println("数组的最大数为：" + max + " " + "在数组中的位置为：" + j);
//输出最小数
min = array[0];
j = 0;
for ( i = 0; i < array.length; i++) {
if(min > array[i]) {
min = array[i];
j = i;
}
}
System.out.println("数组的最小数为：" + min + " " + "在数组中的位置为：" + j);
//升序排序
System.out.print("数组升序排序为：");
for ( i = 0; i < array.length; i++) {
for(j = i; j < array.length; j++) {
if(array[i] > array[j]) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
System.out.print(array[i] + " ");
}
//换行
System.out.println();
//降序排序
System.out.print("数组降序排序为：");
for ( i = 0; i < array.length; i++) {
for(j = i; j < array.length; j++) {
if(array[i] < array[j]) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
System.out.print(array[i] + " ");
}
}
}
实验笔记：
在本次实验中，我在编写for ( i = 0; i < array.length; i++) {… …}这个循环的时候犯了一个错误，我一开始写成了for ( i = 0; i = array.length; i++) {… …},然后他就无限循环了，后来修改错误的时候，我又改成了for ( i = 0; i ==array.length; i++) {}，还是无限循环，然后我改成了for ( i = 0; i < array.length; i++) {}。因为array.length的长度为10，i最高只能到9.
在实验中取随机数时, 用Math.random生成0到1伪随机浮点数,再乘100,生成0到100随机浮点数,然后用Math.round四舍五入取整数.本来是如下图所写的,然后按照提示我转换到了int.
此处有一个疑问,这样的数感觉起来并不是那么随机
实验2:
利用arraycopy 和 copyof 方法分别实现两个数组的内容拷贝，并利用foreach语法显示两个数组元素的内容。
实验源程序:
Arraycopy方法:
public class ArrayCopy {
public static void main(String[] args) {
//定义数组a,b并初始化.
int[] a={67,87,99,89,54,59,67,43,36,90};
int[] b={1489,15,89,898,48,6798,487,8487,965,480};
//从a数组下标为0的开始,复制到b下标为0,一直往后复制,长度为10
System.arraycopy(a,0,b,0,10);
//foreach输出数组a
System.out.println("数组a：");
for(int i : a) {
System.out.print(i + " ");
}
//换行
System.out.println();
//foreach输出拷贝过后的数组b
System.out.println("数组b：");
for(int i : b) {
System.out.print(i + " ");
}
}
}
copyOf方法:
import java.util.Arrays;
public class CopyOf {
public static void main(String[] args) {
//定义数组a,b并初始化
int[] a={67,87,99,89,54,59,67,43,36,90};
int[] b={1489,15,89,898,48,6798,487,8487,965,480};
//将a数组的元素传给b,长度为10
b = Arrays.copyOf(a,10);
//foreach输出数组a,b中的元素
System.out.println("数组a：");
for(int i : a) {
System.out.print(i + " ");
}
//换行
System.out.println();
System.out.println("数组b：");
for(int i : b) {
System.out.print(i + " ");
}
}
}
实验笔记:
1.
System.arraycopy(int[] arr, int start,int[] arr2, int start2, length);
5个参数，
第一个参数是要被复制的数组
第二个参数是被复制的数字开始复制的下标
第三个参数是目标数组，也就是要把数据放进来的数组
第四个参数是从目标数据第几个下标开始放入数据
第五个参数表示从被复制的数组中拿几个数值放到目标数组中
2.
foreach 语法格式如下：
for(元素类型t 元素变量x : 遍历对象obj){
引用了x的java语句;
}
3.
Arrays.copyOf() 用法：
Arrays的copyOf()方法传回的数组是新的数组对象，改变传回数组中的元素值，不会影响原来的数组。
copyOf()的第二个自变量指定要建立的新数组长度，如果新数组的长度超过原数组的长度，则保留数组默认值
实验3
编写一个程序，完成以下功能：
1）声明一个名为name的String对象，内容是“My name is NetworkCrazy”
2）打印字符串的长度
3）打印字符串的第一个字符
4）打印字符串的最后一个字符
5）打印子字符串NetworkCrazy（substring()方法提取子字符串）
6）利用lastIndexOf()方法搜索字符 ‘e’ 最后一次出现的位置
java.lang.String.lastIndexOf()方法的声明
public int lastIndexOf(int ch)
实验源程序:
对象，内容是“My name is NetworkCrazy”
String name="My name is NetworkCrazy";
//用String中的 length() 方法获取字符串的长度
System.out.println("字符串长度：" + name.length());
//用String charAt()方法打印字符串的第一个字符
System.out.println("字符串的第一个字符：" + name.charAt(0));
//用String charAt()方法打印字符串的最后一个字符
System.out.println("字符串的最后一个字符：" + name.charAt(name.length()-1));
//定义一个字符串做缓冲
String buffer=" ";
//String的indexOf方法,获取Network在字符串中的位置
int a = name.indexOf("Network");
//String的lastindexOf方法,获取y最后出现的位置
int b = name.lastIndexOf("y");
//b+1是因为substring在"(b+1)-1"处结束
buffer = name.substring(a,b+1);
//输出子字符串
System.out.println("substring()方法提取子字符串:"+buffer);
//输出e最后出现的位置
int m = name.lastIndexOf("e");
System.out.println("字符串中e最后一次出现的位置为：" + m);
}
}
实验笔记:
- Java String中的 length() 方法用于获取字符串的长度，并以int型变量返回该字符串的长度。
- Java String charAt()方法返回位于字符串的指定索引处的字符。该字符串的索引从零开始。索引范围为0到length()-1。
- String类中lastIndexOf（）与indexOf（）方法的区别。
lastIndexOf（）方法，返回子字符串最后出现的位置。没有找到，则返回 -1。
如:”ABCDABCD”.lastIndexOf(“BC”) ; 返回5
“ABCDABCD”.lastIndexOf(“DE”) ; 返回-1
indexOf（）方法返回子字符串第一次出现字符位置。没有找到，则返回 -1。
如:”ABCD ABCD ” .indexOf(“BC”) ; 返回1
“ABCDABCD”.indexOf(“B”) ； 返回1
“ABCDABCD”.indexOf(“DE”) ; 返回-1
4. substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始， endIndex:到指定的 endIndex-1处结束。
实验5:
利用StringBuffer类实现在字符缓冲区中存放字符串 “Happy new year!”，并通过setCharAt和charAt实现字符设置和替换，利用insert实现字符的插入，利用append实现在字符串末尾添加相应的内容。
setCharAt(int index,char ch),将指定的字符ch放到index指出的位置。
charAt(int index) 获得指定位置的字符
insert(int offset,char ch),在offset位置插入字符ch。
实验源程序:
public class StringPracticeTwo {
public static void main(String[] args) {
//用StringBuffer类实现在字符缓冲区中存放字符串 "Happy new year!"
StringBuffer A = new StringBuffer("Happy new year!");
//转为String,输出我们要转化的字符
A.toString();
System.out.print("要替换的字符为：");
//获取指定位置的字符放入i,j,k中
char i = A.charAt(3);
char j = A.charAt(6);
char k = A.charAt(10);
//输出这些上述的指定位置的字符
System.out.print(i);
System.out.print(j);
System.out.print(k);
//换行
System.out.println();
//将指定位置的字符换为x,y,z
A.setCharAt(3,'x');
A.setCharAt(6,'y');
A.setCharAt(10,'z');
//输出替换后的字符串
System.out.print("替换后的字符串为：");
System.out.println(A);
//在5这个位置插入i这个字符
A.insert(5,'i');
System.out.print("插入后的字符串为：");
System.out.println(A);
//用append在字符串后面插入字符!
A.append('!');
System.out.print("字符串末尾加入字符后为：");
System.out.println(A);
}
}
实验笔记：
1.众所周知String作为不可修改的对象，即每次更改String都会产生一个新的字符串对象，与之相对应的StringBuffer类的对象能够进行多次修改并且不会产生新的未使用的对象，因此在内存上要优于String对象
2. StringBuffer的常用方法解析
3. StringBuffer和String之间的相互转化
对于StringBuffer而言不可直接强制类型转化，即StringBuffer a=（StringBuffer）‘ac’是错误的使用方法。
对于StringBuffer转化为String可使用 String b=a.toString(），对于String转为StringBuffer可使用StringBuffer b=new StringBuffer(string)
实验6:
1.创建一个Rectangle类，添加两个（private）属性width和height。
2.创建一个构造方法，选择width和height为形式参数。
3.在Rectangle中添加两个方法分别计算矩形的周长和面积
实验源程序:
public class RectangleInfo {
public static void main(String[] args) {
//定义变量perimeter和area,用来表示周长面积
double perimeter;
double area;
//new一个Rectangle对象
Rectangle R = new Rectangle();
//用Rectangle中的方法计算周长和面积
perimeter = R.perimeter(3,9);
area = R.area(3,9);
System.out.println("矩形的周长为：" + perimeter +" "+ "矩形的面积为：" + area);
}
}
//Rectangle类
class Rectangle{
//private属性width，heigh
private double width;
private double height;
public Rectangle() {
}
//构造方法,以width和height为形式参数
public Rectangle(double width,double height) {
this.width = width;
this.height = height;
}
//添加方法,计算周长
public double perimeter(double width,double height) {
return 2 * (width + height);
}
//添加方法,计算面积
public double area(double width,double height) {
return width * height;
}
}
实验笔记:
Java中this和super的用法总结:
this
this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。
this的用法在java中大体可以分为3种：
1.普通的直接引用
这种就不用讲了，this相当于是指向当前对象本身。
2.形参与成员名字重名，用this来区分：
3.引用构造函数
super
super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。
作用：
1.普通的直接引用
2.子类中的成员变量或方法与父类中的成员变量或方法
3.引用构造函数
参考: https://www.cnblogs.com/hasse/p/5023392.html
实验7:
创建三角形、梯形和圆形的类封装：分别定义三角形、梯形和圆形类，要求每个类中包含构造方法、求周长及面积的方法。最后在主方法main中为三角形、梯形和圆形类中创建对象并打印输出各种图形的周长及面积。（一个文件中包含3个class类和main）
A）Triangle类具有类型为double的三个边，以及周长、面积属性，Triangle类具有返回周长、面积及修改三个边的功能。另外，Triangle类还具有一个boolean型的属性，该属性用来判断三个边能否构成一个三角形。
B）Lader类有类型为double的上底、下底、高和面积属性，具有返回面积的功能。
C）Circle类有类型为double的半径、周长和面积属性，具有返回周长、面积的功能。
实验源程序:
public class TriangleTrapezoidCircle {
public static void main(String[] args) {
////实例化对象并将参数传给构造方法
Triangle T = new Triangle(5,12,13);
Lader L = new Lader(4,7,2);
Circle C = new Circle(1);
//输出周长和面积
System.out.println("三角形的周长为：" + T.perimeter());
System.out.println("三角形的面积为：" + T.area());
//修改后的三边输出
T.modify(6, 8, 10);
System.out.println("修改三边后三角形的周长为：" + T.perimeter());
System.out.println("修改三边后三角形的面积为：" + T.area());
T.modify(3, 2, 1);
System.out.println("如果修改三边后不能构成一个三角形");
System.out.println(T.area() + T.perimeter());
//输出梯形的面积
System.out.println("梯形的面积为：" + L.area());
//输出圆形的周长和面积
System.out.println("圆形的周长为：" + C.perimeter());
System.out.println("圆形的面积为：" + C.area());
}
}
//三角形类
class Triangle{
//定义变量abc表示三边
double a,b,c;
boolean flag;
//构造方法,以abc为形参
public Triangle(double a,double b,double c) {
this.a = a;
this.b = b;
this.c = c;
//a,b,c构成三角形的条件表达式
if(a+b>c&&a+c>b&&c+b>a) {
flag = true;
}
else{
flag = false;
}
}
//添加方法,周长计算
double perimeter() {
if(flag) {
return a + b + c;
}
else {
System.out.println("三角形的周长为:此三边的值不能构成一个三角形,无法计算周长");
return 0;
}
}
//添加方法,计算三角形面积（p=(a+b+c)/2）,S=sqrt[p(p-a)(p-b)(p-c)]
double area() {
if(flag) {
double p = (a + b + c) / 2;
return Math.sqrt(p*(p-a)*(p-b)*(p-c));
}
else {
System.out.println("三角形的面积为:此三边的值不能构成一个三角形,无法计算面积");
return 0;
}
}
//修改三角形的三边
void modify(double a,double b,double c) {
this.a = a;
this.b = b;
this.c = c;
//a,b,c构成三角形的条件表达式
if(a+b>c&&a+c>b&&c+b>a) {
flag = true;
}
else {
flag = false;
}
}
}
//梯形类
class Lader{
double upper,lower;
double height;
//构造方法,以upper,lower,height为形参
public Lader(double upper,double lower,double height) {
this.upper = upper;
this.lower = lower;
this.height = height;
}
//添加方法,计算面积
double area() {
return (upper + lower)*height / 2;
}
}
//圆形类
class Circle{
double radius;
//构造方法,以半径为形参
public Circle(double radius) {
this.radius = radius;
}
//添加方法,计算圆形周长
double perimeter() {
return (2 * 3.14 * radius);
}
//添加方法,计算圆形面积
float area() {
return (float) (3.14 * radius * radius);
}
}
实验8:
方法重载的练习:
编写一个程序，定义一个类，类有3个plus（）方法，分别实现两个数相加，三个数相加，四个数相加的程序。
实验源程序:
public class MethodOverloading {
public static void main(String[] args) {
int sum;
MethodOverloading g = new MethodOverloading();
//根据方法参数不同进行方法重载，得到不同的和
sum = g.plus(1,2);
System.out.println("两个数的和：" + sum);
sum = g.plus(1,2,3);
System.out.println("三个数的和：" + sum);
sum = g.plus(1,2,3,4);
System.out.println("四个数的和：" + sum);
}
//参数为2个，plus方法，实现相加
int plus(int a,int b)
{
return a + b;
}
//参数为3个，重载
int plus(int a,int b,int c)
{
return a + b + c;
}
//参数为4个，重载
int plus(int a,int b,int c,int d)
{
return a + b + c + d;
}
}
实验笔记:
重载是指不同的方法使用相同的方法名，但是方法的参数个数或类型不同。调用的时候根据方法的参数来区别不同的方法。是发生在类内。
与重写不同
重写（也叫覆盖）是指在派生类中重新对基类中的虚方法重新实现。即方法名和参数都一样，只是方法的实现不一样。是发生在类间，类继承的时候，主要是方法的内容不同。
实验9:
编译并运行下面的程序，观察分析运行结果，体会程序super和this的用法，进一步理解变量隐藏和方法重写的概念。
实验源程序:
public class SuperThis {
public static void main(String[] args) {
ZhangSan zhangsan=new ZhangSan();
zhangsan.superThisUseDemo();
}
}
class Person{
int weight;
Person(){
weight=50;
}
void printPerson() {
System.out.println("Person.printPerson()");
}
}
class ZhangSan extends Person{
int weight;
ZhangSan(){
super();
weight=500;
}
void printPerson() {
System.out.println("ZhangSan.printPerson()");
}
void superThisUseDemo() {
int weight;
weight=5000;
super.printPerson();
printPerson();
System.out.println("super.weight="+super.weight);
System.out.println("this.weight="+this.weight);
System.out.println("weight="+weight);
}
}
分析如下:
首先程序建立了Person类，并在类内有自己的构造方法和方法。然后建立了ZhangSan类extends Person，即继承了Person类，并在自己的构造方法内调用了Person类的构造方法，重写Person类的printPerson()方法。因此Person类为父类，ZhangSan类为子类。最后在主方法main中实例化了ZhangSan的对象zhangsan，并调用了superThisUseDemo()方法显示super和this的差别。
其中
System.out.println("super.weight="+super.weight);
所在的类是ZhangSan类，super.weight输出父类中的weight，值为50。
System.out.println("this.weight="+this.weight);
this.weight输出自己所在类，即ZhangSan类中的weight值,值为500。
若不加修饰则输出所在的方法本身的值，值为5000。
因为若父类和子类中都用相同名称的成员变量，在调用时，父类的成员变量会被隐藏，需要使用super来调用父类中被隐藏的成员变量或者被重写的方法。
实验笔记:
这个在之前的实验笔记里已经总结过super和this的区别,所以做这个的时候也是很简单.
实验10:
下面的代码有什么错误，应该如何解决？
实验源程序:
修改后:
import java.lang.String;
public class ErrorCorrect {
public static void main(String[] args) {
A a = new A("123");
a.print();
}
}
class A{
String s;
A(String s){
this.s = s;
}
public void print() {
System.out.println(s);
}
}
实验分析:
程序中在为类A创建实例化对象时报错，因为此时实例化对象时，系统默认的是无参的构造方法，而在class A中并没有无参构造方法。于是采用传参的构造方法. 此时得到了字符串“123”，因为实例化对象时就把字符串“123”传参到了class A中的构造方法，再a.print()就可以实现字符串输出。
实验11:
熟悉Date类和Calendar类的成员方法
参考课本日历程序（但需修正），实现输出当前月份日历的程序（输出时要考虑上个月和下个月的天数情况），并将此程序改为万年历，可以任意输出指定月份的日历。
例如：
实验源程序:
输出当前月份日历:
import java.util.*;
import java.io.*;
public class DateCalendar {
public static void main(String[] args) {
//字符串转换为日期后再转换成Calendar标准日期类
Calendar calendar = Calendar.getInstance();
//设置时间为当前时间
calendar.setTime(new Date());
//获取年份
int year = calendar.get(Calendar.YEAR);
//获取月份
int month = calendar.get(Calendar.MONTH)+1;
//获取天数
int day = calendar.get(Calendar.DAY_OF_MONTH);
//获取星期几
int week = calendar.get(Calendar.DAY_OF_WEEK)-1;
//获取时、分、秒
int hour = calendar.get(Calendar.HOUR);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
//把输入日期变为当月1号
calendar.set(Calendar.DATE, 1);
//根据当月月份来获取所有当月的总天数
int monthAllDay = calendar.getActualMaximum( Calendar.DAY_OF_MONTH );
//获取当天的星期数
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
//输出当前时间
System.out.println("现在日期是：" + year + "年" + month + "月" + day + "日 星期" + week);
System.out.println("现在时间为：" + hour + "时" + minute + "分" + second + "秒");
System.out.println("当前月份日历：");
System.out.println("日 \t 一 \t 二 \t 三 \t 四 \t 五 \t 六");
//上一个月。calendar.set(Calendar.MONTH, month)时，"月"的计数是从0开始的。
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month-2);
//上个月最大天数
int foreMaxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
int fdk = dayOfWeek;
//补齐上月天数
for (int k = 1; k <= dayOfWeek; k++) {
fdk --;
System.out.print("[" + (foreMaxDay-fdk) + "]" + "\t");
}
//恢复原来的月
calendar.set(Calendar.MONTH, month-1);
//循环当月天数
for (int i = 1; i <=monthAllDay; i++) {
if( i == day ) {
System.out.print("#");
}
System.out.print(i+"\t");
int w =calendar.get( Calendar.DAY_OF_WEEK ) - 1;
//逢周六换行
if( w == 6 ) {
System.out.println();
}
//当月天数加1天
calendar.add(Calendar.DATE, 1);
}
//下一个月
calendar.set(Calendar.MONTH, month);
//把输入日期变为当月1号
calendar.set(Calendar.DATE, 1);
//获取当天的星期数
int nextdayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
//补齐下月天数
for(int i = 1;i <= 6 - nextdayOfWeek + 1;i++) {
System.out.print("[" + i + "]" + "\t");
}
}
}
输出指定月份日历:
import java.util.Scanner;
import java.util.Calendar;
import java.util.Date;
public class DateCalendarPro {
public static void main(String[] args) {
//字符串转换为日期后再转换成Calendar标准日期类
Calendar calendar = Calendar.getInstance();
Scanner sc = new Scanner(System.in);
System.out.print("请输入年份：");
int y = sc.nextInt();
System.out.print("请输入月份：");
int m = sc.nextInt();
calendar.set(Calendar.YEAR, y);
calendar.set(Calendar.MONTH, m-1);
//把输入日期变为当月1号
calendar.set(Calendar.DATE, 1);
//根据当月月份来获取所有当月的总天数
int monthAllDay = calendar.getActualMaximum( Calendar.DAY_OF_MONTH );
//获取当天的星期数
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
//输出日历
System.out.println("当前月份日历：");
System.out.println("日 \t 一 \t 二 \t 三 \t 四 \t 五 \t 六");
//上一个月。calendar.set(Calendar.MONTH, month)时，"月"的计数是从0开始的。
calendar.set(Calendar.YEAR, y);
calendar.set(Calendar.MONTH, m-2);
//上个月最大天数
int foreMaxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
int fdk = dayOfWeek;
//补齐上月天数
for (int k = 1; k <= dayOfWeek; k++) {
fdk --;
System.out.print("[" + (foreMaxDay-fdk) + "]" + "\t");
}
//恢复原来的月
calendar.set(Calendar.MONTH, m-1);
//循环当月天数
for (int i = 1; i <=monthAllDay; i++) {
System.out.print(i+"\t");
int w =calendar.get( Calendar.DAY_OF_WEEK ) - 1;
//逢周六换行
if( w == 6 ) {
System.out.println();
}
//当月天数加1天
calendar.add(Calendar.DATE, 1);
}
//下一个月
calendar.set(Calendar.MONTH, m);
//把输入日期变为当月1号
calendar.set(Calendar.DATE, 1);
//获取当天的星期数
int nextdayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
//补齐下月天数
if(nextdayOfWeek != 0) {
for(int i = 1;i <= 6 - nextdayOfWeek + 1;i++) {
System.out.print("[" + i + "]" + "\t");
}
}
}
}
实验笔记:
1.首先通过calendar.setTime(new Date())把时间设置为当前时间，然后通过calendar.get得到具体时间，并输出。接着输出一排星期，换一行就可以输出日期了。然后设置时间到当前月的上一个月，通过循环补齐上个月的日期；接着返回当前月份，循环输出这个月的日期；最后设置月份到下一个月，补齐下月的日期。
2.
设置
设置时间为当前时间：calendar.setTime(new Date());
设置年份：calendar.set(Calendar.YEAR, year);
设置月份：calendar.set(Calendar.MONTH, month);
设置日期为当月1号：calendar.set(Calendar.DATE, 1);
获取
获取年份：int year = calendar.get(Calendar.YEAR);
获取月份：int month = calendar.get(Calendar.MONTH)+1;
获取天数：int day = calendar.get(Calendar.DAY_OF_MONTH);
获取星期几：int week = calendar.get(Calendar.DAY_OF_WEEK)-1;
获取时、分、秒：int hour = calendar.get(Calendar.HOUR);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
获取一个月最大天数：calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
暂无评论内容