一、 Java
本学期开始学习java，可以说是时隔非常非常久远才捡起了代码，写第一次作业的时候使用idea和java语句略显生疏，现在好了一些，但咱们就是说也没好到哪里去。
二、 第一次作业
- 计算两个数的和。 通过键盘为变量a和b赋值，然后计算变量a与b的和，并将和赋值给变量sum，最终输出变量sum的值；
要求：
输入格式:
输入两个整数
输出格式:
两个数的和
输入样例:
在这里给出一组输入。例如：
2 8
结尾无空行
输出样例:
在这里给出相应的输出。例如：
10
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
int b = scanner.nextInt();
int sum = add(a,b);
System.out.println(sum);
scanner.close();
}
public static int add (int a, int b){
return a+b;
}
}
总结
就是很简单的加法，调用了add方法。只记得当时c语言对于调用函数一整个都有点迷糊，但是java里的方法调用却使得我对调用有了一个更清晰的认识。
2. 国际标准中电话键盘上字母和数字之间的对应关系如下图所示。
编写一个程序，从键盘读入一个输入的字母，将其转换成所对应的数字。
输入格式:
从键盘输入一个字符，取值范围为“a~z”或“A~Z”，当输入多个连续字符时，取第一个字符。
输出格式:
（1）若输入数据合法，输出其所对应的数字，范围为2~9； （2）若输入数据非法，则输出所输入字符+“ is an invalid input”
输入样例1:
在这里给出一组输入。例如：
M
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
6
结尾无空行
输入样例2:
在这里给出一组输入。例如：
t
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
8
结尾无空行
输入样例3:
在这里给出一组输入。例如：
0
结尾无空行
输出样例3:
在这里给出相应的输出。例如：
0 is an invalid input
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
char first = s.charAt(0);
if(first>='a' && first<='c' || first>='A' && first <= 'C')
System.out.println('2');
else if(first>='d' && first<='f' || first>='D' && first <= 'F')
System.out.println('3');
else if(first>='g' && first<='i' || first>='G' && first <= 'I')
System.out.println('4');
else if(first>='j' && first<='l' || first>='J' && first <= 'L')
System.out.println('5');
else if(first>='m' && first<='o' || first>='M' && first <= 'O')
System.out.println('6');
else if(first>='p' && first<='s' || first>='P' && first <= 'S')
System.out.println('7');
else if(first>='t' && first<='v' || first>='T' && first <= 'V')
System.out.println('8');
else if(first>='w' && first<='z' || first>='W' && first <= 'Z')
System.out.println('9');
else
System.out.println(first +" is an invalid input");
scanner.close();
}
}
总结
本体我认为最主要的就是charAt()方法，声明字符串s，将输入的字符串赋值给s，再利用charAt方法将字符串的第一个字符赋给字符char，以此达到即使输入多个字符也只读取第一个字符的目的。
Java charAt() 方法
charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。
语法
public char charAt(int index)
参数
index -- 字符的索引。
返回值
返回指定索引处的字符。（注意：字符串中的第一个字符下标为0，和数组一样）
- 学校进行成绩分级管理，取消分数制，改为成绩分级评定。具体办法是：小于60分为E类；60分至70分（不含70分）为D类；70分至80分（不含）为C类；80分至90分（不含）为B类；90分以上为A类。设计一个程序，对输入的成绩进行等价划分
输入格式:
输入一个整数表示成绩。
输出格式:
根据输入的成绩，输出对应的等级(大写字母）
输入样例:
在这里给出一组输入。例如：
72
结尾无空行
输出样例:
在这里给出相应的输出。例如：
C
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner result = new Scanner(System.in);
int num = result.nextInt();
if(num >=0 && num <= 100){
if(num<60)
System.out.println('E');
else if(num >=60 && num <70 )
System.out.println('D');
else if(num >=70 && num < 80)
System.out.println('C');
else if(num >=80 && num < 90)
System.out.println('B');
else if(num >=90)
System.out.println('A');
}
else
System.out.println(num + " is an unvalid input!");
result.close();
}
}
总结
本题中我认为应注意的是 if...else if...else 的用法，在一些情况下，如果大量使用if，一旦判断内容符合两个if条件，便会两个if语句都执行，而else if很好规避此类情况，从上往下，从第一个开始逐个判断，一旦满足了一个，便不会再执行下一个判断语句。
这种题目直接用switch方法也可以。
3.美国联邦个人所得税是根据申报情况和应纳税所得额计算的。有四种申报情况：单身申报、已婚联合申报、已婚单独申报、户主申报。税率每年都不一样。下表即为假定税率计算方法，例如，某人单身申报，应纳税收入为10,000，则计算方法为：8,350的部分按10%计税，剩余的1,650的部分按158,350×10%+1,650×151,082.5。
你要写一个计算个人所得税的程序。程序应该首先输入申报状态和应纳税所得额并计算税款。其中，输入申报状态用整型数表示，0表示单身申报，1表示已婚联合申报，2表示已婚单独申报，3表示户主申报。应纳税所得金额用实型数表示。下表为具体的税率。
输入格式:
请在一行中输入申报情况和应纳税收入金额，其中，输入申报情况用整型数表示，正确取值范围为0~3；应纳税金额为实型数，正确取值范围为0~+∞。
输出格式:
（1）当输入数据合法时，输出应纳税金额，实型数； （2）当输入数据非法时，输出字符串“Wrong Format”
输入样例1:
在这里给出一组输入。例如：
0 0
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
0.0
结尾无空行
输入样例2:
在这里给出一组输入。例如：
0 100000
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
21720.0
结尾无空行
输入样例3:
在这里给出一组输入。例如：
5 100000
结尾无空行
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner status = new Scanner(System.in);
int str = status.nextInt();
int money = status.nextInt();
float tax;
switch (str)
{
case 0:
tax=singleTax(money);
System.out.println(tax);
break;
case 1:
tax=marriedUniteTax(money);
System.out.println(tax);
break;
case 2:
tax=marriedSeparateTax(money);
System.out.println(tax);
break;
case 3:
tax=HouseholdTax(money);
System.out.println(tax);
break;
default:
System.out.println("Wrong Format");
}
}
public static float singleTax(int money){
float taxes=0;
if(money >=0 && money <=8350) {
taxes = (float) (money * 0.1);
}
else if (money >=8351 && money <=33950) {
taxes = (float) (8350 * 0.1 + (money - 8350) * 0.15);
}
else if (money >=33951 && money <=82250) {
taxes = (float) (8350 * 0.1 + (33950 - 8350) * 0.15 + (money - 33950) * 0.25);
}
else if(money >=82251 && money <=171550){
taxes= (float)(8350*0.1+ (33950-8350)*0.15+(82250-33950)*0.25+(money-82250)*0.28);
}
else if(money >=171551 && money <=372950) {
taxes = (float) (8350 * 0.1 + (33950 - 8350) * 0.15 + (82250 - 33950) * 0.25 + (171550 - 82250) * 0.28 + (money - 171550) * 0.33);
}
else if(money >=372951) {
taxes = (float) (8350 * 0.1 + (33950 - 8350) * 0.15 + (82250 - 33950) * 0.25 + (171550 - 82250) * 0.28 + (372950 - 171550) * 0.33 + (money - 372950) * 0.35);
}
else
System.out.println("Wrong Format");
return taxes;
}
public static float marriedUniteTax(int money){
float taxes=0;
if(money >=0 && money <=16700){
taxes = (float) (money * 0.1);
}
else if (money >=16701 && money <=67900) {
taxes = (float) (16700 * 0.1 + (money - 16700) * 0.15);
}
else if (money >=67901 && money <=137050) {
taxes = (float) (16700 * 0.1 + (67900 - 16700) * 0.15 + (money - 67900) * 0.25);
}
else if(money >=137051 && money <=208850) {
taxes = (float) (16700 * 0.1 + (67900 - 16700) * 0.15 + (137050 - 67900) * 0.25 + (money - 137050) * 0.28);
}
else if(money >=208851 && money <=372950) {
taxes = (float) (16700 * 0.1 + (67900 - 16700) * 0.15 + (137050 - 67900) * 0.25 + (208850 - 137050) * 0.28 + (money - 208850) * 0.33);
}
else if(money >=372951) {
taxes = (float) (16700 * 0.1 + (67900 - 16700) * 0.15 + (137050 - 67900) * 0.25 + (208850 - 137050) * 0.28 + (372950 - 208850) * 0.33 + (money - 372950) * 0.35);
}
else
System.out.println("Wrong Format");
return taxes;
}
public static float marriedSeparateTax(int money){
float taxes=0;
if(money >=0 && money <=8350)
taxes = (float) (money * 0.1);
else if (money >=8351 && money <=33950)
taxes = (float) (8350 * 0.1 + (money - 8350) * 0.15);
else if (money >=33951 && money <=68525)
taxes = (float) (8350 * 0.1 + (33950 - 8350)* 0.15 + (money - 33950) * 0.25);
else if(money >=68526 && money <=104425)
taxes = (float) (8350 * 0.1 + (33950 - 8350)* 0.15 + (68525 - 33950) * 0.25 + (money - 68525) * 0.28);
else if(money >=104426 && money <=186475)
taxes = (float) (8350 * 0.1 + (33950 - 8350)* 0.15 + (68525 - 33950) * 0.25 + (104425 - 68525) * 0.28 + (money - 104425) * 0.33);
else if(money >=186476)
taxes = (float) (8350 * 0.1 + (33950 - 8350)* 0.15 + (68525 - 33950) * 0.25 + (104425 - 68525) * 0.28 + (186475 - 104425) * 0.33 + (money - 186475) * 0.35);
else
System.out.println("Wrong Format");
return taxes;
}
public static float HouseholdTax(int money){
float taxes=0;
if(money >=0 && money <=11950)
taxes = (float) (money * 0.1);
else if (money >=11951 && money <=45500)
taxes = (float) (11950 * 0.1 + (money - 11950) * 0.15);
else if (money >=45501 && money <=117450)
taxes = (float) (11950 * 0.1 + (45500 - 11950)* 0.15 + (money - 45500) * 0.25);
else if(money >=117451 && money <=190200)
taxes = (float) (11950 * 0.1 + (45500 - 11950) * 0.15+ (117450 - 45500) * 0.25 + (money - 117450) * 0.28);
else if(money >=208851 && money <=372950) {
taxes = (float) (11950 * 0.1 + (45500 - 11950) * 0.15 + (117450 - 45500) * 0.25 + (190200 - 117450) * 0.28 + (money - 104425) * 0.33);
}
else if(money >=372951) {
taxes = (float) (11950 * 0.1 + (45500 - 11950) * 0.15 + (117450 - 45500) * 0.25 + (190200 - 117450) * 0.28 + (186475 - 104425) * 0.33 + (money - 186475) * 0.35);
}
else
System.out.println("Wrong Format");
return taxes;
}
}
总结
那么这种税率计算题目就是我在学习c语言时就十分头疼的问题，密密麻麻的数字，各种各样的组合。
首先注意分板块，主函数main，singleTax，marriedUniteTax，marriedSeparateTax，HouseholdTax，利用switch语句完成一个基础判断，根据输入的申报情况数字和金额，调用不同方法，必面main函数太复杂。
之后，就是数字精度问题，在本题中我使用了强制转换，输入的money为整型int，需要浮点数，因此在算式前加上(float)进行转换，提高精度，也符合题目要求输出小数。
但是！强制转换可能造成数据丢失！！！
4. 编写程序，读取用户输入的代表总金额的double值，打印表示该金额所需的最少纸币张数和硬币个数，打印从最大金额开始。纸币的种类有十元、五元、一元，硬币的种类有五角、一角、贰分、壹分。
输入格式:
47.63
输出格式:
4 张十元
1 张五元
2 张一元
1 个五角
1 个一角
1 个贰分
1 个壹分
输入样例:
在这里给出一组输入。例如：
47.63
结尾无空行
输出样例:
在这里给出相应的输出。例如：
4 张十元
1 张五元
2 张一元
1 个五角
1 个一角
1 个贰分
1 个壹分
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
count();
}
public static void count(){
Scanner money = new Scanner(System.in);
double str = money.nextDouble();
double a = str/10;
int b=(int)a;
System.out.println(b+" 张十元");
double c = (str-b*10)/5;
int d = (int) c;
System.out.println(d+" 张五元");
double e = (str - b * 10 - d * 5);
int f = (int) e;
System.out.println(f+" 张一元");
double g= (str-b*10-d*5-f)/0.5;
int h = (int) g;
System.out.println(h+" 个五角");
double i =(str-b*10-d*5-f-h*0.5)/0.1;
int j=(int) i;
System.out.println(j +" 个一角");
double k=(str-b*10-d*5-f-h*0.5-j*0.1)/0.02;
int l =(int)k;
System.out.println(l+" 个贰分");
double m=(str-b*10-d*5-f-h*0.5-j*0.1-l*0.02)/0.01;
int n=(int)m;
System.out.println(n+" 个壹分");
money.close();
}
}
总结
本题主要利用整型数的除法和强制转换，money=47.63，除以10，等于4.763，强制转换，java不会给你四舍五入哈，就直接转换为4，即4张十元。之后将money减去张数乘以钱数，再除所求钱数。写代码时主要问题出在强制转换和计算上，当时在一角这里出了错，最终输出结果是43个一角，所以即便题目简单也还是要仔细认真。
数字类型间的转换
转型有两种: 向上转型和向下转型(强制转型)
两种分别如下:
第一种是向上转型
对于基础数据类型，可以自动转型，比如:
int a = 10;
long b = a;
这里就是把int型转成了long型 , 因为 long范围比int大 , 这样的转型不会有任何影响 , 所以可以自动转型
第二种是向下转型 , 也就是强制
这种需要强转 , 比如
long a = 10 ;
int b = (int) a;
通过 (int)可以强制转型 , 但是这样会丢失精度 , 比如a如果超过了b的范围 , 那么强转成int型, 只会等于int的最大值，内存泄漏，从而出错。
又如 : int a = ( int ) 8.8 ;
- 本题目要求使用一维数组，存储5个整数，输出5个整数的平均值。
输入格式:
输入一组整数。
输出格式:
对每一组输入，在一行中输出平均值。
输入样例:
1 2 3 4 5
结尾无空行
输出样例:
在这里给出相应的输出。例如：
3.0
结尾无空行
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
int[] numbs = new int[10];
Scanner s = new Scanner(System.in);
numbs[0]= s.nextInt();
numbs[1]= s.nextInt();
numbs[2]= s.nextInt();
numbs[3]= s.nextInt();
numbs[4]= s.nextInt();
int sum=0;
for(int i=0;i<=4;i++){
sum=sum+numbs[i];
}
float ave= (float)sum / 5;
System.out.println(ave);
s.close();
}
}
总结
首先声明数组，数据类型 [] 数组名称 = new 数据类型[长度]; int[] numbs = new int[10];，将键盘输入的5个数字赋给数组，利用for循环叠加每一个数组的值，然后得到平均数。但是此处我再一次因为转换而出现问题，直接使用了float ave = sum/5;，未能注意到sum为整型数，因而还是要多加注意各类数值类型。
5.先从键盘输入一个整数n，n代表需要排序的整数数量，然后再从键盘输入n个整数，对这些数从小到大排序并输出。
输入格式:
先从键盘输入一个整数n，之后回车 再从键盘输入n个整数，整数之间用一个或多个空格分隔
输出格式:
按如下示例输出排序后的数据：The sorted numbers are:排序后的n个数，每个输出的整数之后有一个空格作为分隔符
输入样例:
在这里给出一组输入。例如：
10
3 5 2 4 76 89 56 4 3 8
结尾无空行
输出样例:
在这里给出相应的输出。例如：
The sorted numbers are:2 3 3 4 4 5 8 56 76 89
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();//输入n个数
int [] numbs = new int[n];
int m=0;
int i=0;
int j=0;
int l=0;
for (i = 0; i < n; i++) {
numbs[i] = s.nextInt();
}
for (j = 0; j < n; j++) {//第j趟
for(l=0;l<n-j-1;l++) {//第l次
if (numbs[l] > numbs[l + 1]) {
m = numbs[l + 1];
numbs[l + 1] = numbs[l];
numbs[l] = m;
}
}
}
System.out.print("The sorted numbers are:");
for (i= 0; i < n; i++) {
System.out.print(numbs[i]+" ");
}
}
}
本题主要使用for循环，首先输入个数n，使用for循环，为n个数字赋值，再利用冒泡排序，达成排序。
冒泡排序
冒泡排序是比较基础的排序算法之一，其思想是相邻的元素两两比较，较大的数下沉，较小的数冒起来，这样一趟比较下来，最大(小)值就会排列在一端。整个过程如同气泡冒起，因此被称作冒泡排序。
冒泡排序的步骤是比较固定的：
1>比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2>每趟从第一对相邻元素开始，对每一对相邻元素作同样的工作，直到最后一对。
3>针对所有的元素重复以上的步骤，除了已排序过的元素(每趟排序后的最后一个元素)，直到没有任何一对数字需要比较。
- 输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。
输出格式:
（1）如果输入数据非法，则输出“Wrong Format”； （2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”； （3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”； （3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”； （5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”； （6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”； （7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。
输入样例1:
在这里给出一组输入。例如：
50 50 50.0
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
Equilateral triangle
结尾无空行
输入样例2:
在这里给出一组输入。例如：
60.2 60.2 80.56
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
Isosceles triangle
结尾无空行
输入样例3:
在这里给出一组输入。例如：
0.5 20.5 80
结尾无空行
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
double a = sc.nextFloat();
double b = sc.nextFloat();
double c = sc.nextFloat();
if(a >= 0 && a <= 200 && b>= 0 && b <= 200 && c >= 0 && c <= 200){
if(a + b > c && a + c > b && b + c > a){//三角形两边之和大于第三边
if(a == b && a == c){//等边三角形
System.out.println("Equilateral triangle");
}
else if(a*a+b*b-c*c>=0 && a*a+b*b-c*c <0.0001){
if(a == b || a == c || b == c){
System.out.println("Isosceles right-angled triangle");//等腰直角三角形
}
else
System.out.println("Right-angled triangle");//直角三角形
}
else if(a == b || a == c || b == c){//等腰三角形
System.out.println("Isosceles triangle");
}
else//一般三角形
System.out.println("General triangle");
}
else//不能构成三角形
System.out.println("Not a triangle");
}
else//数据不合法
System.out.println("Wrong Format");
}
}
本题就是不断判断，首先判断数据是否合法，a、b、c三条边取值在（0，200），是则进行后续判断，不能则输出"Wrong Format"。
形成三角形的第一条件即为三角形两边之和一定大于第三边，能达成即为三角形，不能就无法构成三角形"Not a triangle"。
等边三角形，a=b=c，直角三角形a2+b2=c2，除此之外均为一般三角形。
在现实数学题中，勾股定理a2+b2=c2，即a2+b2-c2=0，十分简单，然而在编程中则需注意若为浮点数会出现浮点误差无法相等，但差在精度范围内即可认为相等，所以可写为a2+b2-c2<0.0001。
是直角三角形同时存在直角相邻两边相等时，为等腰直角。
三、 第二次作业
- 一个IP地址是用四个字节（每个字节8位）的二进制码组成。请将32位二进制码表示的IP地址转换为十进制格式表示的IP地址输出。
输入数据要求：
- 必须为二进制数，即只能输入0或者1
- 长度必须是32位
违背以上规则程序直接输出Wrong Format
输入格式:
在一行中给出32位二进制字符串。
输出格式:
在一行中输出十进制格式的IP地址，其由4个十进制数组成（分别对应4个8位的二进制数），中间用“.”分隔开。
输入样例:
在这里给出一组输入。例如：
11000110101001000011011011011001
结尾无空行
输出样例:
在这里给出相应的输出。例如：
198.164.54.217
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String a = input.nextLine();
int[] b = new int[4];
int[] c = new int[4];
int fLag = 0;
for (int i = 0;i<a.length();i++)
{
if (a.charAt(i)!='1'&&a.charAt(i)!='0'||a.length()!=32||a.length()==0){
fLag = 1;
break;
}
}
if (fLag == 1){
System.out.println("Wrong Format");
}else {
for (int i = 0; i < 4; i++) {
c[i] = Integer.parseInt(a.substring((i + 1) * 8 - 8, (i + 1) * 8)); //32位分成8位
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 8; j++) {
b[i] += Math.pow(2, j) * (c[i] % 10);// 二进制转换成十进制
c[i] /= 10;
}
if (i != 3)
System.out.print(b[i] + ".");
else System.out.print(b[i]);
}
}
input.close();
}
}
利用flag标志，flag=1，非法输入，flag=0，则执行后续语句。
c[i] = Integer.parseInt(a.substring((i + 1) * 8 - 8, (i + 1) * 8));
在本句中，有两个方法，Integer.parseInt()和substring()。
Integer.parseInt()，将String字符串转换为int整型数。
例如：
Integer.parseInt(String s,int radix)返回的结果是一个十进制数
我们是要得到s的十进制数，而radix是表示s当前是多少进制的数
举个例子
parseInt(1010,16)
意思就是：输出16进制数1010在十进制下的数
Integer.parseInt是有最大数限制的，最大值是1999999999，超过这个数值就不能再转换了。
substring()方法的作用为截取字符串，其有两种用法：
分别如下：
substring（int beginIndex）;这个的作用为截取从beginindex位置处的元素开始，默认截取至剩余所有。
substring（int beginIndex, int endIndex）;这个的作用为截取从beginIndex开始，截取至endIndex-1位置间的元素。
- 合并两个升序排序的整型数组为一个新的升序整型数组并输出。
输入格式:
首先输入第一个数组的数据个数后输入第一个数组按升序排序的数据，然后再输入第二个数组的数据个数，最后输入第二个数据按升序排序的数据。数据之间用一个或多个空格或回车符分隔。
输出格式:
输出合并后按升序排序的数组的元素，元素之间用一个空格分隔。（注意输出的最后一个元素后会有一个空格符）
输入样例:
在这里给出一组输入。例如：
4
1 2 8 10
5
-1 5 6 20 200
结尾无空行
输出样例:
在这里给出相应的输出。例如：
-1 1 2 5 6 8 10 20 200
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int m=s.nextInt();
int[] a = new int[m];
for(int i=0;i<m;i++){
a[i]=s.nextInt();
}
int n=s.nextInt();
int[] b = new int[n];
for(int p=0;p<n;p++){
b[p]=s.nextInt();
}
int[] c = new int[a.length+b.length];
/*System.arraycopy(a,0,c,0,a.length);
System.arraycopy(b,0,c,a.length,b.length);*/
for(int i=0;i<a.length;i++){
c[i]=a[i];
}
for(int j=0;j<b.length;j++){
c[a.length+j]=b[j];
}
for(int p=0;p<c.length;p++){
for(int q=0;q<c.length-1-p;q++){
if(c[q]>c[q+1]){
int l=0;
l=c[q+1];
c[q+1]=c[q];
c[q]=l;
}
}
}
for(int i=0;i<c.length;i++){
System.out.print(c[i]+" ");
}
s.close();
}
}
在做本题时我一直纠结于该如何直接将两个数组放一起，后来查阅了相似题目，才发现完全是思路错了。完全是分开输入两个数组，在声明一个新的数组，通过遍历，将两个数组内的数字一个个赋给新的数组，而新数组的长度=a.length+b.length，然后冒泡排序。
在看类似题目时，发现了一个新方法
System.arraycopy(a,0,c,0,a.length);
System.arraycopy(b,0,c,a.length,b.length);
对于arraycopy()
例如
System.arraycopy(int[] arr, int star,int[] arr2, int start2, length);
5个参数，
第一个参数是要被复制的数组
第二个参数是被复制的数字开始复制的下标
第三个参数是目标数组，也就是要把数据放进来的数组
第四个参数是从目标数据第几个下标开始放入数据
第五个参数表示从被复制的数组中拿几个数值放到目标数组中
比如：
数组1：int[] arr = { 1, 2, 3, 4, 5 };
数组2：int[] arr2 = { 5, 6,7, 8, 9 };
运行：System.arraycopy(arr, 1, arr2, 0, 3);
得到：
int[] arr2 = { 2, 3, 4, 8, 9 };
- 输入年月日的值（均为整型数），输出该年份是否为闰年，同时输出该日期为星期几。 其中：年份的合法取值范围为[1820,2020] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] ; 判断星期几的算法如下：假定公元0001年1月1日为星期一，因此只要计算出当前输入日期离0001年1月1日所差的天数，然后拿这个天数除以7求余数，当余数为0时，为星期日，当余数为1时，为星期一，以此类推，当余数为6时，为星期六。
要求：Main类中必须含有如下方法，签名如下：
public static void main(String[] args)；//主方法；
public static boolean isLeapYear(int year) ;//判断year是否为闰年，返回boolean类型；
public static int numOfDays(int year,int month ,int day) ;//求出year-month-day到0001-1-1的距离天数，返回整型数；
public static String getWhatDay(int days) ; //根据天数返回星期几，其中参数days为天数，整型数，返回星期几的英文单词。
注意：不允许使用Java中和日期相关的类和方法。
输入格式:
在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。
输出格式:
- 当输入数据非法及输入日期不存在时，输出“Wrong Format”；
- 当输入日期合法，以如下格式输出两行数据（注意，两行末尾均有个.）
- 第一行：年份（值） is a leap year.
- 第二行：年-月-日（均为变量值） is 星期几（输出为星期日到星期六的英文单词）.
输入样例1:
在这里给出一组输入。例如：
2020 3 9
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
2020 is a leap year.
2020-3-9 is Monday.
结尾无空行
输入样例2:
在这里给出一组输入。例如：
1835 12 31
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
1835 is not a leap year.
1835-12-31 is Thursday.
结尾无空行
输入样例3:
在这里给出一组输入。例如：
1999 9 31
结尾无空行
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner date = new Scanner(System.in);
int year = date.nextInt();
int month = date.nextInt();
int day = date.nextInt();
if(!checkDate(year,month,day) )
System.out.println("Wrong Format");
else {
isLeapYear(year);
if (isLeapYear(year)) {
System.out.println(year + " is a leap year.");
} else
System.out.println(year + " is not a leap year.");
int a = numOfDays(year, month, day);
String week = getWhatDay(a);
System.out.println(year + "-" + month + "-" + day + " is " + week + ".");
}
date.close();
}
public static boolean checkDate(int year,int month,int day){
boolean checkDate;
int [] a=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31};
if(!isLeapYear(year))
a[2]=28;
checkDate=((year >= 1820 && year <= 2020) && (month >= 1 && month <= 12) && (day >= 1 && day <= a[month]));
return checkDate;
}
public static boolean isLeapYear(int year) {
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
public static int numOfDays(int year, int month, int day)//求出year-month-day到0001-1-1的距离天数，返回整型数；
{
int leapYear = 0;
int commonYear = 0;
for (int i = 1; i <= year - 1; i++) {//通过这里算出year这年之前总共有多少个平年闰年
if (isLeapYear(i)) {
leapYear=leapYear+1;
} else
commonYear=commonYear+1;
}
int[] a = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if(!isLeapYear(year))
a[2]=28;
int day1=0;
int day3=0;
switch (month) {//通过month知道天数 即可知据1年1月1日的天数
case 1:
day1 = day;
break;
case 2:
day1 = a[1] + day;//平年28
break;
case 3:
day1 = a[1] + a[2] + day;
break;
case 4:
day1 = a[1] + a[2] + a[3] + day;
break;
case 5:
day1 = a[1] + a[2] + a[3] + a[4] + day;
break;
case 6:
day1 = a[1] + a[2] + a[3] + a[4] + a[5] + day;
break;
case 7:
day1 = a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + day;
break;
case 8:
day1 = a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + day;
break;
case 9:
day1 = a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + day;
break;
case 10:
day1 = a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + a[9] + day;
break;
case 11:
day1 = a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + a[9] + a[10] + day;
break;
case 12:
day1 = a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8] + a[9] + a[10] + a[11] + day;
break;
}
day3 = (leapYear * 366 + commonYear * 365 + day1);
return day3;
}
public static String getWhatDay(int days) {
int week = days % 7;
String weeks= "" ;
switch (week) {
case 0:
weeks="Sunday";
break;
case 1:
weeks= "Monday";
break;
case 2:
weeks= "Tuesday";
break;
case 3:
weeks= "Wednesday";
break;
case 4:
weeks= "Thursday";
break;
case 5:
weeks= "Friday";
break;
case 6:
weeks= "Saturday";
break;
}
return weeks;
}
}
首先，闰年问题的第一要务就是记住以下条件
(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
符合则为闰年，有2月29日，不符合则为平年，有2月28日
本题要点一为各种方法的调用，二为判断
Main函数，checkDate方法，isLeapYear方法，numOfDays方法，getWhatDay方法。
输入年月日，调用checkDate方法，判断是否为合法输入。
调用isLeapYear方法，判断本年是否为闰年，
通过numOfDays方法，计算出输入的年月日据1年1月1日有多少天。
通过getWhatDay方法，判断星期
int [] a=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31};
if(!isLeapYear(year))
a[2]=28;
checkDate=((year >= 1820 && year <= 2020) && (month >= 1 && month <= 12) && (day >= 1 && day <= a[month]));
以上内容借鉴了其他文章，在看到时顿时觉得思路清晰，通过声明一个数组，达成判断月份相应的天数，并且第一个数组定为0，使得数组下标第一个为0不影响对月份的判断。调用isLeapYear方法，若是平年，则修改2月的天数，a[2]=28，checkDate为布尔型，通过checkDate的返回值判断输入年月日是否合法，而其中天数的判断，大于1没什么可说，但是此处小于a[month]就使得判断灵活，不会出现在平年有2月29日这类情况。
在numOfDays中，同样使用数组，加上switch，使得无需先分为平年和闰年，再分别计算天数，降低了复杂度。
4. 输入年月日的值（均为整型数），输出该日期的下一天。 其中：年份的合法取值范围为[1820,2020] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法。
要求：Main类中必须含有如下方法，签名如下：
public static void main(String[] args)；//主方法
public static boolean isLeapYear(int year) ;//判断year是否为闰年，返回boolean类型
public static boolean checkInputValidity(int year,int month,int day);//判断输入日期是否合法，返回布尔值
public static void nextDate(int year,int month,int day) ; //求输入日期的下一天
输入格式:
在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。
输出格式:
- 当输入数据非法及输入日期不存在时，输出“Wrong Format”；
- 当输入日期合法，输出下一天，格式如下：Next date is:年-月-日
输入样例1:
在这里给出一组输入。例如：
2020 3 10
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
Next date is:2020-3-11
结尾无空行
输入样例2:
在这里给出一组输入。例如：
2025 2 10
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner date = new Scanner(System.in);
int year=date.nextInt();
int month=date.nextInt();
int day=date.nextInt();
if(!checkInputValidity(year,month,day)){
System.out.println("Wrong Format");
}
else{
System.out.print("Next date is:");
nextDate(year,month,day);
}
}
public static boolean checkInputValidity(int year, int month, int day){
boolean checkInputValidity;
int[] a = new int[]{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if(!isLeapYear(year))
a[2]=28;
checkInputValidity=(year>=1820&&year<=2020&&month>=1&&month<=12&&day>=1&&day<=a[month]);
return checkInputValidity;
}
public static boolean isLeapYear(int year){
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
public static void nextDate(int year,int month,int day){
int[] a = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if(!isLeapYear(year))
a[2]=28;
//2020 1 1 下一天是2020 1 2 那么day+1
if(day<a[month]){
day=day+1;
System.out.println(year+"-"+month+"-"+day);
}
//2020 x月 最后一天 下一天2020 x+1 1 那么month+1 day=1
if(day==a[month]&&month!=12){
month=month+1;
day=1;
System.out.println(year+"-"+month+"-"+day);
}
//2020 12月 31日 下一天2021 1 1 那么 year+1 month=1 day=1
if(day==a[month]&&month==12){
year=year+1;
month=1;
day=1;
System.out.println(year+"-"+month+"-"+day);
}
}
}
沿用上一题灵活的使用数组判断输入年月日是否合法的方法，将输入的日期分为三类，一是一般日期，不是月末，二是是月末，但不是年末，三是既是年末，又是月末。
做题时主要出现问题的地方是if判断语句括号里的条件，还是注意年月日的三个分类。
输入年月日的值（均为整型数），同时输入一个取值范围在[-10,10] 之间的整型数n，输出该日期的前n天（当n > 0时）、该日期的后n天（当n<0时）。
其中年份取值范围为 [1820,2020] ,月份取值范围为[1,12] ,日期取值范围为[1,31] 。
注意：不允许使用Java中任何与日期有关的类或方法。
输入格式:
在一行中输入年月日的值以及n的值，可以用一个或多个空格或回车分隔。
输出格式:
- 当输入的年、月、日以及n的值非法时，输出“Wrong Format”；
- 当输入数据合法时，输出“n days ago is:年-月-日”
输入样例1:
在这里给出一组输入。例如：
2018 6 19 8
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
8 days ago is:2018-6-11
结尾无空行
输入样例2:
在这里给出一组输入。例如：
2018 6 19 -8
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
-8 days ago is:2018-6-27
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner date = new Scanner(System.in);
int year=date.nextInt();
int month=date.nextInt();
int day=date.nextInt();
int n=date.nextInt();
if(!checkInputValidity(year,month,day,n)){
System.out.println("Wrong Format");
}
else {
System.out.print(n+" days ago is:");
nextNDate(year,month,day,n);
}
}
public static boolean checkInputValidity(int year, int month, int day,int n){
boolean checkInputValidity;
int[] a = new int[]{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if(!isLeapYear(year))
a[2]=28;
checkInputValidity=(year>=1820&&year<=2020&&month>=1&&month<=12&&day>=1&&day<=a[month]&&n>=-10&&n<=10);
return checkInputValidity;
}
public static boolean isLeapYear(int year){
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
public static void nextNDate(int year,int month,int day,int n){
int[] a = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if(!isLeapYear(year))
a[2]=28;
int month1=0;
if(n>=0)
{
if(n==0){
day=day;
}
//2020 1 11 前3天是 2020 1 8 那么 day-n
//2020 1 11 后三天是 2020 1 14 那么day-n
if(day-n>0){
month1=month;
day=day-n;
}
//2020 2 5 前9天是2020 1 27 那么month-1 day=前一个月的总天数-n+day
//2020 2 28
//2020 2 29 后3天是2020 3 3 那么 month-1 day=n
//2020 9 25 后9天是2020 10 4 那么month+1 day=-n-（当月总天数-day）
else if(day-n<=0 && month!=1 ){
month1=month-1;
day=a[month-1]-n+day;
}
//2020 1 2 前5天 2019 12 28 那么year-1 month=12 day=前一个月的总天数-n+day
//2019 12 31 后五天 2020 1 5 那么 year+1 month=1 day=-n-（当月总天数-day）
else if(month ==1 && day-n<=0){
year=year-1;
month1=12;
day=a[12]-n+day;
}
}
if(n<0)
{
//2020 1 11 前3天是 2020 1 8 那么 day-n
//2020 1 11 后三天是 2020 1 14 那么day-n
if(day-n<=a[month]){
month1=month;
day=day-n;
}
//2020 2 5 前9天是2020 1 27 那么month-1 day=前一个月的总天数-n+day
//2020 9 25 后9天是2020 10 4 那么month+1 day=-n-（当月总天数-day）
//2020 2 29 -3 2020 3 3
else if(day-n>a[month] && month!=12){
month1=month+1;
day=-n-(a[month]-day);
}
//2020 1 2 前5天 2019 12 28 那么year-1 month=12 day=前一个月的总天数-n+day
//2019 12 31 后五天 2020 1 5 那么 year+1 month=1 day=-n-（当月总天数-day）
else if(month ==12 && day-n>a[month] ){
year=year+1;
month1=1;
day=-n-(a[12]-day);
}
}
System.out.println(year+"-"+month1+"-"+day);
}
}
第二次作业中的3-5题，难度递进，在认真做完前两题，弄清楚了各种时间问题后，第5题的解题思路就会十分明晰。
首先是前N天这里，我当时没有仔细看题目，先入为主认为一定只能求前几天，忽略了n可以小于0，变成后n天。
所以代码中我首先分为n是否大于0，成了前n天一个板块，后n天一个板块。又再分为，跨日，即日期大于n，跨月，即日期小于n，跨年，日期小于n，并且为12月。三个小板块，将大问题分解成一个个小问题，无疑令自己思路更明确，不至于头脑混乱，想什么写什么。
四、 第三次作业
设计一个名称为Account的类，具体包括：
- id：账号，私有属性，整型，默认值为0；
- balance：余额，私有属性，实型，默认值为0；
- annualInterestRate：当前利率，私有属性，实型，默认值为0，假设所有帐户均有相同的利率；
- dateCreated：账户开户时间，私有属性，LocalDate类型，默认为2020年7月31日；
- 一个能创建默认账户的无参构造方法；
- 一个能创建带特定id和初始余额的账户的构造方法；
- id、balance、annualInterstRate的getter及setter方法；
- dateCreated的getter方法；
- 一个名为getMonthlyInterestRate()的方法返回月利率（月利率计算公式：余额*(年利率/1200）)；
- 一个名为withDraw的方法从账户提取特定数额，当提取数额大于余额或为负数系统返回WithDraw Amount Wrong提示；
- 一个名为deposit的方法向账户存储特定数额，当存储数额大于20000元或为负数系统返回Deposit Amount Wrong提示。
编写一个测试程序：
- 创建一个账户，其账户id、余额及利率分别有键盘输入，账户开户时间取系统当前时间；
- 输入取钱金额，系统进行取钱操作，如果取钱金额有误，则输出提示信息后系统继续运行；
- 输入存钱金额，系统进行存钱操作，如果存钱金额有误，则输出提示信息后系统继续运行；
- 系统输出，以如下格式分别输出该账户余额、月利息以及开户日期（输出实型数均保留两位小数）
输入格式:
在一行内分别输入账户id、初始余额、当前利率、提取金额、存储金额，数据间采用一个或多个空格分隔。
输出格式:
共分三行输出，分别为约、计算的月利息以及开户日期，格式如下：
`The Account'balance:余额`
- The Monthly interest:月利息
`The Account'dateCreated:年-月-日`
输入样例1:
在这里给出一组输入。例如：
1122 20000 0.045 800 600
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
The Account'balance:19800.00
The Monthly interest:0.74
The Account'dateCreated:2020-07-31
结尾无空行
输入样例2:
在这里给出一组输入。例如：
1122 20000 0.045 8000 30000
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
Deposit Amount Wrong
The Account'balance:12000.00
The Monthly interest:0.45
The Account'dateCreated:2020-07-31
结尾无空行
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.time.LocalDate;
import java.util.Scanner;
public class Main{
public static void main(String[] args) throws Exception {
Scanner a = new Scanner(System.in);
Account myAccount = new Account(1122, 20000);
myAccount.setAnnualInterestRate(4.5 / 100);
myAccount.withDraw(2500);
myAccount.deposit(3000);
myAccount.setId(a.nextInt());
myAccount.setBalance(a.nextDouble());
myAccount.setAnnualInterestRate(a.nextDouble());
myAccount.withDraw(a.nextDouble());
myAccount.deposit(a.nextDouble());
System.out.println("The Account'balance:" + myAccount.getBalance());
System.out.println("The Monthly interest:" + myAccount.getMonthlyInterestRate());
System.out.println("The Account'dateCreated:" + myAccount.getDataCreated());
}
}
class Account {
private int id; //账号
private double balance = 0; // 余额
private double annualInterestRate = 0; // 利息
private LocalDate dataCreated = LocalDate.of(2020, 7, 31); // 账户开户日期
public Account() {
}
public Account(int id, double balance) {
this.id = id;
this.balance = balance;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getBalance() {
DecimalFormat df=new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.HALF_UP);
return df.format(balance);
}
public void setBalance(double balance) {
this.balance = balance;
}
public double getAnnualInterestRate() {
return annualInterestRate;
}
public LocalDate getDataCreated() {
return dataCreated;
}
public void setAnnualInterestRate(double annualInterestRate) {
this.annualInterestRate = annualInterestRate;
}
/**
* 月利息--假设利息为年利息的话
*/
public String getMonthlyInterestRate() throws Exception {
/*if (this.annualInterestRate == 0) {
throw new Exception("还没设置利息呢");
} else {*/
DecimalFormat df=new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.HALF_UP);
return df.format(balance * (annualInterestRate / 1200));
}
/**
* 取钱
*/
public void withDraw(double MoneyNum) {
if (MoneyNum > this.balance || MoneyNum<0) {
System.out.println("WithDraw Amount Wrong");
} else {
this.balance -= MoneyNum;
}
}
/**
* 存钱
*/
public void deposit(double MoneyNum) {
if (MoneyNum > 20000 || MoneyNum < 0) {
System.out.println("Deposit Amount Wrong");
} else {
this.balance += MoneyNum;
}
}
/**
* 测试
*/
}
第一次接触账户类型题目，那么首先分为输出作用的main方法，自定义account类，帐号、余额、利息、开户时间均为private，封装数据。
Account无参构造，再使用有参构造创建带特定id和初始余额的账户。getter及setter方法，访问隐私数据，在存取款中，设置条件，防止取出的金额大于余额，或者存款大于20000，以及非法输入，例如复数。
在题目中要求保留两位小数，在查找资料后发现了格式化数字DecimalFormat方法。
DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。帮你用最快的速度将数字格式化为你需要的样子。
import java.text.DecimalFormat;
public class TestNumberFormat{
public static void main(String[]args){
double pi = 3.1415927; //圆周率
//取一位整数
System.out.println(new DecimalFormat("0").format(pi)); //3
//取一位整数和两位小数
System.out.println(new DecimalFormat("0.00").format(pi)); //3.14
//取两位整数和三位小数，整数不足部分以0填补。
System.out.println(new DecimalFormat("00.000").format(pi));// 03.142
//取所有整数部分
System.out.println(new DecimalFormat("#").format(pi)); //3
//以百分比方式计数，并取两位小数
System.out.println(new DecimalFormat("#.##%").format(pi)); //314.16%
long c =299792458; //光速
//显示为科学计数法，并取五位小数
System.out.println(new DecimalFormat("#.#####E0").format(c)); //2.99792E8
//显示为两位整数的科学计数法，并取四位小数
System.out.println(new DecimalFormat("00.####E0").format(c)); //29.9792E7
//每三位以逗号进行分隔。
System.out.println(new DecimalFormat(",###").format(c)); //299,792,458
//将格式嵌入文本
System.out.println(new DecimalFormat("光速大小为每秒,###米。").format(c));
}
}
DecimalFormat df=new DecimalFormat("0.00");
//取一个整数，两位小数
df.setRoundingMode(RoundingMode.HALF_UP);
//ROUND_HALF_UP：对数值进行取舍，向“最接近的”整数舍入。
若舍入位大于等于5，则对舍入部分的前一位数字加1；若舍入位小于5，则直接舍弃。即为四舍五入模式。
然后了解了this关键字。
一个对象是一个this。
this是一个变量，是一个引用。this保存当前对象地址，指向自身。所以，严格意义上来说，this代表的就是“当前对象”。
this存储在堆内存当中对象的内部。
感觉this在账户问题中非常好使。
以及LocalDate
|
LocalDate.of(int year, int month, int dayOfMonth) |
根据参数设置日期，参数分别为年，月，日 |
LocalDate localDate = LocalDate.of(2019,1,7); System.out.println(localDate); 运行结果为：2019-01-07 |
2.定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法，否则按0分处理。
要求：Date类结构如下图所示：
输入格式:
在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。
输出格式:
- 当输入数据非法及输入日期不存在时，输出“Date Format is Wrong”；
- 当输入日期合法，输出下一天，格式如下：Next day is:年-月-日
输入样例1:
在这里给出一组输入。例如：
1912 12 25
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
Next day is:1912-12-26
结尾无空行
输入样例2:
在这里给出一组输入。例如：
2001 2 30
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
Date Format is Wrong
结尾无空行
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
Date mydate = new Date();
mydate.setYear(s.nextInt());
mydate.setMonth(s.nextInt());
mydate.setDay(s.nextInt());
mydate.checkInputValidity(mydate.getYear(), mydate.getMonth(), mydate.getDay());
if(mydate.checkInputValidity(mydate.getYear(), mydate.getMonth(), mydate.getDay())) {
System.out.print("Next day is:" );
mydate.getNextDate(mydate.getYear(), mydate.getMonth(), mydate.getDay());
}
else
System.out.println("Date Format is Wrong");
}
}
class Date{
private int year;
private int month;
private int day;
public Date(){
}
public Date(int year,int month,int day){
this.year=year;
this.month=month;
this.day=day;
}
public int getYear(){
return year;
}
public void setYear(int year){
this.year=year;
}
public int getMonth(){
return month;
}
public void setMonth(int month){
this.month=month;
}
public int getDay(){
return day;
}
public void setDay(int day){
this.day=day;
}
public boolean isLeapYear(int year){
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
public boolean checkInputValidity(int year,int month,int day){
boolean checkInputValidity;
int[] a = new int[]{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if(!isLeapYear(year))
a[2]=28;
checkInputValidity=(year>=1900&&year<=2000&&month>=1&&month<=12&&day>=1&&day<=a[month]);
return checkInputValidity;
}
public void getNextDate(int year,int month,int day){
int[] a = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if(!isLeapYear(year))
a[2]=28;
//2020 1 1 下一天是2020 1 2 那么day+1
if(day<a[month]){
day=day+1;
System.out.println(year+"-"+month+"-"+day);
}
//2020 x月 最后一天 下一天2020 x+1 1 那么month+1 day=1
else if(day==a[month]&&month!=12){
month=month+1;
day=1;
System.out.println(year+"-"+month+"-"+day);
}
//2020 12月 31日 下一天2021 1 1 那么 year+1 month=1 day=1
else if(day==a[month]&&month==12){
year=year+1;
month=1;
day=1;
System.out.println(year+"-"+month+"-"+day);
}
}
}
主要思路和上一题是一样的，数据的封装，结合了第二次作业的第5题。
编写程序性，实现对简单多项式的导函数进行求解。详见作业指导书。 OO作业3-3题目说明.pdf
输入格式:
在一行内输入一个待计算导函数的表达式，以回车符结束。
输出格式:
- 如果输入表达式不符合上述表达式基本规则，则输出“Wrong Format”。
- 如果输入合法，则在一行内正常输出该表达式的导函数，注意以下几点： 结果不需要排序，也不需要化简；
- 当某一项为“0”时，则该项不需要显示，但如果整个导函数结果为“0”时，则显示为“0”；
- 当输出结果第一项系数符号为“+”时，不输出“+”；
- 当指数符号为“+”时，不输出“+”；
- 当指数值为“0”时，则不需要输出“x^0”，只需要输出其系数即可。
输出格式见输入输出示例。
输入样例1:
在这里给出一组输入。例如：
-2* x^-2+ 5*x^12-4*x+ 12
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
4*x^-3+60*x^11-4
结尾无空行
输入样例2:
在这里给出一组输入。例如：
2*x^6-0*x^7+5
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
结尾无空行
import java.util.Scanner;
public class Main {
public static void main (String[] args) {
Scanner input = new Scanner(System.in);
String form = input.next();
Caculate caculate = new Caculate(form);
caculate.setFomulate(form);
caculate.count();
}
}
class Caculate {
private String fomulate;
private String result;
public Caculate() {
super();
// TODO 自动生成的构造函数存根
}
public Caculate(String fomulate) {
super();
this.fomulate = fomulate;
}
public String getFomulate() {
return fomulate;
}
public void setFomulate(String fomulate) {
this.fomulate = fomulate;
}
public void setResult(String result) {
this.result = result;
}
public boolean Judge() {
if(this.fomulate == "^(([-+]([0-9]*\\.?[0-9]+)(x(\\\\^[+-]?[0-9]+)?))|(([0-9]*\\.?[0-9]+)(x(\\\\^[+-]?[0-9]+)?))|([-+](x(\\\\^[+-]?[0-9]+)?))|([-+]([0-9]*\\.?[0-9]+))|(([0-9]*\\.?[0-9]+))|((x(\\\\^[+-]?[0-9]+)?)))+$" ) {
return true;
}
return false;
}
public void count() {
if(Judge() == false)
System.out.println("Wrong Format");
}
}
这道题目，我现在也没有怎么弄明白，所以说不出个123来。
五、 总结
在前三次作业中，可以感觉内容都很基础，但因为我没什么基础，所以一整个做的有些吃力，但是也有所收获，在慢慢琢磨题目的过程中慢慢有了面向对象的概念，对许多从前不曾掌握的语法在实际编码过程中有了一定提升，还顺带学习了一些全新的方法，例如DecimalFormat，arraycopy，并且发现了java及idea的便利性。但问题还是很多，仍需多做一些题目夯实基础，并且因为没有记录的习惯，所以时隔许久都有些想不起当时的错误，对于一些专业术语也掌握不多，仍需努力。
