Java学习笔记

1、ArrayList的学习

ArrayList构造方法和添加方法

  • public ArrayList() 创建一个空的集合对象
  • public Boolean add(E e) 将指定的元素追加到此集合的末尾
  • public void add(int index,E element) 在此集合的指定位置插入指定元素

1、

import java.util.ArrayList;

public class ArrayListDemo01 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();

        System.out.println(array.add("hello"));
        array.add(1,"java");
        System.out.println("array:" +array);
    }
}

2、
-public Boolean remove(Object o):删除指定的元素,返回删除是否成功

  • public E remove(int index):删除指定索引处的元素,返回被删除的元素
  • public E set(int index,E element ):删除指定索引处的元素,返回被修改的元素
  • public E get(int index):返回索引处的元素
  • public int size():返回集合中的元素的个数
import java.util.ArrayList;

public class ArrayListDemo01 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();


        array.add("hello");
        array.add("world");
        array.add("java");
//        array.add(1,"java");

        System.out.println(array.set(2,"javaee"));
        System.out.println(array.remove("world"));
        System.out.println(array.get(1));
        System.out.println(array.size());

        System.out.println("array"+array);
    }
}

输出结果:
java
true
javaee
2
array[hello, javaee]


3、遍历

import java.util.ArrayList;

public class ArrayListDemo02 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();

        array.add("hello");
        array.add("world");
        array.add("java");
       /* System.out.println(array.get(0));
        System.out.println(array.get(1));
        System.out.println(array.get(2));*/

       for (int i=0;i<array.size();i++){
//           System.out.println(array.get(i));
           String s = array.get(i);
           System.out.println(s);
       }
    }
}

输出
hello
world
java

4、ArrayList 存储学生对象并遍历

import java.util.ArrayList;

public class ArrayListDemo3 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> array = new ArrayList<>();
        //创建学生对象
        Student stu1 = new Student("weblv",30);
        Student stu2 = new Student("ljx",23);

        //添加学生对象到集合中
        array.add(stu1);
        array.add(stu2);

        //遍历集合,采用通用遍历格式实现
        for(int i=0;i<array.size();i++){
            Student s = array.get(i);
            System.out.println(s.getName() + ','+s.getAge());
            
        }
        
        
    }
}
输出
weblv,30
ljx,23

5、ArrayList 存储学生对象并遍历(升级)



import java.util.ArrayList;
import java.util.Scanner;

public class ArrayListDemo04 {
    public static void main(String[] args) {
        ArrayList<Student> array =new ArrayList<Student>();
        //调用方法
       AddStu(array);
       AddStu(array);
       AddStu(array);
       //输出对象
        for (int i=0;i<array.size();i++){
            Student s = array.get(i);
            System.out.println(s.getName() +',' +s.getAge());


        }
    }
    public static void AddStu(ArrayList<Student> array){
        //键盘录入学生对象所需的数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生姓名:");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄");
        String age = sc.nextLine();

        //创建学生对象,把键盘录入的数据赋值给学生对象的成员变量
        Student s = new Student();
        s.setName(name);
        s.setAge(age);
        //集合中添加学生对象
        array.add(s);

    }
}
请输入学生姓名:
hah
请输入学生年龄
13
请输入学生姓名:
xkx
请输入学生年龄
14
请输入学生姓名:
adq
请输入学生年龄
12
hah,13
xkx,14
adq,12

6、
Alt+Ins 根据自己需要构造方法

2、继承

1、格式:public class 子类名 extends 父类名{}
2、继承的好处和弊端:

好处

  • 提高代码复用性(多个类相同的成员可以放到同一个类中)
  • 提高了代码的维护性(方法的代码需要修改,修改一处即可)

弊端

  • 继承让类之间产生了关系,削弱了子类的独立性
3、继承中变量的访问特点

在子类方法中访问一个变量

  • 子类局部范围找——>子类成员范围找--->父类成员范围找(如果都没有,则报错)
4、super关键字
public class Zi extends Fu {
    public int age = 20;
    public void show(){
        int age = 30;
        System.out.println(age);
        //访问本类的成员变量age
        System.out.println(this.age);
        //访问父类的成员变量age
        System.out.println(super.age);
    }
}


5、继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中无参的构造方法

  • 子类会继承父类中的数据,可能还会使用父类的数据,所以子类初始化之前,一定先完成父类数据的初始化
  • 每一个子类构造方法的第一条语句默认都是super

如果父类中没有无参构造方法,只有带参构造方法,怎么办?

  • 通过使用super关键字显示的调用父类的带参构造方法
  • 在父类中自己提供一个无参的构造方法(推荐
6、继承中访问成员方法的访问特点

通过子类对象访问一个方法、

  • 子类成员范围找
  • 父类成员范围找
  • 如果都没有则报错
7、方法重写

概述:

  • 子类中出现和父类一模一样二点方法声明

方法重写的应用:

  • 当子类需要父类的功能,而功能主体子类又有自己的内容十,可以重写父类中的方法,这样,既沿袭了父类的功能,有定义了子类特有的功能

@Override :帮助我们检查方法重写声明的正确性

  • 方法重写注意事项:

1、私有方法不能被重写(父类的私有成员子类是不能继承的)

==子类访问权限不能更低(public > 默认(就是直接void ,没有修饰符) > 私有) ==

8、Java中继承的注意事项
  • Java类只支持单继承,不支持多继承
  • Java类中支持多层继承
9、继承实例
public class Person {
    public String name;
    public String age;
    //无参构造
    public Person() {
    }
    //带参构造
    public Person(String name,String age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

public class Students extends Person{
    public Students(){
    }
    public Students(String name,String age){
        super(name,age); // 继承父类中的带参方法

    }
    public void Study(){
        System.out.println("我是学生,我爱学习!");
    }
}

3、修饰符

1、包

1、概述:就是文件夹,对类进行分类管理
2、定义格式 : package 包名.(多级包用.分开)

2、导包

使用不同包下的类时,简化带包的操作,使用import将其他包导入,并使用其他包下的类

  • 格式:import 包名
3、状态修饰符
  • final(最终态):可修饰成员方法,成员变量,类

  • 特点:

    1、修饰方法:表明该方法是最终方法,不能被重写

    2、修饰变量:表明该变量是常量,不能被再次赋值

    3、修饰类:表明该类是最终类,不能被继承

final修饰局部变量:
  • 变量是基本类型:final修饰指的是基本类型数据值不能发生改变

  • 变量是引用类型:final修饰指的是引用类型的地址值不能发生改变,但是地址值里面的内容是可以发生改变的

  • static(静态):可修饰成员方法,成员变量

  • 特点:

    1、被类的所有对象共享(这也是我们判断是否使用静态变量关键字的条件)

    2、可用通过类名调用,也能使用对象名进行调用(推荐使用类名调用)

public class Student01 {
    public String name;
    public int age ;
    public static String university; //

    public void show(){
        System.out.println(name + "," + age + "," + university);
    }

}

public class staticDemo {
    public static void main(String[] args) {
        Student01.university = "厦门大学";//直接用类中的参数进行赋值,直接通过类名访问,使得默认值为厦门大学

        Student01 s1 = new Student01();
        s1.name="lwb";
        s1.age=10;
        //s1.university="厦门大学";
        s1.show();

        Student01 s2 =new Student01();
        s2.name = "ljx";
        s2.age = 11;
        s2.show();
    }
}
输出
lwb,10,厦门大学
ljx,11,厦门大学

static 访问特点

非静态的成员方法:

  • 能访问静态的成员变量
  • 能访问非静态的成员变量
  • 能访问静态的成员方法
  • 能访问静态的成员方法

静态的成员方法:

  • 能访问静态的成员变量
  • 能访问静态的成员方法

静态成员只能访问静态成员

4、多态

1、同一个对象,在不同时刻表现出来的不同形态

猫 cat = new 猫();
也可以 动物 Animal = new 猫();

多态的前提和体现:

  • 有继承/实现关系
  • 有方法重写
  • 有父类引用指向子类对象
2、多态中成员的访问特点
package Test01;

public class Animal {
    public int age = 40;
    public void eat(){
        System.out.println("动物吃东西");
    }

}

package Test01;

public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playgame(){
        System.out.println("猫捉迷藏");
    }
}

package Test01;

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();

        System.out.println(a.age);
        a.eat();
        //a.playgame();  会报错,因为Animal中没有该方法


    }
}
输出
40
猫吃鱼
  • 成员方法:编译看左边,执行看右边
  • 成员变量:编译看左边,执行看左边

因为成员方法有重写,而成员变量没有

3、多态的好处和弊端
  • 好处:提高了程序的拓展性

具体体现:定义方法时,使用父类作为参数,将来在使用的时候,使用具体子类参与操作(多态只能访问共有的功能)

  • 弊端: 泵使用子类的特有功能
4、多态的转型
  • 向上转型
    从子到父
    父类引用指向子类对象
  • 向下转型
    从父到子
    父类引用转为子类对象
package Test01;

public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat(); //向上转型
        a.eat();
        ((Cat) a).playgame();//向下转型



    }
}

输出
猫吃鱼
猫捉迷藏

5、抽象类

1、概述

一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类

package Test_Abstract;

public abstract class Animal {//定义抽象类
    public abstract void eat();//定义抽象方法
}

2、抽象类的特点
  • 抽象类和抽象方法必须使用abstract关键字修饰

public **abstract** clss 类名{}
public **abstract** void 方法名();

  • 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类

  • 抽象类不能直接实例化

    ++可以参照多态的方式,通过子类对象实例化,这叫抽象类多态++

  • 抽象类的子类


要么重写抽象类中的所有抽象方法
要么是抽象类

3、抽象类的成员特点
  • 成员变量(可以是变量,也可以是常量)
  • 构造方法(有构造方法,但是不能实例化,构造方法用于子类访问父类数据的初始化)
  • 成员方法(可以有抽象方法:限定子类必须完成某些动作;也可以有非抽象方法:提高代码的复用性)

6、接口

1、概述:接口就是一种公用的规范,Java中的接口更多体现在对行为的抽象
2、特点
  • 接口用关键字interface修饰

public interface 接口名{}

  • 类实现接口用implements表示

public class 类名 implements 接口名{}

  • 接口不能实例化
  1. 接口参照多态的方式,通过实现类对象实例化,这叫接口多态
  2. 多态的形式:抽象类多态接口多态
  3. 多态的前提:有几成或者实现关系;有方法重写;有父类(类/接口)引用指向(子/实现)类对象
  • 接口的实现类

要么重写接口中的所有抽象方法
要么是抽象类

3、接口的成员特点
  • 成员变量
  1. 只能是常量
  2. 默认修饰符:public static final
  • 构造方法
  1. 接口没有构造方法,因为接口主要是对行为进行抽象的,是没有具体存在的
  2. 一个类如果没有父类,默认继承Object
  • 成员方法
  1. 只能是抽象方法
  2. 默认修饰符:public abstract
4、类和接口的关系
  • 类和类的关系

继承关系,只能单继承,但是可以多层继承

  • 类和接口的关系

实现关系,可以单实现,也可以多实现,还可以继承一个类的同时实现多个接口

  • 接口和接口的关系

继承关系,可以单继承,也可以多继承

5、抽象类和接口的区别
  • 成员区别
  1. 抽象类---->常量、变量;有构造方法,有抽象方法。也有非抽象方法
  2. 接口------>常量;抽象方法
  • 关系区别
  1. 类与类--------->继承、单继承
  2. 类与接口------->实现、可以单实现,也可以多实现
  3. 接口与接口----->继承,单继承,多继承
  • 设计理念的区别
  1. 抽象类---->对类抽象,包括属性、行为
  2. 接口------>对行为抽象,主要是行为
/*
门与报警器
*/
public abstract interface Jumpping {
    public abstract void Jump();
}

public  interface Alram{
    void alarm;
}
public abstract class Door(){
    public abstract void open();
    public abstract void close();

}
public class AkarnDoor extends Door implements Alarm{
    public void open(){//重写方法
        //...
    }
    public void close(){//重写方法
        //...
    }
    public void alram(){//重写方法
        //...
    }
}
6、类名作为形参和返回值
  • 方法的形参是类名,其实需要的是该类的对象
  • 方法的返回值是类名,其实返回的是该类的对象(需要进行声明对象)
7、接口名作为形参和返回值
  • 方法的形参是类名,其实需要的是该接口的对象
  • 方法的返回值是类名,其实返回的是该接口的对象(需要进行声明对象)

7、内部类

1、格式
public class 类名{
    修饰符 class 类名{
        
    }
}
2、访问特点
  • 内部类可以直接访问外部类的成员,包括私有
  • 外部类要访问内部类的成员,必须创建对象
3、成员内部类

按照内部类在类中定义的位置不同,可以分为一下两种形式

  • 在类的成员位置:成员内部类
  • 在类的局部位置:局部内部类
    成员内部类,外界如何创建对象使用呢?
  • 格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象
  • 范例:Outer.Inner oi = new Outer().new Inner(;
package InnerOutter;

public class Outer {
    private int num = 10;
    public class Inner{
        private void show(){
            System.out.println(num);
        }



    }
    public void method(){//通过外部类调用内部类方法来实现
        Inner i = new Inner();
        i.show();

    }
}


-----------------------------
package InnerOutter;

public class OuterTest {
    public static void main(String[] args) {
      /*  Outer.Inner oi = new Outer().new Inner();
        oi.show();*/

    Outer o = new Outer();
      o.method();

    }
}
输出
10
4、局部内部类

局部内部类是在方法中定义的类,所以外界是无法直接访问的,需要在方法内部创建对象并使用该类可以直接访问外部类的成员,也可以访问方法内的局部变量

package InnerOutter;

public class Outer {
    private int num = 10;

    public void method(){//通过外部类调用内部类方法来实现
        int num2 = 20;
        class Inner{
            public void show(){
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();

    }
}

------------------------------------
package InnerOutter;

public class OuterTest {
    public static void main(String[] args) {
      /*  Outer.Inner oi = new Outer().new Inner();
        oi.show();*/

        Outer o = new Outer();
        o.method();

    }
}
输出
10
20
5、匿名内部类(局部内部类特殊形式)
  • 格式
new 类名或接口名(){
    重写方法;
}

本质:是一个继承该类或者实现该接口的子类匿名对象

public interface Inter {
    void show();
}

-------------------------------
public class Outer {


    public void method(){//
        Inter i= new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");

            }
        };
        i.show(); // 调用show方法 

        }


    }
   -------------------- ---------
   package InnerOutter;

public class OuterTest {
    public static void main(String[] args) {
      /*  Outer.Inner oi = new Outer().new Inner();
        oi.show();*/

        Outer o = new Outer();
        o.method();

    }
}
输出
匿名内部类


6、匿名内部类在开发中的使用
package Inner;

public class Cat implements Jumpping {
    @Override
    public void junp() {
        System.out.println("我会跳高");
    }
}
----------------------------------
package Inner;

public interface Jumpping {
    void junp();
}
====================================
package Inner;

public class JumppingOperator {
    public void method(Jumpping j){
        j.junp();
    }
}

--------------------------------
package Inner;

public class TestDemo {
    public static void main(String[] args) {
        Jumpping j = new Cat();
        j.junp();
        JumppingOperator jo = new JumppingOperator();
        jo.method(j);

        jo.method(new Jumpping() {//直接通过接口实例化对象调用匿名对象类,不用每次都新建一个类
            @Override
            public void junp() {
                System.out.println("我也会跳高了");
            }
        });
    }
}
输出
我会跳高
我会跳高
我也会跳高了

8、API

1、Math

查看文档

2、System
package Math;


public class Math {
    public static void main(String[] args) {
        System.out.println("开始");
        System.exit(0);//中止当前Java虚拟机,非零表示异常
        System.out.println("结束");
        System.out.println(System.currentTimeMillis());//返回当前时间
    }
}

3、Object类中的toString()方法

看方法,选中方法,按下crtl+B

  • 建议子类重写object中的toString()方法

通过Alt+Ins中的toString()重写自动生成

4、Object类中的equals()方法
  • 建议子类重写object中的equals()方法

通过Alt+Ins中的equals()重写自动生成,把hashmap()方法删除即可

5、Integer 类的概述和使用
  • public static Integer valueOf(int i) 返回表示指定的int值的Integer实例
  • public static Integer valueOf(String s) 返回一个保存指定值的Integer对象String
package Inter;

public class InterDeno {
    public static void main(String[] args) {
        Integer i = Integer.valueOf(100);
        System.out.println(i);
        Integer i1 = Integer.valueOf("100");
        System.out.println(i1);
    }

}
输出
100
100
5、int和String 的相互转化
  • Int----->String

public static String valueOf​(int i) 静态方法(String中的方法)

  • String------->Int

public static int parseInt​(String s)静态方法(Integer类中的方法)

package Inter;

/*
int和String的转换
*/


public class InterDeno {
    public static void main(String[] args) {
        //Int----->String
        //方式1
        int number = 100;
        String s1 = ""+number;
        System.out.println(s1);
        //方式2 public static String valueOf​(int i) 静态方法
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("-----------------");


        //String------->Int
        String s3 ="100";
        //方式一 String----->Integer----->int
        Integer i = Integer.valueOf(s3);
        //public int intValue​()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt​(String s)静态方法
        int y = Integer.parseInt(s3);

    }

}

6、int和String 的相互转化(字符串转换案例)
package Inter;

import java.util.Arrays;

public class IntegerTest {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "91 27 46 38 50";
        //用空格获取每一个元素放在数组中
        String[] strArray = s.split(" ");
/*        for (int i= 0;i<strArray.length;i++){
            System.out.println(strArray[i]);

        }*/
        //定义一个int数组,把String[]数组中的每一个元素存储到int数组中
        int[] arr = new int[strArray.length];
        for (int i = 0;i<arr.length;i++){
            arr[i] = Integer.parseInt(strArray[i]);

        }
        //对数组进行排序
        Arrays.sort(arr);
        //把排序后的int数组中的元素进行拼接得到一个字符串,用StringBuilder实现
        StringBuilder sb = new StringBuilder();
        for (int i = 0;i<arr.length;i++){
            if(i == arr.length-1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i]).append(" ");
            }

        }
        String result = sb.toString();
        System.out.println(result);
    }

}
输出
27 38 46 50 91


6、自动拆箱和装箱
  • 装箱:把基本数据类型转换为对应的包装类类型
Integer i= Integer.valueOf(100);//手动装箱
Integer ii = 100;//自动装箱
  • 拆箱:把包装类类型转化为对应的基本数据类型
ii = ii.valueOf()+200;//手动装箱
ii += 200;//自动装箱 和上面语句一样结果
//i = i+200;i+200自动拆箱;i = i+200;自动装箱

在使用包装类类型的时候,如果做操作,最好先判断是否为null,只要是对象,在使用前就必须进行不为null的判断

4、Date
1、SimpleDateFormat
  • y
  • M
  • d
  • H
  • m
  • s
2、SimpleDateFormat格式化和解析日期
  • 格式化(从Date到String)

public final String format(Date date):将日期格式化成日期/时间字符串

  • 解析(从String到Date)

public Date parse(String source):从给定字符串的开始解析文本以生成日期

package Date;

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


public class DateDemo {
    public static void main(String[] args) throws ParseException {
        Date d1 = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        String s = sdf.format(d1);
        System.out.println(s);

        String s1 = "2020-03-16 11:11:11";
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date p  = sdf1.parse(s1);
        System.out.println(p);


    }
}
输出
2020年03月16日 16时16分33秒
Mon Mar 16 11:11:11 CST 2020

3、日期工具类案例
  • 需求:定义一个工具类DateUtils,包含两个方法,把日期转换为指定格式的字符串;把字符串解析为指定格式的日期,在测试类中调用实现
package Date;

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

public class DateUtils {
    public DateUtils() {
    }

    public static String dateToString(Date date, String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);//按照传入格式创建对象
        String s = sdf.format(date); // 把传入的日期转化成指定格式的字符串

        return s;

    }
    public static Date stringToDater(String s, String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date p = sdf.parse(s); //Artl+Enter创建抛出异常
        return p;

    }
}

//测试类
package Date;

import java.text.ParseException;
import java.util.Date;


public class DateDemo {
    public static void main(String[] args) throws ParseException {
        Date d1 = new Date();
        String s1 =DateUtils.dateToString(d1,"yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

        String s2= DateUtils.dateToString(d1, "yyyy年MM月dd日");
        System.out.println(s2);
        System.out.println("--------------");

        String s = "2012-01-01 12:12:12";
        Date date = DateUtils.stringToDater(s, "yyyy-MM-dd HH:mm:ss");
        System.out.println(date);

    }
}

输出
2020年03月16日 16:40:00
2020年03月16日
--------------
Sun Jan 01 12:12:12 CST 2012

4、Calendar类

Calendar rightNow = Calendar.getlnstance();getlnstance()获取Calendar对象,其日历字段已使用当前日期和时间初始化

package Calendar;
import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        int i = c.get(Calendar.YEAR);
        int i1 = c.get(Calendar.MONTH) + 1;
        int i2 = c.get(Calendar.DATE);
        System.out.println(i+"年"+i1+"月");

    }
}
输出
2020年3月16日
5、Calendar类中的add,set方法
package Calendar;
import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        int i = c.get(Calendar.YEAR);
        int i1 = c.get(Calendar.MONTH) + 1;
        int i2 = c.get(Calendar.DATE);
        System.out.println(i+"年"+i1+"月"+i2+"日");

        System.out.println("-------------");
        c.add(Calendar.YEAR,-3);// .add(int field,int amount)将指定的时间量加上或减去给定的日历字段
        int k = c.get(Calendar.YEAR);
        int k1 = c.get(Calendar.MONTH) + 1;
        int k2 = c.get(Calendar.DATE);
        System.out.println(k+"年"+k1+"月"+k2+"日");

        System.out.println("-------------");
        c.set(2058,11,11);// .set(int year,int month,int day)设置当前的年日月
        int l = c.get(Calendar.YEAR);
        int l1 = c.get(Calendar.MONTH) + 1; //月是从0开始算起的
        int l2 = c.get(Calendar.DATE);
        System.out.println(l+"年"+l1+"月"+l2+"日");

    }
}

输出
2020年3月16日
-------------
2017年3月16日
-------------
2058年12月11日

5、Calendar类案例分析(计算二月天数)
package Calendar;


import java.util.Calendar;
import java.util.Scanner;

public class Cal {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要查询的年份:");
        int year = sc.nextInt();

        Calendar c = Calendar.getInstance();
        c.set(year,2,1);
        c.add(Calendar.DATE,-1);
        int date = c.get(Calendar.DATE);
        System.out.println(year+"年的二月份有"+date+"天");
    }
}

输出
请输入你要查询的年份:
2048
2048年的二月份有29天

posted @ 2020-03-16 21:17  DansLv  阅读(150)  评论(0编辑  收藏  举报