关于#java#的问题，请各位专家解答！

import java.util.Scanner;
public class BreakExercise02 {

//编写一个main方法
public static void main(String[] args) {

    //实现登录验证，有3次机会，如果用户名为"真" ,密码"666"提示登录成功，
    //否则提示还有几次机会，请使用for+break完成
    Scanner myScanner=new Scanner(System.in);
    System.out.println("请输入名字");
    String name=myScanner.next();
    System.out.println("请输入密码");
    int pass=myScanner.nextInt();

    for(int i=3;i>=0;i--){
        if(name=="真"&&pass==666){
    System.out.println("登录成功");
    }
    else{
        System.out.println("还有"+(3-i)+"次机会");    
            }
    
}

}
}

想问下哪里出了问题导致没办法出现：输错提醒还有xx次机会后再进行输入而不是直接结束的效果

img

字符串比较要用 equals

public static void main(String[] args) {

        //实现登录验证，有3次机会，如果用户名为"真" ,密码"666"提示登录成功，
        //否则提示还有几次机会，请使用for+break完成
        Scanner myScanner = new Scanner(System.in);

        for (int i = 3; i > 0; i--) {
            System.out.println("请输入名字");
            String name = myScanner.next();
            System.out.println("请输入密码");
            int pass = myScanner.nextInt();

            if ("真".equals(name) && pass == 666) {
                System.out.println("登录成功");
            } else {
                System.out.println("还有" + (i - 1) + "次机会");
            }
        }
    }
  • 你可以参考下这个问题的回答, 看看是否对你有帮助, 链接: https://ask.csdn.net/questions/7543791
  • 你也可以参考下这篇文章：java扩充例题4.14的功能，实现两个矩阵的相加，两个矩阵的相减，矩阵的转置和矩阵的逆矩阵等运算。
  • 同时，你还可以查看手册：java-国际化 - 介绍如何设计软件，使其能够轻松适应（本地化）各种语言和地区。-引言定义了国际化一词，给出了一个快速的示例程序，并提供了一个检查表，你可以用来对现有程序进行国际化。-检查清单 中的内容
  • 除此之外, 这篇博客: java---递归的理解到由递归引入动态规划中的 递归的过程很复杂，而且递归也很重要，它能够解决我们遇到的很多问题。所以理解递归很重要。 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

  • 再一个就是在学习算法的时候我们会遇见动态规划，直接解决动态规划对于大多数人来说都不太现实，而从暴力递归到动态规划就相对变得简单一点了。

    1.递归的理解

    如何用递归实现数字倒着输出？

    	public static void Number1(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		System.out.print(n+" ");
		Number1(n-1);
	}

    如何用递归实现连续数字正着输出？

    	public static void Number2(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		Number2(n-1);
		System.out.print(n+" ");
	}

     如何利用递归让一段连续的数字先倒序输出再正着输出一遍？

    	public static void Number4(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		System.out.print(n+" ");
		Number4(n-1);
		System.out.print(n+" ");
	}

    接下来一个理解递归的就和二叉树相关了、

    	public static void Number3(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		Number3(n-1);
		System.out.print(n+" ");
		Number3(n-1);
	}

     接下来是Fibonacci的递归写法。

    //斐波那契数列递归的写法
	//n代表你想要斐波那契数列的第n项
	public static int Fibo(int n){
		//首先必须要递归的出口，不然就会陷入死循环
		if(n==1||n==2)
			return 1;
		return Fibo(n-1)+Fibo(n-2);
	}

    由Fibonacci递归写法改成动态规划

    //这里我们先提前引入一下动态规划。
	//我们会发现，在递归的过程中，有很多数被重复运算，有没有一种办法不重复的运算这些数呢？
	//动态规划！使用动态规划，每次生成的数放到一个数组当中，下次要用到的时候直接调用表中
	//的数值即可
	public static int Fibo1(int n) {
		int dp[]=new int[n+2];
		//接下来就是填表
			dp[1]=1;
			dp[2]=1;
			if(n>=3) {
				for(int i=3;i<=n;i++)
					dp[i]=dp[i-1]+dp[i-2];
			}
		return dp[n];
	}

    上面这个动态规划我们开辟了一个n长度的数组，我们还可以对空间进行优化，就是开辟一个长度为3的数组即可，重复利用这段空间

    	public static int Fibo2(int n) {
		int dp[]=new int[3];
		int k1 = 1;
		//接下来就是填表
			dp[0]=1;
			dp[1]=1;
			if(n>=3) {
				for(int i=3;i<=n;i++) {
					k1=(i+2)%3;
				dp[k1]=dp[(i+1)%3]+dp[i%3];
				}
			}
		return dp[k1];
	}

    接下来是总代码

    	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//体验一下递归的感觉
		Number1(5);
		System.out.println();
		Number2(5);
		System.out.println();
		Number3(5);
		System.out.println();
		Number4(5);
		System.out.println();
		System.out.println("=========================");
		System.out.println("Fibonacci的第10个数是："+Fibo(10));
		System.out.println("打印Fibonacci的前10项");
		for(int i=1;i<=10;i++) {
			System.out.printf("%-5d",Fibo(i));
			if(i%5==0)
				System.out.println();
		}
		System.out.println("=========动态规划===========");
		System.out.println("Fibonacci的第10个数是："+Fibo1(10));
		System.out.println("打印Fibonacci的前10项");
		for(int i=1;i<=10;i++) {
			System.out.printf("%-5d",Fibo1(i));
			if(i%5==0)
				System.out.println();
		}
		System.out.println("==========优化空间后的动态规划==========");
		System.out.println("Fibonacci的第10个数是："+Fibo2(10));
		System.out.println("打印Fibonacci的前10项");
		for(int i=1;i<=10;i++) {
			System.out.printf("%-5d",Fibo2(i));
			if(i%5==0)
				System.out.println();
		}
	}
	//斐波那契数列递归的写法
	//n代表你想要斐波那契数列的第n项
	public static int Fibo(int n){
		//首先必须要递归的出口，不然就会陷入死循环
		if(n==1||n==2)
			return 1;
		return Fibo(n-1)+Fibo(n-2);
	}
	//这里我们先提前引入一下动态规划。
	//我们会发现，在递归的过程中，有很多数被重复运算，有没有一种办法不重复的运算这些数呢？
	//动态规划！使用动态规划，每次生成的数放到一个数组当中，下次要用到的时候直接调用表中
	//的数值即可
	public static int Fibo1(int n) {
		int dp[]=new int[n+2];
		//接下来就是填表
			dp[1]=1;
			dp[2]=1;
			if(n>=3) {
				for(int i=3;i<=n;i++)
					dp[i]=dp[i-1]+dp[i-2];
			}
		return dp[n];
	}
	//还可以进一步的优化空间
	public static int Fibo2(int n) {
		int dp[]=new int[3];
		int k1 = 1;
		//接下来就是填表
			dp[0]=1;
			dp[1]=1;
			if(n>=3) {
				for(int i=3;i<=n;i++) {
					k1=(i+2)%3;
				dp[k1]=dp[(i+1)%3]+dp[i%3];
				}
			}
		return dp[k1];
	}
	public static void Number1(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		System.out.print(n+" ");
		Number1(n-1);
	}
	public static void Number2(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		Number2(n-1);
		System.out.print(n+" ");
	}
	public static void Number3(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		Number3(n-1);
		System.out.print(n+" ");
		Number3(n-1);
	}
	public static void Number4(int n) {
		//先要有递归出口
		if(n<=0)
			return ;
		System.out.print(n+" ");
		Number4(n-1);
		System.out.print(n+" ");
	}

    那么有人会问了，既然暴力递归能解决这个问题，那我们为何还要引入动态规划？

    因为动态规划能够 节省很多时间。在暴力递归的过程中，有些过程反复计算，这样使我们的程序时间复杂度过高。

    下一节详细的讲一下动态规划

  • 您还可以看一下 汪翠老师的java项目实战之欢乐斗地主游戏开发教程 毕业项目课程设计带源码课程中的 给扑克牌绑定鼠标事件实现单击可以选择出牌列表小节, 巩固相关知识点