1、编写程序，判断给定的某个年份是否是闰年。
闰年的判断规则如下：
（1）若某个年份能被4整除但不能被100整除，则是闰年。
（2）若某个年份能被400整除，则也是闰年。
/**
* 1，编写程序，判断给定的某个年份是否是闰年。
* 闰年的判断规则如下：
* （1）若某个年份能被4整除但不能被100整除，则是闰年。
* （2）若某个年份能被400整除，则也是闰年。
*/
package com.demo3;
import java.util.Scanner;
public class Practice1 {
public static void main(String[] args){
System.out.println("请输入年份");
int year; //定义输入的年份名字为“year”
Scanner scanner = new Scanner(System.in);
year = scanner.nextInt();
if(year <0||year>3000){
System.out.println("年份有误，程序退出！");
System.exit(0);
} else if ((year%4==0)&&(year%100!=0)||(year%400==0)) {
System.out.println(year+" is bissextitle");
}else {System.out.println(year+" is not bissextitle");}
}
}
2、给定一个百分制的分数，输出相应的等级。
90分以上 A级
80~89 B级
70~79 C级
60~69 D级
60分以下 E级
/**
* 给定一个百分制的分数，输出相应的等级。
* 90分以上 A级
* 80~89 B级
* 70~79 C级
* 60~69 D级
* 60分以下 E级
*/
package com.demo3;
import java.util.Scanner;
public class Practice2 {
public static void main(String[] args){
System.out.println("请输入一个分数：");
//定义输入的分数为“mark”，且分数会有小数
double mark;
Scanner scanner = new Scanner(System.in);
mark = scanner.nextDouble();
//判断是否有输入错误。
if(mark<0||mark>100){
System.out.println("分数输入有误！");
System.exit(0);
}
/*判断分数的等级
90分以上者A级， 80~89分者 B级，70~79分者 C级， 60~69者 D级，60分以下 E级 */
if(mark>=90){
System.out.println("this mark is grade A");
} else if (mark>=80) {
System.out.println("this mark is grade B");
} else if (mark>=70) {
System.out.println("this mark is grade C");
} else if (mark>=60) {
System.out.println("this mark is grade D");
}else {
System.out.println("this mark is grade E");
}
}
}
3、编写程序求 1+3+5+7+……+99 的和值。
/**
* 编写程序求 1+3+5+7+……+99 的和值
*/
package com.demo3;
public class Practice3 {
public static void main(String[] args){
int number = 1; //初始值1，以后再+2递增上去
int sum1 = 0,sum2=0,sum3=0;
//1+2+3+4+...+100的值
for(int i=1;i<=100;i++){
sum1 = sum1+i;
}
System.out.println("1+2+3+4+...+100值为："+sum1);
for(int j=1;j<100;j+=2){
sum2 = sum2+j;
}
System.out.println("1+3+5+7+...+99值为："+sum2);
for(int t=2;t<=100;t+=2){
sum3 = sum3+t;
}
System.out.println("2+4+6+8+...+100值为："+sum3);
}
}
4、利用for循环打印 9*9 表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
/**
* 利用for循环打印 9*9 表
*/
package com.demo3;
public class Practice4 {
public static void main(String[] args){
System.out.println();
for(int i=1;i<10;i++){
for(int j=1;j<10;j++){
if(j>i)
break;
System.out.print(" "+j+"*"+i+"="+i*j);
}
System.out.println();
}
}
}
5、输出所有的水仙花数
所谓水仙花数是指一个数3位数，其各各位数字立方和等于其本身，
例如： 153 = 1*1*1 + 3*3*3 + 5*5*5
/**
* 输出所有的水仙花数，所谓水仙花数是指一个数3位数，其各各位数字立方和等于其本身，
* 例如： 153 = 1*1*1 + 3*3*3 + 5*5*5
*/
package com.demo3;
public class Practice5 {
public static void main(String[] args){
System.out.println("以下是所有的水仙花数：");
int number = 100; //由于水仙花是三位数所以由100起算
int i,j,k; //i j k分别为三位数的百位 十位 个位
for(int sum;number<1000;number++){
i=number/100;
j=(number-i*100)/10;
k=number-i*100-j*10;
sum = i*i*i+j*j*j+k*k*k;
if(sum==number){
System.out.println(number+"是一个水仙花数");
}
}
}
}
6、求 a+aa+aaa+.......+aaaaaaaaa=?
其中a为1至9之中的一个数，项数也要可以指定。
/**
* 求 a+aa+aaa+.......+aaaaaaaaa=?
* 其中a为1至9之中的一个数，项数也要可以指定。
*/
package com.demo3;
import java.util.Scanner;
public class Practice6 {
public static void main(String[] args){
int a; //定义输入的数字
int cnt; //定义最后的一项有多少个数字
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个1~9的值进行相加：");
a=scanner.nextInt();
System.out.println("请问要相加多少项：");
cnt= scanner.nextInt();
int sum = 0;
int a1 = a;//用来保存a1的初始值
for(int i=1;i<=cnt;i++){
sum = sum+a;
a=a*10+a1; //这表示a的下一项
//每次 a 的下一项都等于前一项*10，再加上刚输入时的 a ；注意，这时的 a 已经变化了。
}
System.out.println("此时的值为："+sum);
}
}
7、求 2/1+3/2+5/3+8/5+13/8.....前20项之和？
/**
* 求 2/1+3/2+5/3+8/5+13/8.....前20项之和？
*/
package com.demo3;
public class Practice7 {
public static void main(String[] args){
double sum=0;
double fenzi =2.0,fenmu=1.0; // 初始的分子 (fenZi)＝2，分母(fenMu)＝1
for(int i=1;i<=20;i++){
sum = sum+fenzi/fenmu;
fenmu = fenzi; //下一项的分母 ＝ 上一项的分子
fenzi=fenzi+fenmu; //下一项的分子 ＝ 上一项的分子加分母
}
System.out.println("2/1+3/2+5/3+8/5+13/8.....前20项之和:"+sum);
}
}
8、利用程序输出如下图形:
*
* * *
* * * * *
* * * * * * *
* * * * *
* * *
*
/**
* 利用程序输出如下图形:
* *
* * * *
* * * * * *
* * * * * * * *
* * * * * *
* * * *
* *
*/
package com.demo3;
public class Practice8 {
public static void main(String[] args){
for(int i=1;i<=13;i+=2){
for(int j=1;j<=i&&i+j<=14;j++){
System.out.print("* ");
}
System.out.println();//换行
}
}
}
9、计算圆周率
PI＝4－4/3+4/5-4/7.......
打印出第一个大于 3.1415小于 3.1416的值
/**
* 计算圆周率
* PI＝4－4/3+4/5-4/7.......
* 打印出第一个大于 3.1415小于 3.1416的值
*/
package com.demo3;
public class Practice9 {
public static void main(String[] args){
double pi = 0; //初始定义值
double fenzi = 4; //分子为4
double fenmu = 1; //第一个4，可看作分母为1 的分式，以后的分母每次递增2
for (int i=0;i<=1000000000;i++){ 运行太久，可以减少循环次数会快很多，只是精确度小些
pi = pi+fenzi/fenmu;
fenzi =-1*fenzi; //每项分子的变化是+4，－4，+4，－4 ....
fenmu = fenmu+2; //分母的变化是1，3，5，7， .... 每项递加2
}
System.out.println(pi);
}
}
此输出结果并不精确，圆周率为无限不循环小数；
10、输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值
1 1 2 3 5 8 13 21 34
规律：一个数等于前两个数之和
//计算斐波那契数列(Fibonacci)的第n个值
11.求1-1/3+1/5-1/7+1/9......的值。
a,求出前50项和值。
b,求出最后一项绝对值小于1e-5的和值。
/**
* 求 1-1/3+1/5-1/7+1/9......的值。
* a,求出前50项和值。
* b,求出最后一项绝对值小于1e-5的和值。
*/
package com.demo3;
public class Practice11 {
public static void main(String[] args){
double sum = 0;
double fenzi=1.0;
double fenmu=1.0;
for(int i=1;i<=50;i++){
sum = sum+fenzi/fenmu;
fenmu = fenmu+2;
fenzi = -1*fenzi;
}
System.out.println("1-1/3+1/5-1/7+1/9......前50项的和为："+sum);
}
}
12、在屏幕上打印出n行的金字塔图案，如，若n=5,则图案如下：
*
***
*****
*******
*********
13、歌德巴赫猜想,任何一个大于六的偶数可以拆分成两个质数的和
打印出所有的可能
/**
* //任何一个大于六的偶数可以拆分成两个质数的和
* //打印出所有的可能
*/
package com.demo3;
import java.util.Scanner;
public class practice13 {
public static void main(String[] args){
Scanner scanner =new Scanner(System.in);
System.out.println("请输入一个数字：");
int m = scanner.nextInt();
if(m%2!=0||m<6){
System.out.println("数字非大于6的偶数！");
}else {
for (int i=2;i<m;i++){
for(int j=m;j>i;j--){
if(sushu(i)&&sushu(j)){
if(i+j==m){
System.out.println(m+"="+i+"+"+j);
}
}
} }
}
}
public static boolean sushu(int x) {
for (int i=2;i<x;i++){
if(x%i==0){
return false;
}
}
return true;
}
}
数组
14、定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，平均值，和值，并输出出来。
/**
* 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，
* 最小值，平均值，和值，并输出出来。
*/
package com.demo3;
public class Practice14 {
public static void main(String[] args){
int[] arrayNumber;
arrayNumber = new int[10];
System.out.println("以下是随机的10个整数：");
//随机填入10个数字
for (int i=0;i<arrayNumber.length;i++){
arrayNumber[i]=(int)(100*Math.random());
System.out.print(arrayNumber[i]+" ");
}
System.out.println();
int min=arrayNumber[0];
int max=arrayNumber[0];
int sum=0;
//max min 疑点
for(int i =0;i<arrayNumber.length;i++){
if (max<arrayNumber[i]){
max=arrayNumber[i];} //求最大值;
if(min>arrayNumber[i]){
min=arrayNumber[i]; //求最小值
}
sum = sum+arrayNumber[i];
}
System.out.println("其中max="+max+" min="+min+" sum="+sum+" avg="+sum/10.0);
}
}
15、
定义一个int型的一维数组，包含10个元素，分别赋值为1~10， 然后将数组中的元素都向前移一个位置，
即，a[0]=a[1],a[1]=a[2],…最后一个元素的值是原来第一个元素的值，然后输出这个数组。
/**
* 定义一个int型的一维数组，包含10个元素，分别赋值为1~10， 然后将数组中的元素都向前移一个位置，
* 即，a[0]=a[1],a[1]=a[2],…最后一个元素的值是原来第一个元素的值，然后输出这个数组。
*/
package com.demo3;
import java.util.Arrays;
public class Practice15 {
public static void main(String[] args){
int[] arrayNumber;
arrayNumber = new int[10];
//循环迭代
for(int i =0;i<10;i++){
arrayNumber[i]=i+1;
System.out.print(arrayNumber[i]+" ");
}
System.out.println();
System.out.println(Arrays.toString(arrayNumber));
int temp = arrayNumber[0];
for(int i =0;i<arrayNumber.length-1;i++){
arrayNumber[i] = arrayNumber[i+1];
}
arrayNumber[arrayNumber.length-1]=temp;
System.out.println(Arrays.toString(arrayNumber));
}
}
16、
定义一个int型的一维数组，包含40个元素，用来存储每个学员的成绩，循环产生40个0~100之间的随机整数，将它们存储到一维数组中，然后统计成绩低于平均分的学员的人数，并输出出来。
16.1、承上题，将这40个成绩按照从高到低的顺序输出出来。
/**
* 定义一个int型的一维数组，包含40个元素，用来存储每个学员的成绩，循环产生40个0~100之间的随机整数，
* 将它们存储到一维数组中，然后统计成绩低于平均分的学员的人数，并输出出来。
* 承上题，将这40个成绩按照从高到低的顺序输出出来。
*/
package com.demo3;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
public class Practice16 {
public static void main(String[] args){
int[] arrayNumber;
arrayNumber = new int[40];
System.out.println("以下是40个同学的随机成绩：");
for(int i=0;i<arrayNumber.length;i++){
//arrayNumber[i]=(int)(100*Math.random());
arrayNumber[i]=new Random().nextInt(100); //另一种随机取数的方式
System.out.print(arrayNumber[i]+" ");
}
System.out.println();
double sum=0,avg=0;
for(int i=0;i<arrayNumber.length;i++){
sum=sum+arrayNumber[i];
}
avg=sum/arrayNumber.length;
int cnt=0;
for(int i=0;i<arrayNumber.length;i++){
if(arrayNumber[i]<avg){
cnt=cnt+1;
}
}
System.out.println("成绩低于平均分的学员的人数:"+cnt);
//冒泡排序: 从序列的一端开始向另一端冒泡，可以从左往右冒泡，也可以从右往左冒泡，依次比较相邻的两个数的大小(比大还是比小看要求)。
for(int i=0;i<arrayNumber.length-1;i++){
for (int j=0;j<arrayNumber.length-1-i;j++){
if(arrayNumber[j]<arrayNumber[j+1]){
int temp=arrayNumber[j];
arrayNumber[j]=arrayNumber[j+1];
arrayNumber[j+1]=temp;
}
}
}
System.out.println("冒泡排序结果："+Arrays.toString(arrayNumber));
//选择排序：首先，找到数组中最小(最大)的元素，拎出来，将它和数组的第一个元素交换位置，
// 第二步，在剩下的元素中继续寻找最小(最大)的元素，拎出来，和数组的第二个元素交换位置，如此循环，知道整个数组排序完成。
//标记第一个为待比较的数
//然后从后面遍历与第一个数比较
//如果小,就交换最小值
//保存最小元素的下标
//找到最小值后，将最小的值放到第一的位置，进行下一遍循环
for(int i=0;i<arrayNumber.length-1;i++){
int index =i;
for(int j=i+1;j<arrayNumber.length;j++){
if(arrayNumber[j]>arrayNumber[index]){
index=j;
}
}
int temp = arrayNumber[index];
arrayNumber[index]=arrayNumber[i];
arrayNumber[i]=temp;
}
System.out.println("选择排序结果："+Arrays.toString(arrayNumber));
}
}
17、编写程序，将一个数组中的元素倒排过来。例如原数组为1，2，3，4，5；则倒排后数组中的值为5，4，3，2，1。
/**
* 编写程序，将一个数组中的元素倒排过来。例如原数组为1，2，3，4，5；则倒排后数组中的值为5，4，3，2，1。
*/
package com.demo3;
import java.util.Arrays;
import java.util.Random;
public class Practice17 {
public static void main(String[] args){
//随机生成一组数据
int[] arrayNumber;
arrayNumber = new int[10];
for(int i=0;i<arrayNumber.length;i++){
//arrayNumber[i]=new Random().nextInt(10); //会出现重复数据
arrayNumber[i]=(int)(100*Math.random());
}
System.out.print("原始数组数据："+Arrays.toString(arrayNumber));
System.out.println();
//元素倒排不一定是从小到大变成从大到小,而是位置的置换
for (int i=0;i<arrayNumber.length/2;i++){
int temp=arrayNumber[i];
arrayNumber[i]=arrayNumber[arrayNumber.length-i-1];
arrayNumber[arrayNumber.length-i-1]=temp;
}
System.out.println("数组元素倒排后的数据："+Arrays.toString(arrayNumber));
}
}
18、要求定义一个int型数组a,包含100个元素,保存100个随机的4位数。再定义一个int型数组b，包含10个元素。统计a数组中的元素对10求余等于0的个数，保存到b[0]中；对10求余等于1的个数，保存到b[1]中，……依此类推。
/**
* 要求定义一个int型数组a,包含100个元素,保存100个随机的4位数。
* 再定义一个int型数组b，包含10个元素。
* 统计a数组中的元素对10求余等于0的个数，保存到b[0]中；
* 对10求余等于1的个数，保存到b[1]中，
* 对10求余等于2的个数，保存到b[0]中，……依此类推。
*/
package com.demo3;
import java.util.Arrays;
import java.util.Random;
public class Practice18 {
public static void main(String[] args){
int[] a;
int[] b;
a=new int[100];
b=new int[10];
//取a数组100个随机的4位数;
for (int i=0;i<a.length;i++){
a[i]=(int)(10000* Math.random());
}
System.out.println("a数组："+Arrays.toString(a));
统计 a 数组中的元素对 10 求余的各个的数目
int k,cnt;
for(int j=0;j<b.length;j++){
for (k=0,cnt=0;k<a.length;k++){
if((a[k]%10)==j){
cnt = cnt+1;
}
b[j]=cnt;
}
System.out.printf("b[%d]=%d \n",j,b[j]);
}
}
}
19、定义一个20*5的二维数组，用来存储某班级20位学员的5门课的成绩；
这5门课 按存储顺序依次为：core C++，coreJava，Servlet，JSP和EJB。
（1）循环给二维数组的每一个元素赋0~100之间的随机整数。
（2）按照列表的方式输出这些学员的每门课程的成绩。
（3）要求编写程序求每个学员的总分，将其保留在另外一个一维数组中。
（4）要求编写程序求所有学员的某门课程的平均分。
/**
* 定义一个20*5的二维数组，用来存储某班级20位学员的5门课的成绩；这5门课
* 按存储顺序依次为：core C++，coreJava，Servlet，JSP和EJB。
* （1）循环给二维数组的每一个元素赋0~100之间的随机整数。
* （2）按照列表的方式输出这些学员的每门课程的成绩。
* （3）要求编写程序求每个学员的总分，将其保留在另外一个一维数组中。
* （4）要求编写程序求所有学员的某门课程的平均分。
*/
package com.demo3;
import java.util.Random;
public class Practice19 {
public static void main(String[] args){
Random rd = new Random();
int[][] stu=new int[20][5];
int[] ssum = new int[20];//每个学员的总分,学员有20个
int[] cavg = new int[5]; //每门课程的平均分，课程共有5门
int a=0;
System.out.println("学号"+"\t\t"+"core C++"+"\t"+"coreJava"+"\t"
+"Servlet"+"\t\t"+"JSP"+"\t\t\t"+"EJB"+"\t\t\t"+"总成绩");//输出课程目录
for(int i=0;i<stu.length;i++){
System.out.print(i+1+"\t\t");//输出学生学号
for(int j=0;j<stu[i].length;j++){
stu[i][j]=rd.nextInt(50)+50; //随机赋值 +50保证数据不至于太低
System.out.print(stu[i][j]+"\t\t\t");
ssum[i]=ssum[i]+stu[i][j]; //求和：求一个学生的总成绩
cavg[j]=cavg[j]+stu[i][j]; //求单科成绩的全班同学总分
}
a=a+ssum[i]; //总成绩求和
System.out.print(" ");
System.out.println(ssum[i]);
}
System.out.print("平均分"+"\t");
for (int i = 0; i < cavg.length; i++) {
System.out.print(cavg[i]/20.0+"\t\t");
}
System.out.print(a/20.0);
}
}
20、判断随机整数是否是素数
产生100个0-999之间的随机整数，然后判断这100个随机整数哪些是素数，哪些不是？
/**
* 判断随机整数是否是素数
* 产生100个0-999之间的随机整数，然后判断这100个随机整数哪些是素数，哪些不是？
*/
package com.demo3;
import java.util.Arrays;
public class Practice20 {
public static void main(String[] avgs){
int[] arrayNumber;
arrayNumber = new int[100];
for(int i=0;i<arrayNumber.length;i++){
arrayNumber[i]=(int)(1000*Math.random());//产生100个0-999的随机数
}
System.out.println(Arrays.toString(arrayNumber));
StringBuilder primeBuilder = new StringBuilder();
StringBuilder notPrimeBuilder = new StringBuilder();
for(int i : arrayNumber) {
if(isPrime(i)) {
primeBuilder.append(i + ",");
} else {
notPrimeBuilder.append(i + ",");
}
}
System.out.println("素数有：" + primeBuilder.toString());
System.out.println("非素数有：" + notPrimeBuilder.toString());
}
//判断是否为素数
public static boolean isPrime(int num) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
//System.out.println(num + "第一个被" + i + "整除！");
return false;
}
}
return true;
}
}
21、某公司的雇员分为以下若干类：
某公司的雇员分为以下若干类：
Employee：这是所有员工总的父类，属性：员工的姓名和生日月份。
方法：getSalary(int month) 根据参数月份来确定工资，如果该月员工过生日，
则公司会额外奖励100元。
SalariedEmployee：Employee的子类，拿固定工资的员工。属性：月薪
HourlyEmployee：Employee的子类，按小时拿工资的员工，每月工作超出160
小时的部分按照1.5倍工资发放
属性：每小时的工资、每月工作的小时数
SalesEmployee：Employee的子类，销售人员，工资由月销售额和提成率决定
属性：月销售额、提成率
BasePlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，
工资由底薪加上销售提成部分 属性：底薪。
/**
* 在原有的雇员练习上修改代码
* 公司会给SalaryEmployee每月另外发放2000元加班费,给
* BasePlusSalesEmployee发放1000元加班费
* 改写原有代码,加入以上的逻辑
* 并写一个方法,打印出本月公司总共发放了多少加班费
* @author Administrator
*
*/
package com.demo3;
/**
* 某公司的雇员分为以下若干类：
* Employee：这是所有员工总的父类，属性：员工的姓名和生日月份。
* 方法：getSalary(int month) 根据参数月份来确定工资，如果该月员工过生日，
* 则公司会额外奖励100元。
* SalariedEmployee：Employee的子类，拿固定工资的员工。属性：月薪
* HourlyEmployee：Employee的子类，按小时拿工资的员工，每月工作超出160
* 小时的部分按照1.5倍工资发放
* 属性：每小时的工资、每月工作的小时数
* SalesEmployee：Employee的子类，销售人员，工资由月销售额和提成率决定
* 属性：月销售额、提成率
* BasePlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，
* 工资由底薪加上销售提成部分 属性：底薪。
*/
/**
* 在原有的雇员练习上修改代码
* 公司会给SalariedEmployee每月另外发放2000元加班费,给BasePlusSalesEmployee发放1000元加班费
* 改写原有代码,加入以上的逻辑
* 并写一个方法,打印出本月公司总共发放了多少加班费
* @author Administrator
*
*/
//package com.demo3;
public class Practice21_1 {
public static void main(String[] args){
Employee[] employee = new Employee[10];
employee[0]=new Employee("昭君",2);
employee[1]=new SalariedEmployee("貂蝉",3,4500.00);
employee[2]=new HourlyEmployee("赵云",3,200,15);
employee[3]=new SalesEmployee("吕布",5,400000,0.05);
employee[4]=new BasePlusSalesEmployee("刘备",8,400000,0.01,5000);
employee[5]=new SalariedEmployee("小乔",6,8800.00);
employee[6]=new SalariedEmployee("大乔",2,6500.00);
employee[7]=new SalariedEmployee("周瑜",4,5500.00);
employee[8]=new BasePlusSalesEmployee("张飞",8,900000,0.01,5000);
employee[9]=new BasePlusSalesEmployee("关羽",8,700000,0.01,5000);
int month = 2;//设置本月为2月
System.out.println("三国集团"+month+"月的工资表为：");
for (int i=0;i<employee.length;i++){
System.out.println(employee[i].getName()+":"+employee[i].getSalary(month));
}
//统计加班费：
//instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
int result = 0;
int result1=0;
int result2=0;
for(int i=0;i<employee.length;i++){
if(employee[i] instanceof SalariedEmployee){
SalariedEmployee s = (SalariedEmployee)employee[i];
result1 = result1+s.getAddtinoalSalary();
}
if(employee[i] instanceof BasePlusSalesEmployee){
BasePlusSalesEmployee b = (BasePlusSalesEmployee)employee[i];
result2 = result2+b.getAddtinoalSalary();
}
//result = result1+result2;
}
result = result1+result2;
System.out.println("加班费："+result);
}
}
//Employee：这是所有员工总的父类，属性：员工的姓名和生日月份。
// 方法：getSalary(int month) 根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励100元。
class Employee{
private String name;
private int birth;
public Employee(String name,int birth){
this.name = name;
this.birth = birth;
}
public String getName(){
return name;
}
public double getSalary(int month){
if(month==birth){
return 100;
}
return 0;
}
}
//SalariedEmployee：Employee的子类，拿固定工资的员工。属性：月薪
class SalariedEmployee extends Employee{
private double salary;
public SalariedEmployee(String name,int birth,double salary){
super(name, birth);
this.salary=salary;
}
public int getAddtinoalSalary(){
return 2000;
}
public double getSalary(int month){
return salary+super.getSalary(month)+getAddtinoalSalary();
}
}
//HourlyEmployee：Employee的子类，按小时拿工资的员工，每月工作超出160小时的部分按照1.5倍工资发放
// 属性：每小时的工资、每月工作的小时数
class HourlyEmployee extends Employee{
public double hourSalary;
public int hour;
public HourlyEmployee(String name,int birth,int hour,double hourSalary){
super(name, birth);
this.hour = hour;
this.hourSalary = hourSalary;
}
public double getSalary(int month){
if (hour<=160){
return hourSalary*hour+super.getSalary(month);
} else {
return 160*hourSalary+(hour-160)*hourSalary*1.5+super.getSalary(month);
}
}
}
//SalesEmployee：Employee的子类，销售人员，工资由月销售额和提成率决定
// 属性：月销售额、提成率
class SalesEmployee extends Employee{
public double sales;
public double pre;
public SalesEmployee(String name,int birth,double sales,double pre){
super(name, birth);
this.sales = sales;
this.pre = pre;
}
public double getSalary(int month){
return sales*pre+super.getSalary(month);
}
}
//BasePlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，
//工资由底薪加上销售提成部分 属性：底薪。
class BasePlusSalesEmployee extends SalesEmployee{
private double baseSalary;
public BasePlusSalesEmployee(String name, int birth, double sales, double pre, double baseSalary) {
super(name, birth, sales, pre);
this.baseSalary = baseSalary;
}
public int getAddtinoalSalary(){
return 1000;
}
public double getSalary(int month) {
return baseSalary +sales*pre+ super.getSalary(month)+getAddtinoalSalary();
}
}
经典算法：
1. 某学校为学生分配宿舍，每6个人一间房（不考虑性别差异），问需要多少房？
答案： (x+5)/6
注意理解int类型数值。
2、让数值在 0～9 之间循环。
/**
* 让数值在 0～9 之间循环。
*/
package com.demo3;
public class Practice22 {
public static void main(String[] args){
int i=0;
while(true){
i=(i+1)%10;
System.out.println(i);
}
}
}
1、写一个数组类（放对象）：
功能包括：添加(添加不限制多少项)、修改、插入、删除、查询
2、作业 10-08
1. 随机产生 20 个整数(10以内的)，放入一个ArrayList中， 用迭代器遍历这个ArrayList
2. 并删除其中为 5 的数
3. 再产生 3 个整数，插入到位置 4 处
4. 把所有值为 1 的数都变成 10
3、产生 3000 个 10 以内的数，放入 hashSet 遍历它，打印每一个值
/***
* 1. 产生 3000 个 10 以内的数，放入 hashSet
* 2. 遍历它，打印每一个值
*/
package com.demo3;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
public class Practice24 {
public static void main(String[] args){
Random r = new Random();
HashSet hs1 = new HashSet();
for(int i=0; i<3000; i++){
hs1.add(r.nextInt(10));
}
//由于 HashSet 不能重复，所以只有10个数在里面，按哈希排序
Iterator it1 = hs1.iterator();
while(it1.hasNext()) {
System.out.print(it1.next() + " ");
}
}
}
/***
* 1. 产生 3000 个 10 以内的数，放入 hashSet
* 2. 遍历它，打印每一个值
*/
package com.demo3;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
public class Practice24_1 {
public static void main(String[] args) {
int[] arrayNumber;
arrayNumber = new int[3000];
for (int i = 0; i < arrayNumber.length; i++) {
arrayNumber[i] = (int) (10 * Math.random());
}
System.out.println("3000个10以内的随机数为：");
System.out.println(Arrays.toString(arrayNumber));
//放入hashSet中
//由于 HashSet 不能重复，所以只有10个数在里面，按哈希排序
HashSet hs1 = new HashSet();
for (int i=0;i<arrayNumber.length;i++){
hs1.add(arrayNumber[i]);
//System.out.println(hs1);
}
Iterator it1 = hs1.iterator();
while(it1.hasNext()) {
System.out.print(it1.next() + " ");
}
}
}
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
