标签：Java int System 第一次 newdata year date 随笔 public
经过两个月对于Java语言的学习，我认为有必要总结一下学习成果。下面是我近期学习的内容和对题目集的理解，以及对测试点的踩坑心得。
在学习Java语言的初期，在我看来Java语言的基本语法和C语言差不多，Java语言和C语言在很多方面的语法很相似，比如说循环语句，条件语句等。但是Java语言和C语言也有着不一样的地方，比如说在输入和输出是，c的输入方法是调用scanf（）在括号中输入内容完成对变量的赋值，c的输出方法是调用printf（），在括号里面输入%d,%f,%c,%s等来输出整数型数字，浮点数，字符以及字符串等。尤其要注意的是，c在输入和输出的过程中要特别在逗号后面声明变量的地址，否则语法上不通过。在Java语言中您可以简单地使用System.out.println(); 或System.out.print(); 或System.out.print()将输出发送到标准输出（屏幕）。
示例：
class Main {
public static void main(String[] args) {
System.out.println("Java programming is interesting.");
}
}
关于println()，print()和printf()之间的区别
print() - 它在引号内打印字符串。
println() - 它在引号内打印字符串，类似于print()方法，相当于在print() 方法中加入了一个换行符。
printf() -格式化输出括号中的内容，于C中的printf（）方法相似。
Java中的输入方法和C有很大的区别，首先Java语言输入之前要先加入一个包，import java.util.Scanner;来使我们可以创建Scanner对象，
Scanner input=new Scanner(System.in);
在创建完对象之后我们可以进行输入。
Int a=input.nextInt();
double a=input.nextDouble();
示例：
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println(“请输入一个整数”)
int x=input.nextInt();
System.out.println(“您输入的整数为”+x)；
}
}
需要注意的是在输入不同类型的数据时要采用不同的输入类型，输入浮点数是采用input.nextFloat或者input.nextDouble。输入字符类型时可以用Input.next()或者Input.nextLine()。
在学习面向对象的过程中，对象的创建对我认知的冲击比较大，我们在创建对象的时候要考虑的两个方面：对象的属性和方法。这样说比较晦涩难懂，我举一个简单的例子，假如我们现在要创建一个“学生”的类，那么这个学生类里面应该要包括这个学生的学号，姓名等，这些称之为属性。学生要运动，要吃饭，要回答问题，这些学生的行为我们称之为方法。也就是说在对象中对象的基本信息就是属性，对象的行为称之为方法。
我们知道Java语言是面向对象的程序设计，其包括了三大基本要素：封装，继承以及多态。下面我来简单介绍一下这三个特征。
首先关于封装性，我们都知道在c语言中有一个神奇的东西叫做指针，它里面承载了内存地址，我们可以通过指针来便捷的访问和更改某一处数据，但是这就存在了一定的安全隐患。我们可以想一下，如果任何人都可以随意的更改数据，那么这个程序一定是不安全的。于是在Java语言设计时就有了这么一种性质，封装性。
在面向对象程序设计的过程中，我们要创建对象，在对象内部我们引用关键词private来对属性进行封装，private的意思是私有的，也就是说在对象外部，我们并不能直接访问这个属性，而是要通过对象内部的方法来进行访问或是更改。
例如：
class Year{
private int y;
public Year(int y) {
this.y = y;
}
public Year() {
}
public int getY() {
return y;
}
}
我们用年份举例，上面我们有一个类表示年。在这个类之中我们的y属性是私有的，于是在对象外部我们就不能直接访问这个属性，而是要通过get和set方法来进行访问或更改。
其次关于继承，继承的关键词为extends。其中包括子类和父类。子类又可以称为派生类。父类又可以称为超类（Super Class），要注意的是在Java语言中只能实现单继承，就是说一个类只能有一个父类。
我们举一个继承的例子：
class Person{//父类
private String name;
private int age;
public void setName(String name){
this.name=name;
}
public void setAge(int age){
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}
class Student extends Person{ //Student类继承了Person类
private String school; //子类扩充属性
//子类扩充方法
public void setSchool(String school){
this.school=school;
}
public String getSchool(){
return this.school;
}
}
在上面的例子中我们有一个Person类，Student类继承了Person类，同时也代表这Student类继承了Person类中public方法（注意私有的属性是无法继承的）。
要注意的是当子类方法和父类方法名字一样时，子类中的方法会覆盖父类中的方法，称之为方法的重载。
最后关于多态，多态中涉及到的几个概念，向上转型和向下转型，向上转型。是子类型转到父类型，向下转型是父类型转到子类型，无论是向上转型还是向下转型，两种类型之间必须有继承关系，否则编译器无法通过。下面举个动物类的例子
Class Animal{
Public void move(){
System.out.print(“动物在移动”)
}
}
Class Cat extend Animal {
Public void move(){
System.out.print(“猫在走猫步”)
}
}
Class Bird extend Animal {
Public void move(){
System.out.print(“鸟在飞”)
}
}
以下语句是正确的
Animal a = new Cat（）；
只是一个向上转型的例子，Animal和Cat存在继承关系。 Java中存在这样的语法，父类型的引用指向子类型的对象。
1. Java程序永远都分为编译阶段和运行阶段。
2.先分析编译阶段，再分析运行阶段，编译阶段无法通过，则程序无法运行。
3.编译阶段编译器检查a这个引用的数据类型为Animal,由于animal class中move 这个方法,所以编译通过了。这个过程我们称之为静态绑定或者编译阶段绑定,只有静态绑定成功之后才有后续的运行。
4.在程序运行阶段。JVA对于内存当中真实创建的对象是cat对象。那么程序运行阶段一定会调用cat对象里的move方法。此时发生了程序的动态绑定即运行阶段绑定。
5.父类型引用指向子类型应用这种机制导致的程序。存在编译阶段和运行阶段两种不同的形态或状态。这种机制可以称为一种多态机制。
以上是前端时间对知识点的简单概阔，下面分析在习题中所遇到的问题
这是一个关于日期计算的问题
1.参考题目集二中和日期相关的程序，设计一个类DateUtil，该类有三个私有属性year、month、day（均为整型数），其中，year∈[1820,2020] ,month∈[1,12] ,day∈[1,31] , 除了创建该类的构造方法、属性的getter及setter方法外，需要编写如下方法：
public boolean checkInputValidity();//检测输入的年、月、日是否合法
public boolean isLeapYear(int year);//判断year是否为闰年
public DateUtil getNextNDays(int n);//取得year-month-day的下n天日期
public DateUtil getPreviousNDays(int n);//取得year-month-day的前n天日期
public boolean compareDates(DateUtil date);//比较当前日期与date的大小（先后）
public boolean equalTwoDates(DateUtil date);//判断两个日期是否相等
public int getDaysofDates(DateUtil date);//求当前日期与date之间相差的天数
public String showDate();//以“year-month-day”格式返回日期值
应用程序共测试三个功能：
- 求下n天
- 求前n天
- 求两个日期相差的天数
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int year = 0;
int month = 0;
int day = 0;
int choice = input.nextInt();
if (choice == 1) { // test getNextNDays method
int m = 0;
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
DateUtil date = new DateUtil(year, month, day);
if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}
m = input.nextInt();
if (m < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:");
System.out.println(date.getNextNDays(m).showDate());
} else if (choice == 2) { // test getPreviousNDays method
int n = 0;
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
DateUtil date = new DateUtil(year, month, day);
if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}
n = input.nextInt();
if (n < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.print(
date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:");
System.out.println(date.getPreviousNDays(n).showDate());
} else if (choice == 3) { //test getDaysofDates method
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
int anotherYear = Integer.parseInt(input.next());
int anotherMonth = Integer.parseInt(input.next());
int anotherDay = Integer.parseInt(input.next());
DateUtil fromDate = new DateUtil(year, month, day);
DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);
if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
System.out.println("The days between " + fromDate.showDate() +
" and " + toDate.showDate() + " are:"
+ fromDate.getDaysofDates(toDate));
} else {
System.out.println("Wrong Format");
System.exit(0);
}
}
else{
System.out.println("Wrong Format");
System.exit(0);
}
}
}
class DateUtil{
private int year,month,day;
int []a=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
public DateUtil(DateUtil d){
this.day = d.getDay();
this.month = d.getMonth();
this.year = d.getYear();
}
public DateUtil(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
public void setDay(int day) {
this.day = day;
}
public int getDay() {
return day;
}
public int getMonth() {
return month;
}
public int getYear() {
return year;
}
public void setMonth(int month) {
this.month = month;
}
public void setYear(int year) {
this.year = year;
}
public boolean checkInputValidity() {
int[] a=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
if(isLeapYear(year)){
a[2]=29;
}
if(year>=1820&&year<=2020&&month>0&&month<=12&&day<=a[month]&&day>0){
return true;
}
else
return false;
}
public boolean isLeapYear(int year){
if(( year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)){
return true;
}
else
return false;
}
public DateUtil getNextNDays(int n){
DateUtil newdate = new DateUtil(this);
int[] a = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
int years=0;
if(!isLeapYear(newdate.year)&&isLeapYear(newdate.year+1)&&newdate.getMonth()>2){
n=n-366;
}
while(n>years){
if(isLeapYear(newdate.year))
years=366;
else
years=365;
newdate.year++;
n=n-years;
}
for (int i = 1; i <= n; i++) {
newdate.day++;
if(isLeapYear(newdate.year)) {
a[2] = 29;
}
else {
a[2] = 28;
}
if (newdate.day > a[newdate.month]) {
newdate.day = 1;
newdate.month++;
if (newdate.month > 12) {
newdate.month = 1;
newdate.year++;
}
}
}
return newdate;
}
public DateUtil getPreviousNDays(int n){
DateUtil newdata = new DateUtil(this);
while (n>=365) {
if(isLeapYear(newdata.year)) {
newdata.year = newdata.year - 1;
n = n - 366;
}
if(!isLeapYear(newdata.year)) {
newdata.year = newdata.year - 1;
n = n - 365;
}
}
for(int i = 0; i < n; i++){
newdata.setDay(newdata.getDay() - 1);
if(newdata.getDay() <= 0){
newdata.setMonth(newdata.getMonth() - 1);
if(newdata.getMonth() <= 0){
newdata.setMonth(12);
newdata.setYear(newdata.getYear() - 1);
}
if(isLeapYear(newdata.getYear()) && newdata.getMonth() == 2)
newdata.setDay(29);
else
newdata.setDay(newdata.a[newdata.getMonth()]);
}
}
return newdata;
}
public boolean compareDates(DateUtil date){
if(year > date.getYear())
return true;
else if(year == date.getYear() && month > date.getMonth())
return true;
else if(year == date.getYear() && month == date.getMonth() && day > date.getDay())
return true;
return false;
}
public boolean equalTwoDates(DateUtil date){
if(this.year != date.getYear())
return false;
else if(this.day != date.getDay())
return false;
else if(this.month != date.getMonth())
return false;
else
return true;
}
public int getDaysofDates(DateUtil date){
int x = 0;
DateUtil newdata = new DateUtil(this);
if(this.compareDates(date)){
while(newdata.getYear() - date.getYear() >= 2){
if(newdata.isLeapYear(newdata.getYear()) && newdata.getMonth() > 2)
x = x + 366;
else if(newdata.isLeapYear(newdata.getYear() - 1) && newdata.getMonth() <= 2)
x = x + 366;
else
x = x + 365;
newdata.setYear(newdata.getYear() - 1);
}
while(true){
if(newdata.equalTwoDates(date))
break;
x++;
newdata.setDay(newdata.getDay() - 1);
if(newdata.getDay() <= 0){
newdata.setMonth(newdata.getMonth() - 1);
if(newdata.getMonth() <= 0){
newdata.setMonth(12);
newdata.setYear(newdata.getYear() - 1);
}
if(isLeapYear(newdata.getYear()) && newdata.getMonth() == 2)
newdata.setDay(29);
else
newdata.setDay(newdata.a[newdata.getMonth()]);
}
}
}
else{
while(date.getYear() - newdata.getYear() >= 2){
if(newdata.isLeapYear(newdata.getYear()) && newdata.getMonth() <= 2)
x = x + 366;
else if(newdata.isLeapYear(newdata.getYear() + 1) && newdata.getMonth() > 2)
x = x + 366;
else
x = x + 365;
newdata.setYear(newdata.getYear() + 1);
}
while(true){
if(newdata.equalTwoDates(date))
break;
x++;
newdata.setDay(newdata.getDay() + 1);
if(isLeapYear(newdata.getYear()) && newdata.getMonth() == 2){
if(newdata.getDay() > 29){
newdata.setMonth(newdata.getMonth() + 1);
newdata.setDay(1);
}
}
else if(newdata.getDay() > newdata.a[newdata.getMonth()]){
newdata.setMonth(newdata.getMonth() + 1);
newdata.setDay(1);
if(newdata.getMonth() > 12){
newdata.setMonth(1);
newdata.setYear(newdata.getYear() + 1);
}
}
}
}
return x;
}
public String showDate(){
return year + "-" + month + "-" + day;
}
}
这是此题的源代码。
在写这道题的时候，我认为在计算日期前n天和后n天的时候很伤脑筋，在最开始我的思路是如果n大于365，就先一年一年的算，遇到润年就减去366，否则就减去365.但是在测试的时候遇到了一个问题。在测试这一组数据的时候1 1999 3 28 6543，输出结果应该是2017-2-24。最开始我的输出结果一直是2017-2-25，随后我注意到了一个问题，1999年是一个平年，但是2000年是一个闰年，而且我们是从1999年的3月28日开始算的，到了2000年的3月28日，我经历了366天而不是365天，这就是为什么结果比正确答案多算了一天。于是我们多加一种情况：如果今年是平年，但是下一年是闰年，而且我们是从今年的3月之后开始算的，那我们就应该减去366而不是365.
2.我们换一种想法，设计如下几个类：DateUtil、Year、Month、Day，其中年、月、日的取值范围依然为：year∈[1900,2050] ,month∈[1,12] ,day∈[1,31] , 设计类图如下：
类的代码如下：
class Year{
int value;
public Year(){
}
public Year(int value){
this.value=value;
}
public int getValue(){
return value;
}
public void setValue(int value){
this.value=value;
}
public boolean isLeapYear(int value){
if((value%4==0&&value%100!=0)||value%400==0)
return true;
else
return false;
}
public boolean isLeapYear(){
if((value%4==0&&value%100!=0)||value%400==0)
return true;
else
return false;
}
public boolean validate(){
if(value<=2050&&value>=1900)
return true;
else
return false;
}
public void yearIncrement(){
value=value+1;
}
public void yearReduction(){
value=value-1;
}
}
class Month{
int value;
Year year;
public Month(){
}
public Month(int yearValue,int monthValue){
this.year=new Year(yearValue);
this.value=monthValue;
}
public int getValue(){
return value;
}
public Year getYear(){
return year;
}
public void setValue(int value){
this.value=value;
}
public void setYear(Year year){
this.year=year;
}
public void resetMin(){
value=1;
}
public void resetMax(){
value=12;
}
public boolean validate(){
if(value>=1&&value<=12)
return true;
else
return false;
}
public void monthIncrement(){
value=value+1;
}
public void monthReduction(){
value=value-1;
}
}
//Day类
class Day{
int value;
Month month;
int a[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
public Day(){
}
public Day(int yearValue,int monthValue,int dayValue){
this.month=new Month(yearValue,monthValue);
this.value=dayValue;
}
public int getValue(){
return value;
}
public Month getMonth(){
return month;
}
public void setValue(int value){
this.value=value;
}
public void setMonth(Month value){
this.month=value;
}
public void resetMin(){
value=1;
}
public void resetMax(){
value=a[month.getValue()-1];
}
public boolean validate(){
if(this.getMonth().getYear().isLeapYear())
a[1]=29;
if(value>=1&&value<=a[month.getValue()])
return true;
else
return false;
}
public void dayIncrement() {
value=value+1;
}
public void dayReduction() {
value=value-1;
}
}
我们将DateUtil类和Day类关联在一起Day类和Month类关联在一起，Month类和Year类关联在一起。这样我们知道了day就可以知道这一天的年份和月份。这是一个链式结构，彼此之间的耦合性很强，对于程序设计而言不够简洁，下面还有另外一种聚合。
3.类图如下：
在这个聚合之中，我们将年月日分开表示，这样做的好处是可以便捷的访问年月日，而不是像上次的聚合那样，必须要通过day才能访问其他属性，这次的聚合显然更加方便。类的代码如下：
class Year{
private int y;
public Year(int y) {
this.y = y;
}
public Year() {
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public void yearIncrement(){
this.y++;
}
public void yearReduction(){
this.y--;
}
}
class Month{
private int m;
public Month(int m) {
this.m = m;
}
public Month() {
}
public int getM() {
return m;
}
public void setM(int m) {
this.m = m;
}
public void monthIncrement(){
this.m++;
}
public void monthReduction(){
this.m--;
}
public void resetMin(){
m=1;
}
public void resetMax(){
m=12;
}
}
class Day {
private int d;
public Day(int d) {
this.d = d;
}
public Day() {
}
public int getD() {
return d;
}
public void setD(int d) {
this.d = d;
}
public void dayIncrement() {
this.d++;
}
public void dayReduction() {
this.d--;
}
}
这样分类，使得类之间的耦合度变得非常低，更加符合面向对象设计的初衷。
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//int year = 0;
//int month = 0;
//int day = 0;
Year year=new Year(0);
Month month = new Month(0);
Day day = new Day(0);
int choice = input.nextInt();
if (choice == 1) { // test getNextNDays method
int m = 0;
year.setY(Integer.parseInt(input.next()));
month.setM(Integer.parseInt(input.next()));
day.setD(Integer.parseInt(input.next()));
DateUtil date = new DateUtil(year, month, day);
if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}
m = input.nextInt();
if (m < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.print(date.getYear().getY() + "-" + date.getMonth().getM() + "-" + date.getDay().getD() + " next " + m + " days is:");
System.out.println(date.getNextNDays(m).showDate());
} else if (choice == 2) { // test getPreviousNDays method
int n = 0;
year.setY(Integer.parseInt(input.next()));
month.setM(Integer.parseInt(input.next()));
day.setD(Integer.parseInt(input.next()));
DateUtil date = new DateUtil(year, month, day);
if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}
n = input.nextInt();
if (n < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.print(
date.getYear().getY() + "-" + date.getMonth().getM() + "-" + date.getDay().getD() + " previous " + n + " days is:");
System.out.println(date.getPreviousNDays(n).showDate());
} else if (choice == 3) { //test getDaysofDates method
year.setY(Integer.parseInt(input.next()));
month.setM(Integer.parseInt(input.next()));
day.setD(Integer.parseInt(input.next()));
Year anotherYear = new Year(Integer.parseInt(input.next()));
Month anotherMonth = new Month(Integer.parseInt(input.next()));
Day anotherDay = new Day(Integer.parseInt(input.next()));
DateUtil fromDate = new DateUtil(year, month, day);
DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);
if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
System.out.println("The days between " + fromDate.showDate() +
" and " + toDate.showDate() + " are:"
+ fromDate.getDaysofDates(toDate));
} else {
System.out.println("Wrong Format");
System.exit(0);
}
}
else{
System.out.println("Wrong Format");
System.exit(0);
}
}
}
在这个主函数中，我改变了输入方式，没有直接对int型的变量赋值，而是先创建对象再通过set函数对对象内部的属性进行赋值，这是利用了Java语言的封装性，在创建对象的时候采用构造方法传入三个对象比如DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);其他算法与题目一一样，只是要将所有的变量用引用的方式替换。
总结：在学习Java的语法时，Java的语法是类似c语言的，所以学习的比较轻松。唯一需要注意的是有几个不容易搞清楚的关键字的用法，public，protected，private，static，在学习Java的面向对象的编程语言的特性。比如继承，构造器，抽象类，接口，方法的多态，重载，覆盖，Java的异常处理机制。对于一个没有面向对象语言背景的人来说，我觉得这个过程需要花很长很长时间，因为学习Java之前没有C++的经验，只有C语言的经验，花了很长时间，才彻底把这些概念都搞清楚，把书上面的例子反复的揣摩，修改，尝试，把那几章内容反复的看过来，看过去，看了很多遍，才领悟了。在之后的学习中，我认为还是要巩固基础知识，只有基础知识学明白才能更好的学习Java语言。
标签：Java,int,System,第一次,newdata,year,date,随笔,public 来源： https://www.cnblogs.com/zhaoziyiblog/p/16123419.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。