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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

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

#### 练习题:打印全三角形


需求:接收用户输入的行数,打印对应的全三角形,如图所示:  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210512102104536.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA==,size_16,color_FFFFFF,t_70)  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210512102108639.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA==,size_16,color_FFFFFF,t_70)

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(“输入数据有误！！！”);
}
//n1
if(n1){
System.out.println(0);
}
//n2
if(n2){
System.out.println(0+“\t”+1);
}
//n3
if(n3){
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 == x\*x\*x+y\*y\*y+z\*z\*z) {
		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+“喂食”);
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 cn.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 cn.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 cn.cxy.exec;

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

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。

如果你需要这些资料，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

ll -= 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 cn.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 cn.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 cn.cxy.exec;

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

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
[外链图片转存中…(img-tQ8RuFUw-1715678638467)]
[外链图片转存中…(img-Low98BB7-1715678638468)]

如果你需要这些资料，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！