JAVA小白 编程练习500题 超详细!!!带答案!!!持续更新中~

System.out.println(“存款” + year + “年后的本息是：” + outMoney);

}

}

练习题：求税后工资问题

2019年1月1日起，国家推出新的个人所得税政策，起征点上调值5000元。也就是说税前工资扣除三险一金（三险一金数额假设是税前工资的10%）后如果不足5000元，则不交税。如果大于5000元，那么大于5000元的部分按梯度交税，具体梯度比例如下：

​ 0 ~ 3000元的部分，交税3%

​ 3000 ~ 12000元的部分，交税10%

​ 12000 ~ 25000的部分 ， 交税20%

​ 25000 ~ 35000的部分，交税25%

​ 35000 ~ 55000的部分，交税30%

​ 55000 ~ 80000的部分，交税35%

​ 超过80000的部分，交税45%

比如：小蓝入职一家企业后，税前工资是18000，则他每月该交个税的部分是18000-1800-5000=11200元，个税缴纳数额是3000×3%+8200×10%=910元。税后工资15290元。

请完成一个个税计算程序，在用户输入税前工资后，计算出他对应的纳税数额，以及税后工资为多少？

import java.util.Scanner;

public class Demo5 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println(“请输入您的税前工资：”);

//2.键盘录入税前工资

int money = sc.nextInt();

//3.计算应纳税部分的工资

double before = money - (money*0.1) - 5000;

//4.定义个税变量

double shui = 0;

//5.按照梯度范围计算个税数值

if(before > 0 && before <=3000){

shui = before * 0.03;

}else if(before > 3000 && before <=12000){

shui = 3000*0.03 + (before-3000) * 0.1;

}else if(before > 12000 && before <=25000){

shui = 30000.03 + 90000.1 + (before-12000)*0.2;

}else if(before > 25000 && before <=35000){

shui = 30000.03 + 90000.1 + 13000*0.2 + (before-25000)*0.25;

}else if(before > 35000 && before <=55000){

shui = 30000.03 + 90000.1 + 130000.2 + 100000.25 + (before-35000)*0.3;

}else if(before > 55000 && before <=80000){

shui = 30000.03 + 90000.1 + 130000.2 + 100000.25 + 20000*0.3 + (before-55000)*0.35;

}else if(before > 80000){

shui = 30000.03 + 90000.1 + 130000.2 + 100000.25 + 200000.3 + 250000.35 + (before-80000)*0.45;

}

//6.计算税后工资

double after = money - (money*0.1) - shui;

//7.打印个税和税后工资

System.out.println(“个人所得税” + shui + “元”);

System.out.println(“税后工资” + after + “元”);

}

}

练习题: 手机选号:根据用户输入的手机号来确认用户实际支付的价格

如果尾数为8，需支付办卡费50元

如果尾数为4，需支付办卡费用0元

如果是其他尾号,需支付办卡费用20元

package cn.cxy.exec;

import java.util.Scanner;

public class PayCard {

public static void main(String[] args) {

//1.提示并接收用户输入的手机号

System.out.println(“请输入您预选的手机号：”);

String tel = new Scanner(System.in).nextLine();//注意String类型数据一般用nextLine()

//2.调用getPrice()方法，来计算价格,注意需要把手机号tel作为参数传入方法中

getPrice(tel);

}

//3.创建getPrice()

public static void getPrice(String tel) {

//3.1 手机号tel的长度，必须是11位的正确手机号–提前校验,提高程序健壮性

if(tel.length() != 11) {

System.out.println(“号码格式错误”);

return;//结束方法，返回到调用位置再继续执行

}

/*比如我们拿到的手机号是tel=“2313123123”,想要拿到尾数,也就是最后一个字符

• 需要用到 char c = tel.charAt(10)

• 注意:由于下标也是从0开始,所以取第11个字符，它的下标位置是10

*/

//3.2获取手机号的尾数

char c = tel.charAt(10);

//3.2定义用来保存最终结果的变量price,初始值为0

int price = 0;

//3.3根据c字符的值，来为price重新赋值

switch© {

case ‘8’: price=50; break;//尾数为8支付50

case ‘4’: price=0; break;//尾数为4免费

default: price=20;//其他情况需支付20

}

//3.4显示结果

System.out.println(“您实际应支付的价格为：”+price);

}

}

练习题: 获取邮箱名字

接收用户输入的邮箱名，获取邮箱的名字

比如：cxy@163.com,输出cxy

package cn.cxy.exec;

import java.util.Scanner;

public class GetEmailName {

public static void main(String[] args) {

System.out.println(“输入email:”);

String e = new Scanner(System.in).nextLine();

//email地址e，传递到该方法，

//并得到方法返回的名字，保存到变量n

String n = getName(e);

System.out.println(n);

}

static String getName(String email) {

/*

• “sdfwerw@rewerwe.com”

•     |
  

•     index
  

• 1. 定位 “@” 的下标位置 index
• 2. 截取 [0, index)，直接返回

• email.indexOf(“@”)

•    查找指定子串的位置
  

•    找不到，得到特殊值 -1
  

• email.substring(0, index)

•    截取 [0, index)
  

*/

//找@的位置

int index = email.indexOf(“@”);

if(index == -1) {//找不到

return “邮箱格式错误”;

}

//截取，直接返回截取的结果

return email.substring(0, index);

}

}

练习题 : 分别通过for循环/While循环/do-While循环写一个死循环

package cn.cxy.exec;

public class DeadCycle {

public static void main(String[] args) {

//for循环的死循环

// for (int i = 1; ; i++){

// System.out.println(“欢迎学习泡泡的分享,继续加油哦~”);

// }

//while循环的死循环

// while(true){

// System.out.println(“都到这里啦?奥利给~”);

// }

//do-while循环的死循环

do{

System.out.println(“相信我们可以的~”);

}while(true);

}

}

练习题: 鸡兔同笼问题(穷举法)

已知:鸡兔共35只,共94只脚,那么鸡和兔各几只?

package cn.cxy.exec;

//穷举法

//鸡 兔

//0 35

//1 34

//2 33

//3 32

//…

//23 12

//…

//35 0

public class SameCage {

public static void main(String[] args) {

//循环变量j,控制小鸡的个数: 0到35递增

//循环变量t,控制兔子的个数: 35到0递减

for(int j=0,t=35; j<=35; j++,t–) {//如果有多个小条件,用逗号隔开

//保证脚的数量是94

if(j2 + t4 == 94) {

System.out.println(“鸡：”+j+“， 兔：”+t);

}

}

}

}

练习题:商品录入系统

通过java基础的相关知识，设计并完成一个简单的商品录入系统，可以实现：菜单显示、商品信息展示、商品信息录入、商品信息查询、退出的功能

package cn.cxy.exec;

import java.util.Scanner;

public class Product {

//成员变量

static String[] names = {“iPhoneXS”,“华为 Mate 20 pro”,“小米X”,“vivo NEX”,“oppo Find”};

static double[] price = {8999,5399,2399,4399,3999};

static int[] numbers = {50,20,80,120,90};

public static void main(String[] args) {

/*

• ---

• 1. 商品列表
• 2. 商品录入
• 3. 商品查询
• 4. 统计信息
• 5. 退出

• ---

• 选择：> 1

• …

*/

//死循环显示菜单

outer:

while(true) {

//显示菜单，并获得选择的值

int c = menu();

//判断c的值

switch© {

case 1: f1(); break;

case 2: f2(); break;

case 3: f3(); break;

case 4: f4(); break;

case 5: break outer;

}

}

}

private static int menu() {

System.out.println(“----------------------”);

System.out.println(“1. 商品列表”);

System.out.println(“2. 商品录入”);

System.out.println(“3. 商品查询”);

System.out.println(“4. 统计信息”);

System.out.println(“5. 退出”);

System.out.println(“----------------------”);

System.out.print("选择：> ");

return new Scanner(System.in).nextInt();

}

private static void f1() {

/*

names

[“A”, “B”, “C”]

price

[2, 8, 3]

numbers

[200, 300, 180]

0 1 2

1. 名称：xx，价格：xx，数量：xx

*/

for(int i=0;i<names.length;i++) {

String n = names[i];

double p = price[i];

int b = numbers[i];

System.out.println(

(i+1)+“. 名称：”+n+“，价格：”+p+“，数量：”+b);

}

}

private static void f2() {

/*

names

[“A”, “B”, “C”]

price

[2, 8, 3]

numbers

[200, 300, 180]

0 1 2

*/

//遍历数组

for (int i = 0; i < names.length; i++) {

System.out.println(“录入第”+(i+1)+“件商品：”);

System.out.print(“名称：”);

String n = new Scanner(System.in).nextLine();

System.out.print(“价格：”);

double p = new Scanner(System.in).nextDouble();

System.out.print(“数量：”);

int b = new Scanner(System.in).nextInt();

names[i] = n;

price[i] = p;

numbers[i] = b;

}

//重新显示商品列表

f1();

}

private static void f3() {

/*

names

[“A”, “B”, “C”]

price

[2, 8, 3]

numbers

[200, 300, 180]

0 1 2

字符串，比价是否相等，要用equals()方法

a = “aaa”

b = “aaa”

a.equals(b)

*/

System.out.print(“输入查询的商品名：”);

String n = new Scanner(System.in).nextLine();

//遍历数组

for (int i = 0; i < names.length; i++) {

// n 和 names[i] 相等

if(n.equals(names[i])) {

String name = names[i];

double p = price[i];

int b = numbers[i];

System.out.println(

(i+1)+“. 名称：”+name+“，价格：”+p+“，数量：”+b);

return;

}

}

//循环结束，所有商品都比较完，没有找到

System.out.println(“找不到商品”);

}

private static void f4() {

/*

names

[“A”, “B”, “C”]

price

[2, 8, 3]

numbers

[200, 300, 180]

0 1 2

*/

//商品总价，单价均价，最高单价，最高总价

double spzj = 0;//商品总价

double djzj = 0;//单价总价

double zgdj = 0;//最高单价

double zgzj = 0;//最高总价

//遍历数组

for (int i = 0; i < names.length; i++) {

spzj += price[i] * numbers[i];

djzj += price[i];

//数组中，找到更大的值

if(price[i] > zgdj) {

zgdj = price[i];//更大值存到这个变量

}

if(price[i]*numbers[i] > zgzj) {

zgzj = price[i]*numbers[i];

}

}

System.out.println(“商品总价：”+spzj);

System.out.println(“单价均价：”+(djzj/names.length));

System.out.println(“最高单价：”+zgdj);

System.out.println(“最高总价：”+zgzj);

}

}

练习题:求数字阶乘(for循环版)

需求:接收用户输入的数字,计算该数字的阶乘结果

已知:负数不可以有阶乘,0的阶乘结果是1,

5 ! = 5 x 4 x 3 x 2 x 1

package cn.cxy.exec;

import java.util.Scanner;

public class Factorial {

public static void main(String[] args) {

System.out.print(“输入整数，求阶乘：”);

int n = new Scanner(System.in).nextInt();

//调用f()方法，把n的值传递到f()方法，求阶乘

f(n);

}

public static void f(int n) {

if(n<0) {

System.out.println(“负数不可以求阶乘”);

return;//方法结束，返回到调用位置继续执行

}

if(n == 0) {

System.out.println(“0的阶乘是1”);

return;

}

/*

• r = 5

• i

• 4, r=r*i

• 3, r=r*i

• 2, r=r*i

• 1, r=r*i

*/

long r = n;

for(int i=n-1; i>=1; i–) {

r *= i;

}

System.out.println(n+“的阶乘：”+r);

}

}

/**其实我们还可以通过递归思想解决这个问题,感兴趣的可以研究一下~*/

练习题:多次生成随机数,并打印第一次出现大于0.999 时的次数与生成的随机数

package cn.cxy.exec;

public class ForBreak {

public static void main(String[] args) {

// Math.random()可以产生[0,1)的随机浮点数

// >0.999

//写一个死循环, i变量用来计次

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

double d = Math.random();

if(d>0.999) {

System.out.println(“第”+i+“次产生了目标值,值为:”+d);

break;

}

}

}

}

练习题:打印100以内除了尾数为3,5,7的所有数

package cn.cxy.exec;

public class ForContinue {

public static void main(String[] args) {

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

int y = i%10;//100以内的数,通过取余求出尾数

if(y3 || y5 || y==7) {

continue;//如果尾数为3 5 7 ,则跳过后面的打印,进行下一轮循环

}

System.out.println(i);

}

}

}

练习题:求质数:接收用户输入的数字,判断是否为质数

质数的概念:一个大于1的自然数,除了1和它自身外,不能被其他自然数整除的数叫做质数,也称为素数

规定:1既不是质数,也不是合数

package cn.cxy.exec;

import java.util.Scanner;

public class PrimeNumber {

public static void main(String[] args) {

System.out.print(“请输入要判断的自然数：”);

int n = new Scanner(System.in).nextInt();

//调用getPrimeNumber()方法，判断n是否为质数

getPrimeNumber(n);

}

public static void getPrimeNumber(int n) {

if(n<2) {//此范围内的数均不为质数

System.out.println(n+“不是质数”);

return;//结束程序

}

if(n == 2) {

System.out.println(“2是质数”);

return;

}

//在 2到 1+n开方范围(数学理论)，找能把n整除的值(这个值也称作因子)

//如果找到可以把n整除的第三个数，那n就不是质数,反之,n为质数

double max = 1+ Math.sqrt(n);//max保存的是查找因子的范围

//依次遍历范围内的所有数,验证是否存在n的因子

for(int i=2; i<max; i++) {

//判断n能不能被i整除,如果有,说明不是质数

if(n%i == 0) {

System.out.println(n+“不是质数”);

return;

}

}

//如果判断了范围内的所有值，没有能整除的,则说明n是质数

System.out.println(n+“是质数”);

}

}

练习题:接收用户输入的数字,判断在此范围内质数的个数

package cn.cxy.exec;

import java.util.Scanner;

public class CountPrimeNumber {

public static void main(String[] args) {

System.out.println(“输入整数n，求n内质数的数量”);

int n = new Scanner(System.in).nextInt();

count(n);

}

public static void count(int n) {

if(n<2) {

System.out.println(“没有质数”);

return;

}

if(n==2) {

System.out.println(“有1个质数”);

return;

}

//定义计数变量

int count = 1;//已知有一个质数

outer: //从3到n寻找质数

for(int i=3; i<=n ;i++) {

//判断i是否是质数

double max = 1+ Math.sqrt(i);

for(int j=2; j<max; j++) {//在2到<max，找能把i整除的数

if(i%j == 0) {//i被j整除，i不是质数

//跳到i++，继续判断下一个i值

continue outer;//跳到外部outer的位置

}

}

//内层j循环结束，i是质数

count++;

}

System.out.println(n+“内质数的数量：”+count);

}

}

练习题:生成一个顺序数组,将这个数组的元素打乱顺序后输出

package cn.cxy.exec;

import java.util.Arrays;

import java.util.Random;

public class ShuffleArray {

public static void main(String[] args) {

//调用f()方法，从方法获取一个int[]数组

int[] a = f();

//遍历打印数组数据

for(int i=0; i<a.length; i++) {

System.out.println(a[i]);

}

System.out.println(“\n\n----------------”);

//把a数组，传递到 shuffle() 方法打乱顺序

shuffle(a);

//打印乱序后的数组

System.out.println(Arrays.toString(a));

}

public static int[] f() {

//新建int[]数组，长度5

//再把它的内存地址存到变量 a

int[] a = new int[5];

//遍历访问5个位置，填入1,2,3,4,5

for(int i=0; i<a.length; i++) {

a[i] = i+1;

}

//返回数组，把数组返回到调用位置

//本质是把数组地址返回去

return a;

}

public static void shuffle(int[] a) {

/*

•    j
  

• [4, 2, 3, 1, 5]

• i
  

• *) i循环遍历数组

• *) 随机定位下标j与i交换

*/

for (int i = 0; i < a.length; i++) {

//随机下标j，范围：[0, a.length)

int j = new Random().nextInt(a.length);

int t = a[i];

a[i] = a[j];

a[j] = t;

}

}

}

练习题:打印全三角形

需求:接收用户输入的行数,打印对应的全三角形,如图所示:

package cn.cxy.exec;

import java.util.Scanner;

public class PrintTraingle {

public static void main(String[] args) {

//1.提示并接收用户输入的行数:

System.out.println(“请输入您要打印星星的行数:”);

int n = new Scanner(System.in).nextInt();

//2.开始打印图形

//2.1外层循环控制打印的行数 i的取值范围:[1,n],一共n行

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

//2.2内层循环1

//控制每行打印空格的个数 j的取值范围:[0,n-i),即1 2 3…

for(int j=0;j<n-i;j++){

System.out.print(" ");

}

//2.3内层循环2

//控制每行打印星星的个数 k的取值范围:[1,2*i-1],即1 3 5 …

for(int k=1;k<=2*i-1;k++){

System.out.print(“*”);

}

//2.4打印完本行所有内容后添加换行

System.out.println();

}

}

}

练习题：模拟双色球生成案例

需求：体彩中有一项是双色球，要求在1-33号共33个红色球里选出6个，1-16号共16个蓝色球中选出一个作为中奖号码，请实现这个需求

package cn.cxy.exec;

import java.util.Arrays;

import java.util.Random;

public class ColorBall {

public static void main(String[] args) {

//准备两个号码数组

int[] r = zbsz(33);//[1,2,3,4,5…33]

int[] b = zbsz(16);//[1,2,3…16]

System.out.println(Arrays.toString®);

System.out.println(Arrays.toString(b));

//选择红球

int[] red = selectRed®;

//选择蓝球

int blue = selectBlue(b);

System.out.println(“红球：”+Arrays.toString(red));

System.out.println(“蓝球：”+blue);

}

private static int[] zbsz(int n) {//准备数组的方法

//新建n个长度的int[]数组，存到a

int[] a = new int[n];

//遍历a数组，填入1到n

for (int i = 0; i < a.length; i++) {

a[i] = i+1;

}

//返回数组

return a;

}

private static int[] selectRed(int[] r) {//选择红球

/*

•                                       j
  

• r [10, 5, 1, 4, 2, 6, 7, 8, 9, 3, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33]

•                   i
  

•     [i, r.length)
  

•  i+ [0, r.length-i)
  

*/

//i循环从0到<6

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

//j随机定位

int j =

i+ new Random().nextInt(r.length-i);

int t = r[i];

r[i] = r[j];

r[j] = t;

}

//截取前6个位置，生成一个新数组返回

return Arrays.copyOf(r, 6);

}

private static int selectBlue(int[] b) {//选择蓝球

return b[new Random().nextInt(16)];

}

}

练习题:求任意自然数各位数之和

接收用户输入的任意自然数,累计所有位数数字之和

需求:接收用户输入的行数,

package cn.cxy.exec;

import java.util.Scanner;

public class SumNum {

public static void main(String[] args) {

//1.提示并接收用户要计算的自然数:

System.out.println(“请输出您要求和的自然数:”);

int n = new Scanner(System.in).nextInt();

//2.定义一个变量用来保存最终求和的结果

int sum=0;

//3.循环获取每一位上的数

while(n!=0){

//4.求当前的个位数,并将个位数累加

sum = sum + (n%10);

//5.去掉刚刚累加过的最后一位数,得到新的整数

//比如刚刚的十位就变成了现在的个位

n=n/10;

}

//6.打印最终的结果:

System.out.println(sum);

}

}

练习题:求任意数组中所有元素的最大值

package cn.cxy.exec;

public class GetArrayMaxNum {

public static void main(String[] args) {

//1.定义一个数组

int[] arr={90,1562,43,2,44,8,6666};

//2.选取数组中的第一个元素开始比较

int max=arr[0];

//3.依次遍历数组中的每个元素

for(int i=1;i<arr.length;i++){//i指的是下标,我们通过下标来操作数组中的元素

//4.判断当前元素与目前最大值的大小

if(arr[i]>max){

//5.如果当前数组元素大于max,就讲此元素的值赋值给max

max=arr[i];

}

}

//6.打印最终的结果

System.out.println(max);

}

}

练习题:求1000以内的完数

完数:如果一个数等于其所有因子之和,我们就称这个数为"完数",比如6的因子为1,2,3 6 = 1 + 2 + 3,那么6就是一个完数

package cn.cxy.exec;

/*获取1000以内的完数/

public class GetNum {

public static void main(String[] args) {

//1.循环遍历1000以内的所有数

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

//2.定义一个变量来保存求和的结果

int sum = 0;

//3.求i的因子

for(int j=1;j<=i/2;j++){

//4.判断是否能被整除

if(i % j == 0){

//5.如果能整除,就是因子,因子需要累加

sum+=j;

}

}

//6.如果因子累加之和为本轮判断的数,则当前数是完数,输出

if(sum==i){

System.out.println(i);

}

}

}

}

练习题： 随机数组的归并问题

需求：生成两个任意的随机数组，并将这两个数组按照数字大小按顺序归并到一个新数组中

package cn.cxy.exec;

import java.util.Arrays;

import java.util.Random;

import java.util.Scanner;

public class MergingArrays {

public static void main(String[] args) {

int[] a = suiJi();

int[] b = suiJi();

Arrays.sort(a);

Arrays.sort(b);

System.out.println(Arrays.toString(a));

System.out.println(Arrays.toString(b));

int[] c = heBing(a, b);

System.out.println(Arrays.toString©);

}

private static int[] suiJi() {

int n = 5+ new Random().nextInt(6);

int[] a = new int[n];

for (int i = 0; i < a.length; i++) {

a[i] = new Random().nextInt(100);

}

return a;

}

private static int[] heBing(int[] a, int[] b) {

/*

• a[1,1,2,3,4]

•          j
  

• b[1,2,4,5,6,8,9]

•     k
  

• c[ ]

•           i
  

*/

//新建数组

int[] c = new int[a.length+b.length];

//对新数组遍历

for(int i=0,j=0,k=0;i<c.length;i++) {

if(j>=a.length) {//j越界，b数组数据一个一个放入新数组

//c[i] = b[k];

//k++;

//continue;

System.arraycopy(b,k,c,i,b.length-k);

break;

} else if(k>=b.length) {//k越界,a数组数据一个个放入新数组

//c[i] = a[j];

//j++;

//continue;

System.arraycopy(a,j,c,i,a.length-j);

break;

}

//j和k，较小值放入i位置，并递增

if(a[j]<=b[k]) {

c[i] = a[j];

j++;

} else {

c[i] = b[k];

k++;

}

}

return c;

}

}

练习题：遍历二维数组打油诗

package cn.cxy.exec;

import java.util.Arrays;

import java.util.Random;

import java.util.Scanner;

public class TestArray {

public static void main(String[] args) {

char[][] a = {

//i

/0/{‘道’,‘路’,‘千’,‘万’,‘条’},

/1/{‘安’,‘全’,‘第’,‘一’,‘条’},

/2/{‘行’,‘车’,‘不’,‘规’,‘范’},

/3/{‘亲’,‘人’,‘两’,‘行’,‘泪’}

//0 1 2 3 4 j

};

/* j是外层循环，递增

• i是内层循环，递减

• 亲行安道

• 人车全路

• 两不第千

*/

for(int j=0;j<a[0].length;j++) {

for(int i=a.length-1; i>=0; i–) {

System.out.print(a[i][j]);

}

System.out.println();

}

}

}

练习题:求猴子大王

15个猴子围成一圈选大王,依次1-7循环报数,报到7的猴子被淘汰,直到最后一只猴子称为大王,问:哪只猴子会成为大王?

package cn.cxy.exec;

/*猴子选大王/

public class MonkeyKing {

public static void main(String[] args) {

//1.定义长度为15的数组保存猴子,boolean类型是为了判断猴子是否存活

boolean[] b=new boolean[15];

//2.依次遍历每一只猴子

//true—未淘汰 false—已淘汰

for(int i=0;i<b.length;i++){

b[i]=true;//先把所有猴子设置成存活

}

//3.定义变量保存猴子报的数

int num=0;

//4.定义变量保存剩余的猴子数

int monkeyLeft=15;

//5.定义数组下标

int index=0;

//6.循环,直到只剩最后一只猴子(猴子王)

while(monkeyLeft>1){//判断条件

//7.检测猴子是否已淘汰

if(b[index]){

//8.报数

num++;

//9.判断报数是否为7

if(num==7){

b[index]=false;//为7淘汰

monkeyLeft–;//猴子数减一

num=0;//报数归零

}

}

//10.下标移动

index++;

//11.围成一圈—最后一个置为0

if(index==15){

index=0;

}

}

//遍历数组,找到最后活着的那个猴子王

for(int i=0;i<b.length;i++){

if(b[i]){

System.out.println(i+1);

}

}

}

}

练习题:斐波那契问题

已知:斐波那契数列的前几个数分别为0,1,1,2,3,5…从第三项开始,每一项都等于前两项的和.请接收用户输入的整数n,求出此数列的前n项.

package cn.cxy.exec;

import java.util.Scanner;

/*斐波那契数列/

public class Faibonacci {

public static void main(String[] args) {

System.out.println(“请输入您要测试的数:”);

int n = new Scanner(System.in).nextInt();

//判断n是否是不正常的范围

if(n<1){

System.out.println(“输入数据有误！！！”);

}

//n==1

if(n==1){

System.out.println(0);

}

//n==2

if(n==2){

System.out.println(0+“\t”+1);

}

//n==3

if(n==3){

System.out.println(0+“\t”+1+“\t”+1);

}

//拼接前n项

if(n>3){

System.out.print(0+“\t”+1+“\t”+1+“\t”);

}

//循环输出后面的数据

int f1=1;

int f2=1;

int next=0;

for(int i=4;i<=n;i++){

next=f1+f2;

f1=f2;

f2=next;

System.out.print(next+“\t”);

}

}

}

练习题:古典问题：生兔兔问题

有一对兔子，从出生后第3个月起都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月兔子的对数为多少？

程序分析：前两个月兔子的对数为1

从第三个月开始，兔子的对数变成了 2 3 5 8 13 21 …

package cn.cxy.exec;

import java.util.Scanner;

public class GetRabbitNum {

public static void main(String[] args) {

System.out.println(“请输入要判断的月数：”);

int month = new Scanner(System.in).nextInt();

System.out.println(“第”+month+“月兔子的对数为：”+getSum(month));

}

public static int getSum(int month) {

//如果是前两个月，还是1对兔子

if(month == 1 || month == 2) {

return 1;

}else {

//从第三个开始，兔子按照2 3 5 8 13 21变化

return getSum(month-1)+getSum(month-2);

}

}

}

练习题:打印水仙花数

水仙花数：是指一个三位数，其各位数字立方和等于该数字本身

例如：153就是一个水仙花数，因为153 = 1³ + 5³ + 3³

package cn.cxy.exec;

public class GetNum {

public static void main(String[] args) {

//1.遍历所有的三位数

for (int i = 100; i < 1000; i++) {

//2.调用自定义方法判断是不是水仙花数

if(isAim(i)) {

//3.如果是水仙花数，就打印

System.out.println(i);

}

}

}

//4.自定义判断水仙花数的方法

public static boolean isAim(int a) {

int x = a/100;

int y = a/10%10;

int z = a%10;

if(a == xxx+yyy+zzz) {

return true;

}

return false;

}

}

练习题：面向对象 封装百分制分数

需求：封装百分制分数，和它对应的五档分制分数

分数类：

package cn.cxy.exec;

public class Score {

//成员变量

int score;

char level;

//构造方法

public Score(int score) {

this.score = score;

//计算五档分数，保存到成员变量level

this.level = setLevel(score);

}

private char setLevel(int s) {

char r = 0;

switch(s/10) {

case 10:case 9:

r = ‘A’;break;

case 8:case 7:

r = ‘B’;break;

case 6:

r = ‘C’;break;

case 5:case 4:case 3:case 2:

r = ‘D’;break;

case 1:case 0:

r = ‘E’;break;

}

return r;

}

public String toString() {

return score+", "+level;

}

}

测试类：

package cn.cxy.exec;

public class TestScore {

public static void main(String[] args) {

/*

A [90,100]

B [70,90)

C [60,70)

D [20,60)

E [0,20)

*/

Score s = new Score(54);

System.out.println(s.toString());

}

}

练习题:面向对象 打印图形

需求：设计一个可以随机打印形状的代码

形状类【父类】：

package cn.cxy.exec;

public class Shape {

public void draw() {

//无意义代码

//在子类中要重写draw()方法

System.out.println(“图形形状”);

}

public void clear() {

System.out.println(“\n\n\n”);

}

}

圆形类【子类】：

package cn.cxy.exec;

public class Circle extends Shape {

@Override

public void draw() {

System.out.println(“打印一个圆形 O”);

}

}

方形类【子类】：

package cn.cxy.exec;

public class Square extends Shape {

@Override

public void draw() {

System.out.println(“打印一个方形 口”);

}

}

直线类【子类】：

package cn.cxy.exec;

public class Line extends Shape {

@Override

public void draw() {

System.out.println(“打印一条直线 ————”);

}

public void length() {

System.out.println(“一米多。。。”);

}

}

测试类：随机生成图形

package cn.cxy.exec;

import java.util.Random;

import java.util.Scanner;

public class TestShape {

public static void main(String[] args) {

System.out.println(“按回车继续”);

while(true) {

int r = new Random().nextInt(4);

switch® {

case 0: f(new Shape()); break;

case 1: f(new Line()); break;

case 2: f(new Square()); break;

case 3: f(new Circle()); break;

}

}

}

/*

• Shape

• |- Line

• |- Square

• |- Circle

*/

static void f(Shape s) {

System.out.println(“----------------”);

new Scanner(System.in).nextLine();

s.draw();

//向上转型后，只能调用父类定义的通用成员

//子类特有成员不能调用

//s.length();

//s对象的真实类型是 Line 类型

if(s instanceof Line) {

//向下转型成Line类型，才能调用它特有的方法

Line line = (Line) s;

line.length();

}

new Scanner(System.in).nextLine();

s.clear();

}

}

练习题:面向对象 设计士兵类

需求：设计士兵与武器AK47类，并完成前进、进攻、发射子弹、装载子弹的功能

士兵类：

package cn.cxy.exec;

/*

• 封装：

• 士兵相关的属性数据、逻辑运算方法，
  

• 封装成一个士兵“类”组件
  

*/

import java.util.Random;

public class Soldier {

//成员变量，属性变量

int id; //默认值0

int blood = 100;

AK47 a;//默认 null 值

//成员方法

public void go() {

//this是一个特殊引用

//引用“当前对象”的地址

//当前对象：谁调用就是谁

//可以省略，缺省存在

System.out.println(this.id+“号士兵前进”);

}

public void attack() {

if(blood == 0) {

System.out.println(“这是”+id+“号士兵的尸体”);

return;//方法结束

}

System.out.println(id+“号士兵进攻”);

if(a != null) {

a.fire();//调用枪发射子弹

}

//模拟进攻掉血

//随机的减血量

int d = new Random().nextInt(10);

blood -= d;

if(blood < 0) {//不允许负数血量

blood = 0;

}

System.out.println(“血量：”+blood);

//血量是0

if(blood == 0) {

System.out.println(id+“号士兵阵亡”);

}

}

}

武器类：

package cn.cxy.exec;

import java.util.Random;

/*

• 封装：

• AK47武器相关的属性数据、运算代码，
  

• 封装成一个“类”组件
  

*/

public class AK47 {

int bullets = 100;

public void fire() {

if(bullets == 0) {

System.out.println(“没有子弹”);

return;

}

//随机产生发射子弹数量

int r = new Random().nextInt(10);

//要发射的数量，比现有子弹多

if(r > bullets) {

r = bullets;//有多少发多少

}

bullets -= r;

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

System.out.print(“突”);

}

System.out.println(“~”);

if(bullets == 0) {

System.out.println(“弹夹空了”);

}

}

public void load() {

bullets = 100;

System.out.println(“弹夹已装满”);

}

}

测试类1：

package cn.cxy.exec;

public class Test1 {

public static void main(String[] args) {

//新建 Soldier 士兵对象

//内存地址，保存到变量s1

Soldier s1 = new Soldier();

Soldier s2 = new Soldier();

//用s1引用第一个士兵对象

//为它的id赋值

s1.id = 9527;

s2.id = 9528;

//用s1找到第一个士兵对象

//让第一个士兵执行go()方法代码

s1.go();

s2.go();

//新建 AK47 对象，保存到s1.a

s1.a = new AK47();

s2.a = new AK47();

s2.attack();

s2.attack();

s2.attack();

s2.attack();

}

}

测试类2：

package cn.cxy.exec;

import java.util.Scanner;

public class Test2 {

public static void main(String[] args) {

//新建AK47对象，地址存到变量a

AK47 a = new AK47();

System.out.println(“按回车射击，输入load装载子弹”);

while(true) {

String s = new Scanner(System.in).nextLine();

if(s.equals(“load”)) {

a.load();

continue;

}

a.fire();

}

}

}

练习题:面向对象 设计宠物类

需求：设计宠物类，用户可以自由选择养猫还是养狗，可以给宠物起名字，还可以实现喂食互动的功能，宠物需要有饱食度和快乐度

宠物类【父类】：

package cn.cxy.exec;

public class Pet {

String name;

int full;

int happy;

public Pet(String name) {

this(name, 50, 50);

}

public Pet(String name,int full,int happy) {

this.name = name;

this.full = full;

this.happy = happy;

}

public void feed() {//宠物的喂食方法

if(full == 100) {

System.out.println(name+“已经吃饱了”);

return;

}

System.out.println(“给”+name+“喂食”);