Java基础（一）

计算机语言与编程概述

什么是计算机语言?

生活中的两个人的交流主要是方式无非是采用一种都能够识别的语言，那么也就是说该语言是他们之间传递信息的媒介

计算机语言是指用于人与计算机之间通讯的一种特殊语言，是人与计算机之间传递信息的媒介。

 

那计算机怎么能读懂我们给它发出的的信息呢？

此时就需要编写一套由字符、数字所组成并按照某种语法格式的一串串计算机指令，而这些计算机指令就是计算机语言。软件就是由若干条计算机指令所组成的。

 

计算机语言分类:

 

机器语言：直接用二进制指令表达，指令是用0和1组成的一串代码，它们有一定的位数，并分成若干段，各段的编码表示不同的含义（如0000 代表 加载（LOAD）,0001 代表 存储（STORE））。

 

汇编语言：使用一些特殊的符号来代替机器语言的二进制码(又称符号语言)，计算机不能直接识别，需要用一种软件将汇编语言翻译成机器语言，汇编语言依赖于硬件体系，开发难度大（如加法指令ADD/ADC、减法指令SUB/SBB）。

 

高级语言：使用一定格式的自然语言进行编写源代码，通过编译器将源代码翻译成计算机直接识别的机器语言，之后再由计算机执行，不直接操作硬件，把繁琐的翻译操作交给编译器完成。

 

我们将学习的Java就属于高级语言范畴。

 

 

什么是编程:

前面说了计算机语言就是用来实现人和计算机通讯的，那为什么人要和计算机通讯呢，其原因就是为了让计算机帮我们完成一些人为起来比较复杂的工作。那计算机怎么知道我们要它解决的问题是什么，怎么知道解决问题的具体的步骤是什么呢？此时我们就得通过编程语言去告诉计算机去，做什么，怎么做。这种人和计算机之间交流的过程，我们称之为编程。

 

1.1、什么是Java,Java得特性?

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，

因此Java语言具有功能强大和简单易用两个特征。

Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。

Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。

Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等

Java的发展过程

1996年1月，Sun公司发布了Java的第一个开发工具包（JDK 1.0）

1997年2月，JDK 1.1面世

1998年12月8日，第二代Java平台的企业版J2EE发布。

1999年6月，Sun公司发布了第二代Java平台（简称为Java2）的3个版本：

J2ME（Java2 Micro Edition，Java2平台的微型版），应用于移动、无线及有限资源的环境；

J2SE（Java 2 Standard Edition，Java 2平台的标准版），应用于桌面环境；

J2EE（Java 2Enterprise Edition，Java 2平台的企业版），应用于基于Java的应用服务器。

Java 2平台的发布，是Java发展过程中最重要的一个里程碑，标志着Java的应用开始普及

1999年4月27日，HotSpot虚拟机发布。

HotSpot虚拟机发布时是作为JDK 1.2的附加程序提供的，

后来它成为了JDK 1.3及之后所有版本的Sun JDK的默认虚拟机

2000年5月，JDK1.3、JDK1.4和J2SE1.3相继发布，几周后其获得了Apple公司Mac OS X的工业标准的支持。

 

 

2001年9月24日，J2EE1.3发布。

2002年2月26日，J2SE1.4发布。

自此Java的计算能力有了大幅提升

2004年9月30日，J2SE1.5发布，成为Java语言发展史上的又一里程碑。

为了表示该版本的重要性，J2SE 1.5更名为Java SE 5.0

2005年6月，在Java One大会上，Sun公司发布了Java SE 6。此时，

Java的各种版本已经更名，已取消其中的数字2，

如J2EE更名为JavaEE，J2SE更名为JavaSE，J2ME更名为JavaME

2006年11月13日，Java技术的发明者Sun公司宣布从2007年3月起，全世界所有的开发人员均可对Java源代码进行修改

2009年，甲骨文公司宣布收购Sun 。

2010年，Java编程语言的共同创始人之一詹姆斯·高斯林从Oracle公司辞职。

2011年，甲骨文公司举行了全球性的活动，以庆祝Java7的推出，随后Java7正式发布。

2014年，甲骨文公司发布了Java8正式版

 

1.2、什么是JDK和什么是JRE?

 

JRE(Java Runtime Environment)：Java运行环境，如果要运行Java程序，就需要JRE的支持，JRE里包含JVM。

JDK(Java Development Kit)：Java开发工具，包含开发Java程序的所有工具,如javac和java等，JDK里包含JRE。

 

Java虚拟机（Java Virtual Machine），简称JVM，它是运行所有Java程序的虚拟计算机，好比是街机游戏的模拟器。

JVM是Java语言的运行环境，也是Java 最具吸引力的特性之一。JVM用于读取并处理编译过的与平台无关的字节码(class)文件，从而实现Java的可移植性。但是值得注意的是Java虚拟机是不跨平台的。也就是说在Win下得装Win版的JVM，在Linux下装Linux版的JVM。

见图:选择不同平台的JDK版本

 

JVM是Java程序的解释和执行器。

1.3、JDK的版本

但由于JDK包含了许多与运行无关的内容，占用的空间较大，因此运行普通的Java程序无须安装JDK，

而只需要安装JRE即可

JDK由最初得 1.0开始发展到如今的1.8

1.x代表得是公司的内版本号, 1代表主版本号,x代表次版本号,每次 次版本号得增加都是对前版本号得一种更新,使用户得体验度提升 (应用版本号),

像5.0,6.0这样得是发布版本号,有些时候也是我们开发者俗称得版本

 

1.4、Java体系

Java得体系

Java SE  Java标准版本,Java得核心语法,是Java EE和 Java ME得基础

Java EE  Java企业版本, JSP servlet等,其中有最经典得是三大框架 SSH Struts Spring hibernate

Java ME Java嵌入式版本, 移动平台软件产品得开发,像早期得诺基亚 塞班系统, 不过现在已经过时了

 

1.5、Java的跨平台性

writer onec run anywhere 一处编译,到处运行!

一份代码可以在不用平台所运行,这就是Java得跨平台性

Java源文件--编译-->Java字节码(可跨平台)--运行-->JVM Java虚拟机-->多个平台

在这里的跨平台指的是不同版本的虚拟机

Java 关键字

关键字:在编程语言中有一些事先定义的，有着特殊含义和用途的单词。

保留字:和关键字一样都是编程语言事先定义好的，只是说现在暂时没有特殊的用途，但说不定以后某天会突然被赋予意义和被使用到，因此被保留下来的单词，goto和const就是Java的保留字。

看图;

注意关键字和保留字都是由小写组成，关键字不要去记，我们学一个记一个。

 

注意：java 无sizeof 、goto、 const 关键字

 

标识符:

在写代码的时候为了增强代码的阅读性会自定义很多名字，比如：类名，方法名，变量名等。

在编程的里我们把这种为了增强程序阅读性而自定义的名称,称为标识符。

标识符命名规则：

①　由字母、数字、下划线、$组成，但不能以数字开头（注：此处的字母可以是中文、日文等）。

②　大小写敏感。

③　不得使用java中的关键字和保留字。

④　不用Java中内置的类名作为自己的类名。

其实，大家也没必要记这么多，使用一个非关键字和保留字的有意义的英文单词就很OK了。

                  注意问题:类名首字符规范是大写的.

 

九、变量和常量的定义及初始化

 

变量：表示存储空间，可用来存放某一类型的常量，没有固定值，并可以重复使用，也可以用来存储某种类型的数据。

变量的特点：

①　占据着内存中的某一块存储区域；

②　该区域有自己的名称（变量名）和类型（数据类型）；

③　可以被重复使用;

④　该区域的数据可以在同一类型范围内不断变化；

变量的定义：

先定义变量,再赋值:

数据类型  变量名;

变量名 = 值;

或在声明时同时赋值:

数据类型  变量名  =  初始化值；

 

【案例】

 

class VariableDemo {

int b = 20;//无法访问只能定义成static 修饰的

static int c = 20;

public static void main(String[] args)

{

/*

变量分类-作用域-使用规则:

变量的分类:

随着变量定义在类中的位置不同，故把变量分成两大类：

成员变量(全局变量)：直接定义在类里的变量，又称为全局变量或字段。

局部变量：变量除了成员变量之外，其他就是局部变量。根据定义的位置不同有3种表现形式：方法形参，方法内变量，代码块变量。

 

变量作用域:

指变量的存在范围，只有在这个范围内，程序代码才能访问它。当一个变量被定义时,它的作用域就确定了:

作用域是定义开始到定义所在的花括号结束;

 

变量使用规则:

1．变量必须先声明，并且初始化后才能使用；

2．声明变量必须有数据类型

3．同一作用域内变量名不能重复定义

 

*/

int a;

a = 10;

System.out.println(a);

a = 20;

System.out.println(a);

//System.out.println(b);

System.out.println(c);

}

}

• Java的数据类型
• 

 

本数据类型/原生数据类型,共8个:

            1>:数值型:

                 整数类型:byte,short,int,long,

                    不同的整数类型在内存占用的内存空间大小是不一样的.

                    小数类型:float,double.

            2>:字符型:char,什么是字符,字母/符号.

            3>:布尔型:boolean,表示对与错.true,false.

Java中数据类型特别说明:

浮点型在计算机底层，使用的是科学计数法来进行存储的.

1234.89==>1.23489*10(3)(书本上)==>1.23489E3

注意：

1、小数默认是double型      

2、显示的结果分为：

     ①数据小，显示本身的数值                             

     ②数据大，显示科学计数法的结果。

3、浮点数在底层，使用近似值来表示，不适用于在银行、电信领域存储金额。

（使用BigDecimal来存储小数，小数点后精确到的位数可以任意定制）    

4、同字节的浮点数较之于同字节的整数或者是比起字节数多的整数，能够存储更多更大的数值。

字符型说明    

语法：char 变量 = '单个字符';

char ch1 = 'a';

System.out.println(ch1);

char ch2 = 97;

System.out.println(ch2);

char ch3 = '\u0061';

System.out.println(ch3);

特点：

1、单个字符:个数是1，包括：汉字，英文字母，特殊的符号;        

2、不允许什么都没有         

3、采用的字符集是unicode,该字符集的特点是：任何字符都占用2个字节。  

字符集(编码)：将语言文字与计算机底层表示的数值建立映射关系的二维表。

计算机只能表示0和1两个数，于是人们做规定使用一个数字去表示一个特定的字符，比如a使用97表示。('\U0000'～'\UFFFF')  

常用的字符集：

  ascii:a～ｚ　A～Z   0～9

  'a'-->97  'A'-->65  '0'-->48    

 gb2312:简体中文  gbk:简体、繁体中文

 gb18030:简体、繁体、生僻的汉字iso-8859-1:西文字符集

 

Ps：String是一个类，表示字符串（后面详讲），所谓字符串，就是一串字符，也就是N个字符连接在一起（N可以表示0或多个），好比羊肉串。

字符串都得使用 "" 括起来的，连接字符串使用 “+”符号。 +相当于拼接符号

 

Java中的数据类型转换

 

在8大基本数据类型中,boolean不属于数值类型,不参与转换.

---------------------------------------------------------------------------------------

转换规则其实就是各自数据类型的空间大小.看图

 

把不同的数据类型看出是不同容量的容器.

byte是1个字节,最多只能装1斤水.

short是2个字节,最多只能装2斤水.

自动类型转换:

把小数据范围类型的数值或变量赋给另一个大数据范围类型变量，系统可以完成自动类型转型。这好比把装一斤水容器里的水倒进可以装两斤水的容器里一样。

再次强调:boolean 类型是不可以转换为其他数据类型。

。

 如：int age = 34;

     long age2 = age;//long age2 = 45;

注意：1、byte、short、char类型的变量进行运算时，首先会自动提升为int型，然后，参与运算。    

8.3.2、整型数值默认的类型是int。      

8.3.3、单精度的浮点数进行运算时，不会自动提升为double。

 

强制类型转

当把大范围类型的数值或变量赋给另一个小范围类型变量时，此时系统不能自动完成转换，需要加上强制转换符，但这样的操作可能造成数据精度的降低或溢出，所以使用时要格外注意。

这就好比把装两斤水容器里的水倒在可以装一斤水的容器里，是可能造成水溢出的。

若要坚持把4斤苹果塞进一个装3斤的袋子里，我们要怎么办？动用暴力。

强制类型转换，可能造成溢出和精度损失。

语法：

取值范围较小的类型  变量名 = (取值范围较小的类型)取值范围较大的变量或者是值;

如：int age = 56;

byte ageTmp = (byte)age;

【案例】

class TypeConverDemo {

public static void main(String[] args) {

//①自动类型转换 。 int age = 34;

long age2 = age;

byte num1=2;

byte num2 = 4;

//byte sum = num1 + num2;//错误: 可能损失精度

int sum = num1 + num2 + '男';

float x = 3.45F;

float y = 4.56f;

float sum2 = 1+'女'+x + y;

//②强制类型转换

age = 56;

        //byte ageTmp = age;//TypeChangeDemo.java:21: 错误: 可能损失精度

//byte ageTmp = (byte)age;

//byte ageTmp = 56;//56是常量值，在byte的取值范围-128～127之内

byte ageTmp = (byte)156;

System.out.println("ageTmp = "+ageTmp);

}

 

 

}

十一、Java的运算符

算数运算符:+  -  *  /  %

加号：在操作数值、字符、字符串时其结果是不同的，当两个字符相加得到的是ASCII码表值，

当两个字符串相加时表示将两个字符串连接在一起，从而组成新的字符串。

除号：整数在使用除号操作时，得到的结果仍为整数（小数部分忽略），当整数除以0的时候，会引发算术异常。

             正无穷大(Infinity):当一个正浮点类型数除以0时,或者正整数除以0.0时;

              负无穷大(-Infinity):当一个负浮点类型数除以0时,或者负整数除以0.0时;

              NaN(Not a Number):当0.0除以0.0时;

取模(求余数)：模数的符号忽略不计，结果的正负取决于被模数.

注意：无穷大和NaN都属于double浮点类型,但是所有正无穷大都是相等的,所有负无穷大也是相等的,NaN永远不相等,也不等于自己.

= 赋值运算符

等号的左边可以是变量或是常量

等号的右边可以变量,常量,表达式

关系运算符 > >= < <= == !=

逻辑运算符 && || !

• Java分支

输入三个不等数，按从小到大顺序输出(交换)

      int a;

      int b;

      int c;

      int tmp = 0;

      Scanner input = new Scanner(System.in);

      a = input.nextInt();

      b = input.nextInt();

      c = input.nextInt();

    //比较的方法

    if(a<b&&a<c&&b<c){

         System.out.println(a+" "+b+" "+c);

    }

    if (a<b && a<c && c<b) {

         System.out.println(a+" "+c+" "+b);

    }

    if(b<a && b<c && a<c){

        System.out.println(b+" "+a+" "+c);

    }

    if (b<a && b<c && c<a) {

        System.out.println(b+" "+c+" "+a);

    }

    if (c<a && c<b && a<b) {

         System.out.println(c+" "+a+" "+b);

    }

    if(c<a && c<b && b<a){

        System.out.println(c+" "+b+" "+a);

    }

      //交换的方法

          if(a>b){

          tmp = a;

          a = b;

          b = tmp;

      }

     

      if (a>c) {

          tmp = a;

          a = c;

          c = tmp;

      }

      

      if (b>c) {

          tmp = b;

          b = c;

          c = tmp;

      }

      System.out.println(a+" "+b+" "+c);

写一个程序，判断某一年是否为闰年（被4整除但不能被100整除能被400整除)是闰年:2000 平年:1999

         int year;

     Scanner input = new Scanner(System.in);

      year = input.nextInt();

      if((year%4==0 && year%100!=0) || (year%400==0)) {

           System.out.println("是闰年");

      }else{

    System.out.println("不是闰年");

    

      }

条件运算符 ?:(三目运算符，三元运算符)

    表达式1?表达式2:表达式3

    执行过程:首先会执行表达式1,判断表达式1的值,

    如果值为真,那么就型值表达式2,并把表达式2的值作为整个表达式的值,

    如果表达式1的值为假,那么就执行表达式3,并把表达式3的值作为整个表达式的值

     【案例】

      int a;

      int b;

      int c;

      int tmp = 0;

      Scanner input = new Scanner(System.in);

      a = input.nextInt();

      b = input.nextInt();

      c = input.nextInt();

      tmp = a > b ? a:b;

      tmp = tmp > c ? tmp:c;

      System.out.println(tmp);

 

ps:Java中的三目运算符,后面两个参数不能是输出语句,必须是带有返回值参数

 

给出一个百分制成绩，

要求输出成绩等级’A’、’B’、’C’、’D’、’E’。

90分以上输出’A’，

80～89分输出’B’，

70～79分输出’C’，

60～69分输出’D’，

60分以下 输出’E’

       int fs;

       Scanner input = new Scanner(System.in);

       fs = input.nextInt();

       if (fs>=90 && fs<=100) {

        System.out.println("A");

        }else if (fs>=80 ){

         System.out.println("B");

        }else if (fs>=70){

         System.out.println("C");

        }else if(fs >= 60){

         System.out.println("D");

        }else{

         System.out.println("E");

        }

   }

1. 输入一个时间，输出它的下一秒时间。
   20:39:40 -->20:39:41
   20:39:59 -->20:40:00
   20:59:59 -->21:00:00
   23:59:59 -->00:00:00
   */
   //String[] strs = split(":");//拆分字符串
   Scanner input = new Scanner(System.in);
   System.out.println("请输入小时:");
   int h = input.nextInt();
   System.out.println("请输入分钟:");
   int m = input.nextInt();
   System.out.println("请输入秒:");
   int s = input.nextInt();
   //当s获取到数据的时候,时间已将输入完成了
   //秒自增
   //典型的if-else 嵌套
   s++;
   if(s == 60){ //当前秒等于60时候 需要清零
   s = 0; //清零
   //秒清零就意味着 分钟需要+1
   m++;
   if(m == 60){//当当前分钟等于60时候 需要清零
   m = 0; //清零
   //分钟清零意味着 小时需要+1
   h++;
   if(h == 24){
   //当小时到达24 需要清零
   h = 0;
   }
   }
   } S
   system.out.println(h+":"+m+":"+s); 

 

/*
14.输入一个日期，输出这一天是这一年的第几天，考虑平年闰年
输入:2000-1-1 输出1天
输入:2000-12-31 输出366天
2000-5 -1 ---> 4 +3+ 2+1+day
month - 1 不知道之前过完多少个月了
//如何累加其他月份天数 贯穿
*/
Scanner input = new Scanner(System.in);
System.out.println("请输入年:");
int year = input.nextInt();
System.out.println("请输入月:");
int month = input.nextInt();
System.out.println("请输入日:");
int day = input.nextInt();
//逻辑处理 获取当前月份之前过完的月份有几个月
//2000-1-1
switch (month - 1){
case 11:
day += 30; //当前天数+当前月的天数 --> 做了累加
case 10:
day += 31;
case 9:
day += 30;
case 8:
day += 31;
case 7:
day += 31;
case 6:
day += 30;
case 5:
day += 31;
case 4:
day += 30;
case 3:
day += 31;
case 2:
//if是可以嵌套,所有的分支都可以互相嵌套
if((year%4 == 0 && year%100 != 0) || (year%400 == 0)){
//闰年
day += 29;
}else{
day += 28;
}
case 1:
day += 31;
System.out.println("第"+day+"天");
break;
default: //默认就是1月的天数
System.out.println("第"+day+"天");
break;
}
}
} 

打印100以内所有的奇数，偶数和3的倍数（不包括100）

    

    //循环变量赋初值

    int i = 1;

    while (i<100) {//循环条件

        if(i%2==1){

           System.out.println(“奇数:”+i);

        }

        if(i%2==0){

           System.out.println(“偶数:”+i);

        }

        if (i%3==0) {

           System.out.println(“3的倍数:”+i);

        }

        //循环变量的自增

        i++;

}

 

求1!+2!+3!和

public static void main(String[] args) {

  Scanner input = new Scanner(System.in);

//输入一个数

  int n = input.nextInt();

    //累加

    int sum = 0;

    //阶乘

    int num = 1;

    //循环变量赋初值

    int i = 1;

    do {

        //1!+2!+3!=1*1+1*2+1*2*3+1*2*3*4

        //先求出阶乘

        num = num * i;//2

        //求和

        sum = sum + num;//3

        //循环变量的自增

        i++;

    } while (i<=n);//循环条件

    //打印结果

    System.out.println("sum="+sum);

}

 

for循环的6种写法

public static void main(String[] args) {

 Scanner input = new Scanner(System.in);

   //1.标准写法

    for(int i = 0;i<10;i++){

        System.out.println(i);

    }

    //2.表达式1可以省略,但是要在外部声明

    int i = 0;

    for(;i<10;i++){

     System.out.println(i);

    }

    //3.表达式2可以省略,但是是死循环

    for(int i = 0;;i++){

      System.out.println(i);

    }

    //4.表达式3可以省略,但是要声明在循环内部

    for(int i = 0;i<10;){

      System.out.println(i);

        i++;

    }

     //5.表达式1,3可以省略,但是要声明在循环的外部和内部

    int i = 0;

    for(;i<10;){

      System.out.println(i);

        i++;

    } //while

    //6.三个表达式都省略,死循环

    int i = 0;

    for(;;){

        System.out.println(i);

        i++;

    }

打印输出乘法口诀表(直角三角形) 

for(int i = 1; i<=9;i++){
for (int j = 1;j<=i ;j++ ){
System.out.print(j+"*"+i+"="+i*j);
}
System.out.println();
} 

输入一个数，打印下述图形
输入5
打印
    ABBBB
   AABBB
  AAABB
 AAAAB
AAAAA 

 

char chA = 'A';
char chB = 'B';
char chS = ' ';
//有行数
int n4 = 10;
//打印行
for(int i = 0;i<n4;i++){
//先打印空格
for(int j = 1; j<n4-i;j++){// 1 1<5-4
System.out.print(chS);
} /
/打印A
for(int k = 0;k<=i;k++){
System.out.print(chA);
}
//先打印B
for(int j = 1; j<n4-i;j++){// 1 1<5-4
System.out.print(chB);
}
ystem.out.println();//换行
} 

解释一下方法:

public class calendar{

 

public static void main(String[] args) {

   //ctrl+s进行代码保存

//ctrl+F11 运行

//1.提示用户输入

Scanner input  = new Scanner(System.in);

        System.out.println("请输入年:");

        int year = input.nextInt();

        System.out.println("请输入月份:");

        int month = input.nextInt();

        //2.年份天数+月份天数  = 总天数

        int totalDaysY = getFormNowYearTo1900TotalDays(year);

        int totalDaysM = getNowYearToDays(year, month);

        //3.得到星期数

        //求余范围是0-6 即从星期天(0) 开始 到 星期六(6)结束

        int week = (totalDaysM+totalDaysY+1)%7;

        //4.格式化输出

        FormatCalendar(week, year, month);

}

/**

 * 格式化日历输出

 * @param week  第一天是星期几

 * @param year   当前年份

 * @param month  当前月份

 */

 public static void FormatCalendar(int week,int year,int month) {

  //统计计数 逢7换行

 int cut = 0;

 //表头

 System.out.println("星期日\t\t星期一\t\t星期二\t\t星期三\t\t星期四\t\t星期五\t\t星期六\t\t");

 //打印星期数

 for(int i = 1 ;i<=week;i++) {

 System.out.print("\t\t");

 cut++;

 }

 //打印日历天数

 for(int i =1;i<=getNowMonthDays(year, month);i++) {

 //打印值

 System.out.print(i+"\t\t");

 cut++;

 if(cut%7 == 0) {

 System.out.println();

 }

 }

 

 

 }

 

 /**

  * 判断闰年

  * @param year 传入的年 整数

  * @return  true 是润年  false 润年

  */

 public static boolean isLeapYear(int year) {

 return (year%4==0 && year%100!=0)||(year%400==0);

 }

 /**

  * 通过月份当前天数

  * @param year 对应的年

  * @param month 对应的月

  * @return  月份所对应的概念书

  */

 public static int getNowMonthDays(int year,int month) {

   switch(month) {

   case 2:

   return isLeapYear(year) ? 29 : 28;

   case 4:    

   case 6:    

   case 9:    

   case 11:  

   return 30;

    default:

     return 31;

   

   }

 

 }

 /**

  * 当前年份距离1900年的总天数

  * @param year 当前年份

  * @return  总天数

  */

 public static int getFormNowYearTo1900TotalDays(int year) {

 //定义变量存储总天数

 int sum = 0;

 for(int i = 1900 ;i<year;i++) {

  sum += isLeapYear(i) ? 366 : 365;

 }

 return sum;

 }

 /**

  * 当前月份距离1月1日的总天数

  * @param year  当前年份

  * @param month  当前月份

  * @return 总天数

  */

 public static int getNowYearToDays(int year,int month) {

 //总天数

 int totalDays = 0;

 //统计当前月份距离1月1日的总天数

 for(int i = 1; i<month;i++) {

totalDays +=  getNowMonthDays(year, i);

 }

 return totalDays;

 

 }

 

 

}