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

某银行推出了整存整取定期储蓄业务，其存期分为一年、两年、三年、五年，到期凭存单支取本息。存款年利率表如下
​ 存期 年利率（%）
​ 一年 2.25
​ 两年 2.7
​ 三年 3.25
​ 五年 3.6
请存入一定金额（1000起存），存一定年限（四选一），计算到期后得到的本息总额。
提示
​ 存入金额和存入年限均由键盘录入
​ 本息计算方式本金+本金×年利率×年限

import java.util.Scanner;
public class BankDemo {
 public static void main(String[] args) {
  //1.提示并接收用户输入的存款金额
  System.out.println("请输入存款金额");
  int money = ne Scanner(System.in).nextInt();
  //2.提示并接收用户输入的存款年限
  System.out.println("请输入存款年限");
  int year = ne Scanner(System.in).nextInt();
  //3.定义变量用来保存本金和利息之和
  double outMoney = 0;
  //4.根据利率和年限计算本息和
  if (year == 1) {
   outMoney = money + money  2.25 / 100  1;
  } else if (year == 2) {
   outMoney = money + money  2.7 / 100  2;
  } else if (year == 3) {
   outMoney = money + money  3.25 / 100  3;
  } else if (year == 5) {
   outMoney = money + money  3.6 / 100  5;
  } else {
   System.out.println("输入的年限有误");
  }
  //5.打印输出
  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 = ne Scanner(System.in);
  System.out.println("请输入您的税前工资");
  //2.键盘录入税前工资
  int money = sc.nextInt();
  //3.计算应纳税部分的工资
  double before = money - (money0.1) - 5000;
  //4.定义个税变量
  double shui = 0;
  //5.按照梯度范围计算个税数值
  if(before > 0 && before <=3000){
   shui = before  0.03;
  }else if(before > 3000 && before <=12000){
   shui = 30000.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 + 130000.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 + 200000.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 - (money0.1) - shui;
  //7.打印个税和税后工资
  System.out.println("个人所得税" + shui + "元");
  System.out.println("税后工资" + after + "元");
 }
}

如果尾数为8，需支付办卡费50元
如果尾数为4，需支付办卡费用0元
如果是其他尾号,需支付办卡费用20元

package .cxy.exec;

import java.util.Scanner;

public class PayCard {
 public static void main(String[] args) {
  //1.提示并接收用户输入的手机号
  System.out.println("请输入您预选的手机号");
  String tel = ne 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;//结束方法，返回到调用位置再继续执行
  }

  
  //3.2获取手机号的尾数
  char c = tel.charAt(10);

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

  //3.3根据c字符的值，来为price重新赋值
  sitch(c) {
   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.,输出cxy

package .cxy.exec;

import java.util.Scanner;

public class GetEmailName {
	public static void main(String[] args) {
		System.out.println("输入email:");
		String e = ne Scanner(System.in).nextLine();
		//email地址e，传递到该方法，
		//并得到方法返回的名字，保存到变量n
		String n = getName(e);
		System.out.println(n);
	}

	static String getName(String email) {
		
		//找@的位置
		int index = email.indexOf("@");
		if(index == -1) {//找不到
			return "邮箱格式错误";
		}
		//截取，直接返回截取的结果
		return email.substring(0, index);
	}
}

package .cxy.exec;

public class DeadCycle {
 public static void main(String[] args) {
  //for循环的死循环
//  for (int i = 1; ; i++){
//   System.out.println("欢迎学习泡泡的分享,继续加油哦~");
//  }
  //hile循环的死循环
//  hile(true){
//   System.out.println("都到这里啦?奥利给~");
//  }
  //do-hile循环的死循环
  do{
   System.out.println("相信我们可以的~");
  }hile(true);
 }
}

已知:鸡兔共35只,共94只脚,那么鸡和兔各几只?
package .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 .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) {
   

   //死循环显示菜单
   outer:
   hile(true) {
   //显示菜单，并获得选择的值
   int c = menu();
   //判断c的值
   sitch(c) {
   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 ne Scanner(System.in).nextInt();
   }

   private static void f1() {
   
   for(int i=0;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);
   }
}

需求:接收用户输入的数字,计算该数字的阶乘结果
已知:负数不可以有阶乘,0的阶乘结果是1,
5 ! = 5 x 4 x 3 x 2 x 1

package .cxy.exec;

import java.util.Scanner;

public class Factorial {
 public static void main(String[] args) {
  System.out.print("输入整数，求阶乘");
  int n = ne 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;
  }
  
  long r = n;
  for(int i=n-1; i>=1; i--) {
   r = i;
  }
  System.out.println(n+"的阶乘"+r);
 }
}

package .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;
   }
  }
 }
}

package .cxy.exec;

public class ForContinue {
 public static void main(String[] args) {
  for(int i=1;i<=100;i++) {
   int y = i%10;//100以内的数,通过取余求出尾数
   if(y==3 || y==5 || y==7) {
    continue;//如果尾数为3 5 7 ,则跳过后面的打印,进行下一轮循环
   }
   System.out.println(i);
  }
 }
}

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

package .cxy.exec;

import java.util.Scanner;

public class PrimeNumber {
 public static void main(String[] args) {
  System.out.print("请输入要判断的自然数");
  int n = ne 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 
练习题:接收用户输入的数字,判断在此范围内质数的个数 
package .cxy.exec;

import java.util.Scanner;

public class CountPrimeNumber {
 public static void main(String[] args) {
  System.out.println("输入整数n，求n内质数的数量");
  int n = ne 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 
练习题:生成一个顺序数组,将这个数组的元素打乱顺序后输出 
package .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 
练习题:打印全三角形 
需求:接收用户输入的行数,打印对应的全三角形,如图所示:
 
 
 
package .cxy.exec;

import java.util.Scanner;

public class PrintTraingle {
	public static void main(String[] args) {
		//1.提示并接收用户输入的行数:
		System.out.println("请输入您要打印星星的行数:");
		int n = ne 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 
练习题模拟双色球生成案例 
需求体彩中有一项是双色球，要求在1-33号共33个红色球里选出6个，1-16号共16个蓝色球中选出一个作为中奖号码，请实现这个需求
 
package .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(r));
		System.out.println(Arrays.toString(b));
		//选择红球
		int[] red = selectRed(r);
		//选择蓝球
		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 = ne 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) {//选择红球
		
		//i循环从0到<6
		for (int i = 0; i < 6; i++) {
			//j随机定位
			int j =
					i+ ne 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[ne Random().nextInt(16)];
	}
}
 
练习题:求任意自然数各位数之和 
接收用户输入的任意自然数,累计所有位数数字之和
 需求:接收用户输入的行数,
 
package .cxy.exec;

import java.util.Scanner;

public class SumNum {
	public static void main(String[] args) {
		//1.提示并接收用户要计算的自然数:
		System.out.println("请输出您要求和的自然数:");
		int n = ne Scanner(System.in).nextInt();
		//2.定义一个变量用来保存最终求和的结果
		int sum=0;
		//3.循环获取每一位上的数
		hile(n!=0){
			//4.求当前的个位数,并将个位数累加
			sum = sum + (n%10);
			//5.去掉刚刚累加过的一位数,得到新的整数
			//比如刚刚的十位就变成了现在的个位
			n=n/10;
		}
		//6.打印最终的结果:
		System.out.println(sum);
	}

}
 
练习题:求任意数组中所有元素的最大值 
package .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;imax){
					//5.如果当前数组元素大于max,就讲此元素的值赋值给max
					max=arr[i];
				}
			}
			//6.打印最终的结果
			System.out.println(max);
		}
	}
 
练习题:求1000以内的完数 
完数:如果一个数等于其所有因子之和,我们就称这个数为"完数",比如6的因子为1,2,3 6 = 1 + 2 + 3,那么6就是一个完数
 
 package .cxy.exec;

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 .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(c));
	   }

	   private static int[] suiJi() {
	   int n = 5+ ne Random().nextInt(6);
	   int[] a = ne int[n];
	   for (int i = 0; i < a.length; i++) {
	   a[i] = ne Random().nextInt(100);
	   }
	   return a;
	   }

	   private static int[] heBing(int[] a, int[] b) {
	   
	   //新建数组
	   int[] c = ne int[a.length+b.length];
	   //对新数组遍历
	   for(int i=0,j=0,k=0;i=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 .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 4 j
	   };
	   
	   for(int j=0;j=0; i--) {
	   System.out.print(a[i][j]);
	   }
	   System.out.println();
	   }
	   }
}
 
练习题:求猴子大王 
15个猴子围成一圈选大王,依次1-7循环报数,报到7的猴子被淘汰,直到一只猴子称为大王,问:哪只猴子会成为大王?
 
package .cxy.exec;

public class MonkeyKing {
	public static void main(String[] args) {
		//1.定义长度为15的数组保存猴子,boolean类型是为了判断猴子是否存活
		boolean[] b=ne boolean[15];

		//2.依次遍历每一只猴子
		//true---未淘汰  false---已淘汰
		for(int i=0;i1){//判断条件
			//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 
练习题:斐波那契问题 
已知:斐波那契数列的前几个数分别为0,1,1,2,3,5…从第三项开始,每一项都等于前两项的和.请接收用户输入的整数n,求出此数列的前n项.
 
package .cxy.exec;

import java.util.Scanner;


public class Faibonai {
	public static void main(String[] args) {
		System.out.println("请输入您要测试的数:");
		int n = ne 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 .cxy.exec;

import java.util.Scanner;

public class GetRabbitNum {
	public static void main(String[] args) {
		System.out.println("请输入要判断的月数");
		int month = ne 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 .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 .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;
		sitch(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 .cxy.exec;
 
public class TestScore {
 public static void main(String[] args) {
 
 Score s = ne Score(54);
 System.out.println(s.toString());
 }
 }
 
练习题:面向对象 打印图形 
需求设计一个可以随机打印形状的代码
 
形状类【父类】 
package .cxy.exec;

public class Shape {
	public void dra() {
		//无意义代码
		//在子类中要重写dra()方法
		System.out.println("图形形状");
	}
	public void clear() {
		System.out.println("nnn");
	}
}
 
圆形类【子类】 
package .cxy.exec;

public class Circle extends Shape {
	@Override
	public void dra() {
		System.out.println("打印一个圆形 O");
	}
}
 
方形类【子类】 
package .cxy.exec;

public class Square extends Shape {
	@Override
	public void dra() {
		System.out.println("打印一个方形 口");
	}
}
 
直线类【子类】 
package .cxy.exec;

public class Line extends Shape {
	@Override
	public void dra() {
		System.out.println("打印一条直线 ————");
	}

	public void length() {
		System.out.println("一米多。。。");
	}
}
 
测试类随机生成图形 
package .cxy.exec;

import java.util.Random;
import java.util.Scanner;

public class TestShape {
	public static void main(String[] args) {
		System.out.println("按回车继续");
		hile(true) {
			int r = ne Random().nextInt(4);
			sitch(r) {
			case 0: f(ne Shape()); break;
			case 1: f(ne Line()); break;
			case 2: f(ne Square()); break;
			case 3: f(ne Circle()); break;
			}
		}
	}

	
	static void f(Shape s) {
		System.out.println("----------------");
		ne Scanner(System.in).nextLine();
		s.dra();
		//向上转型后，只能调用父类定义的通用成员
		//子类特有成员不能调用
		//s.length();
		//s对象的真实类型是 Line 类型
		if(s instanceof Line) {
			//向下转型成Line类型，才能调用它特有的方法
			Line line = (Line) s;
			line.length();
		}
		ne Scanner(System.in).nextLine();
		s.clear();
	}
}
 
练习题:面向对象 设计士兵类 
需求设计士兵与武器AK47类，并完成前进、进攻、发射子弹、装载子弹的功能
 
士兵类 
package .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 = ne Random().nextInt(10);
		blood -= d; 
		if(blood < 0) {//不允许负数血量
			blood = 0;
		}
		System.out.println("血量"+blood);
		//血量是0
		if(blood == 0) {
			System.out.println(id+"号士兵阵亡");
		}
	}
}
 
武器类 
package .cxy.exec;
import java.util.Random;

public class AK47 {
	int bullets = 100;
	public void fire() {
		if(bullets == 0) {
			System.out.println("没有子弹");
			return;
		}
		//随机产生发射子弹数量
		int r = ne Random().nextInt(10);
		//要发射的数量，比现有子弹多
		if(r > bullets) {
			r = bullets;//有多少发多少
		}
		bullets -= r;
		for(int i=0;i 
测试类1 
package .cxy.exec;

public class Test1 {
	public static void main(String[] args) {
		//新建 Soldier 士兵对象
		//内存地址，保存到变量s1
		Soldier s1 = ne Soldier();
		Soldier s2 = ne Soldier();
		//用s1引用第一个士兵对象
		//为它的id赋值
		s1.id = 9527;
		s2.id = 9528;
		//用s1找到第一个士兵对象
		//让第一个士兵执行go()方法代码
		s1.go();
		s2.go();
		//新建 AK47 对象，保存到s1.a
		s1.a = ne AK47();
		s2.a = ne AK47();
		s2.attack();
		s2.attack();
		s2.attack();
		s2.attack();
	}
}

 
测试类2 
package .cxy.exec;

import java.util.Scanner;

public class Test2 {
	public static void main(String[] args) {
		//新建AK47对象，地址存到变量a
		AK47 a = ne AK47();
		System.out.println("按回车射击，输入load装载子弹");
		hile(true) {
			String s = ne Scanner(System.in).nextLine();
			if(s.equals("load")) {
				a.load();
				continue;
			}
			a.fire();
		}
	}
}
 
练习题:面向对象 设计宠物类 
需求设计宠物类，用户可以自由选择养猫还是养狗，可以给宠物起名字，还可以实现喂食互动的功能，宠物需要有饱食度和快乐度
 
宠物类【父类】 
package .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+"喂食");
		full += 10;
		System.out.println("饱食度"+full);
	}
	public void play() {//宠物的互动玩耍方法
		if(full == 0) {
			System.out.println(name+"已经饿得玩不动了");
			return;
		}
		System.out.println("陪"+name+"玩耍");
		happy += 10;
		full -= 10;
		System.out.println("快乐度"+happy);
		System.out.println("饱食度"+full);
	}
	public void punish() {//宠物的惩罚方法
		//子类不同的代码，改成调方法
		System.out.println(
				"打"+name+"的pp，"+name+"哭叫"+cry());
		happy -= 10;
		System.out.println("快乐度"+happy);
	}
	public String cry() {//小动物被打哭了
		//无意义代码
		//cry()方法需要在子类中重写，返回具体哭叫声
		return "此处有哭叫声";
	}
}
 
小猫类【子类】 
package .cxy.exec;
public class Cat extends Pet{
	public Cat(String name, int full, int happy) {
		super(name, full, happy);
	}
	public Cat(String name) {
		super(name);
	}
	@Override
	public String cry() {
		return "喵~";
	}
}
 
小狗类【子类】 
package .cxy.exec;
public class Dog extends Pet {
	public Dog(String name, int full, int happy) {
		super(name, full, happy);
	}
	public Dog(String name) {
		super(name);
	}
	@Override
	public String cry() {
		return "汪~";
	}
}
 
测试类 
package .cxy.exec;

import java.util.Random;
import java.util.Scanner;

public class TestPet {
	public static void main(String[] args) {
		System.out.println("1. 狗");
		System.out.println("2. 猫");
		System.out.print("选择> ");
		int c = ne Scanner(System.in).nextInt();
		System.out.print("给宠物起个名字");
		String n = ne Scanner(System.in).nextLine();
		//定义猫狗变量
		Dog dog = null;
		Cat cat = null;
		if(c == 1) {
			dog = ne Dog(n);
			play(dog);
		} else {
			cat = ne Cat(n);
			play(cat);
		}
	}
	private static void play(Dog dog) {
		System.out.println("按回车执行");
		hile(true) {
			ne Scanner(System.in).nextLine();
			int r = ne Random().nextInt(6);
			sitch(r) {
			case 0: dog.feed(); break;
			case 1: dog.play(); break;
			default: dog.punish(); break;
			}
		}
	}
	private static void play(Cat cat) {
		System.out.println("按回车执行");
		hile(true) {
			ne Scanner(System.in).nextLine();
			int r = ne Random().nextInt(6);
			sitch(r) {
			case 0: cat.feed(); break;
			case 1: cat.play(); break;
			default: cat.punish(); break;
			}
		}
	}
}