Java第四次实验作业A(山东大学)

实验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);
    }

}

实验笔记:

  1. Java String中的 length() 方法用于获取字符串的长度,并以int型变量返回该字符串的长度。
  2. Java String charAt()方法返回位于字符串的指定索引处的字符。该字符串的索引从零开始。索引范围为0到length()-1。
  3. 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);

© 版权声明
THE END
喜欢就支持以下吧
点赞0赞赏
分享
评论 抢沙发

请登录后发表评论