java基础控制语句、方法及递归

最新推荐文章于 2022-04-27 12:57:18 发布
最新推荐文章于 2022-04-27 12:57:18 发布
阅读量156 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38360675/article/details/85162631
版权

1选择结构

if单选择结构

/**
 * 测试if语句
 * @author Memorial
 *
 */
public class Test {
public static void main(String[] args) {
	double d =Math.random();//返回[0,1）之间的随机数
	System.out.println(d);
    System.out.println((int)(6*Math.random()+1));
    
    int h=(int)(6*Math.random()+1);
    if (h<=3) {
    	System.out.println("小");	
    }
    System.out.println("########################################");
    //通过掷三个骰子看看今天的手气如何？
    int i = (int)(6 * Math.random()) + 1;//通过Math.random()产生随机数
    int j = (int)(6 * Math.random()) + 1;
    int k = (int)(6 * Math.random()) + 1;
    int count = i + j + k;
    //如果三个骰子之和大于15，则手气不错
    if(count > 15) {
        System.out.println("今天手气不错");
    }
    //如果三个骰子之和在10到15之间，则手气一般
    if(count >= 10 && count <= 15) { //错误写法：10<=count<=15
        System.out.println("今天手气很一般");
    }
    //如果三个骰子之和小于10，则手气不怎么样
    if(count < 10) {
        System.out.println("今天手气不怎么样");
    }
    System.out.println("得了" + count + "分");
}
    
}

if-else选择结构

/**
 * 测试if-else语句
 * @author Memorial
 *
 */
public class Test2 {
public static void main(String[] args) {
	 //随机产生一个[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长
    double r = 4 * Math.random();
   //Math.pow(r, 2)求半径r的平方
    double area = Math.PI * Math.pow(r, 2);
    double circle = 2 * Math.PI * r;
    System.out.println("半径为： " + r);
    System.out.println("面积为： " + area);
    System.out.println("周长为： " + circle);
    //如果面积>=周长，则输出"面积大于等于周长"，否则，输出周长大于面积
    if(area >= circle) {
        System.out.println("面积大于等于周长");
    } else {
        System.out.println("周长大于面积");
    }
}
}

swicth选择结构

public class Test6 {
    public static void main(String[] args) {
        char c = 'a';
        int rand = (int) (26 * Math.random());
        char c2 = (char) (c + rand);
        System.out.print(c2 + ": ");
        switch (c2) {
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
            System.out.println("元音");
            break;
        case 'y':
        case 'w':
            System.out.println("半元音");
            break;
        default:
            System.out.println("辅音");
        }
    }
}

2.循环结构

while语句

public class Test7 {
    public static void main(String[] args) {
        int  i = 0;
        int  sum = 0;
        // 1+2+3+…+100=?
        while (i <= 100) {
            sum += i;//相当于sum = sum+i;
            i++;
        }
        System.out.println("Sum= " + sum);
    }
}

do-while语句

public class Test8 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do {
            sum += i; // sum = sum + i
            i++;
        } while (i <= 100);//此处的；不能省略
        System.out.println("Sum= " + sum);
    }

for循环

public class Test10 {
    public static void main(String args[]) {
        int sum = 0;
        //1.求1-100之间的累加和
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("Sum= " + sum);
        //2.循环输出9-1之间的数
        for(int i=9;i>0;i--){
            System.out.print(i+"、");
        }
        System.out.println();
        //3.输出90-1之间能被3整除的数
        for(int i=90;i>0;i-=3){
            System.out.print(i+"、");
        }
        System.out.println();
    }
}

嵌套循环

public class Test15 {
    public static void main(String args[]) {
        for (int i = 1; i < 10; i++) { // i是一个乘数
            for (int j = 1; j <= i; j++) { // j是另一个乘数
                System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + "  ");
            }
            System.out.println();
        }
    }
}

break和continue语句

/**
 * 测试break和continue
 * @author 86176
 *
 */
public class Test3 {
public static void main(String[] args) {
	int total=0;//定义计数器
	System.out.println("Begin");
	while(true) {
		total++;//每循环一次计数器加1
		int i=(int)Math.round(100*Math.random());
		System.out.println(i);
		//当i=99时，退出循环
		if(i==99) {
			break;
		}
	}
	//输出循环的次数
	System.out.println("Game over,used "+total+"times.");
}
}

 

/**
 * 测试continue语句
 * @author Memorial
 *
 */
//把100~150之间不能被3整除的数输出，并且每行输出5个数
public class Test4 {
public static void main(String[] args) {
	int count=0;//定义一个计数器
	for(int i=100;i<=150;i++) {
		//如果是3的倍数，则跳过本次循环，继续下一次循环
		if(i%3==0) {
			continue;
		}
		//否则（不是3的倍数）,输出该数值
		System.out.print(i+"、");
		count++;//每输出一个数，计数器加1
		if(count %5==0) {
			System.out.println();
		}
		
	}
}
}

带标签的break和continue语句

/**
 * 测试带标签break和continue
 * @author Memorial
 *
 */

//打印101-150之间的所有质数
public class Test5 {
public static void main(String[] args) {
	outer:for (int i=101;i<150;i++) {
		for(int j =2;j<i/2;j++) {
			if(i%j==0) {
				continue outer;
			}
		}
		System.out.print(i+" ");
	}
}
}

3.方法

/**
 * 测试方法的声明以及调用
 * @author Memorial
 *
 */
public class Test6 {
/**main方法：程序的入口**/
public static void main(String[] args) {
	int i=1;
	int j=2;
	//调用求和方法：将i和j的值传给add方法中的n1和n2
	//求和后将结果返回，用sum接受结果
	int sum=add(i,j);
	System.out.println("sum="+sum);//输出sum值
	//调用打印的方法，该方法没有返回值
	print();

}
private static int add(int n1, int n2) {
	// TODO Auto-generated method stub
	int sum=n1+n2;
	return sum;
}

private static void print() {
	// TODO Auto-generated method stub
System.out.println("CSDN博客...");	
}
}

4.方法的重载

 重载的方法，实际是完全不同的方法，只是名称相同而已!

      构成方法重载的条件：

      1.不同的含义：形参类型、形参个数、形参顺序不同

      2.只有返回值不同不构成方法的重载

      3.只有形参的名称不同，不构成方法的重载

/**
 * 测试方法的重载
 * @author Memorial
 *
 */
//重载方法，实际是完全不同的方法，只是名称相同
//在形参类型、形参个数、形参顺序不同的情况下构成重载
public class Test7 {
	public static void main(String[] args) {
        System.out.println(add(3, 5));// 8
        System.out.println(add(3, 5, 10));// 18
        System.out.println(add(3.0, 5));// 8.0
        System.out.println(add(3, 5.0));// 8.0
        // 我们已经见过的方法的重载
        System.out.println();// 0个参数
        System.out.println(1);// 参数是1个int
        System.out.println(3.0);// 参数是1个double
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数个数不同，构成重载
    public static int add(int n1, int n2, int n3) {
        int sum = n1 + n2 + n3;
        return sum;
    }
    // 方法名相同，参数类型不同，构成重载
    public static double add(double n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数顺序不同，构成重载
    public static double add(int n1, double n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有返回值不同，不构成方法的重载
    public static double add(int n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有参数名称不同，不构成方法的重载
    public static int add(int n2, int n1) {
        double sum = n1 + n2;         
        return sum;
    }  
}

5.递归

递归结构包括两个部分：

      1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。

      2.递归体。解答：什么时候需要调用自身方法。

/**
 * 测试递归
 * @author Memorial
 *
 */
public class Test8 {
public static void main(String[] args) {
	a();
}
static int count=0;
static void a() {
	System.out.println("a");
    count++;
    if(count<10) {
    	a();
    }
    else {
    	return;
    }
}
static void b() {
	System.out.println("b");
}
}

/**
 * 测试递归
 * @author 86176
 *
 */
//求阶乘
public class Test9 {
public static void main(String[] args) {
	long d1=System.currentTimeMillis();//当前时间
	
	System.out.printf("%d阶乘的结果:%s%n",10,factorial(10));
	long d2=System.currentTimeMillis();
	System.out.printf("递归费时：%s%n",d2-d1);//耗时
}
/**求阶乘的方法**/
static long factorial(int n) {
	if (n==1) {//递归头
		return 1;
	}
	else {//递归体
		return n*factorial(n-1);//n!=n*(n-1)!
	}
}
}

1.从结构化程序设计角度出发，程序有三种结构：顺序结构、选择结构和循环结构

　　2.选择结构

　    （1）if单选择结构 if-else双选择结构 if-else if-else多选择结构

　    （2）switch多选择结构

　　3.多选择结构与switch的关系：当布尔表达式是等值判断的情况，可使用多重选择结构或switch结构，如果布尔表达式区间判断的情况，则只能使用多重选择结构

　　   （1） 循环结构

　　   （2）当型：while与for

　　   （3）直到型:do-while

　　4.while与do-while的区别，在布尔表达式的值为false时while的循环体一次也不执行，而do-while至少执行一次

　　5.break可以在switch与循环结构中使用，而continue只能在循环结构中使用

　　6.方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数

　　7.方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法

　　8.任何能用递归解决的问题也能使用迭代解决。在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。

 

Memorial*
关注
专栏目录
Java基础手册（标识符 关键字 字面值 变量 数据类型 字符编码 运算符 控制语句 方法及方法重载和递归 面向对象与面向过程）
weixin_44976692的博客
03-16 2万+
Java中的控制语句用于控制程序的执行流程，包括条件语句（if-else）、循环语句（for、while、do-while）和跳转语句（break、continue、return）等。方法是一段可重复使用的代码块，它接受参数并在执行完指定的任务后返回结果。Java有8种内置的数据类型：byte、short、int、long、float、double、char和boolean。在Java中，变量需要先声明后使用，并且需要指定变量的类型。字面值是程序中直接使用的数据，如整数、浮点数、字符或字符串等。
Java语法-递归
sdusgq的博客
11-23 426
1、什么是直接递归？什么是间接递归？ 直接递归是A方法调用A方法； 间接递归是A方法调用B方法，B方法又回头调用A方法； 2、使用递归必须明确的前提是什么？ （1）递归的结束条件； （2）递归的目的； 3、在1~n 累加和的题目中，递归的目的是获取下一个被加的数字（n-1），如何理解？ public static int sum(int n){ if(n==1)return 1; else { return n + sum(n-1);
Java中的递归
HNUTheMao的博客
07-14 1190
Java中的递归 1.何为递归，递归与循环有何区别？    程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于...
Java的递归。
hackerbaseing的博客
05-02 1066
今天我们来谈谈Java递归。首先我们来看看下面的代码。从字面的意思来理解，递归就是不断的重复的调用自己.还是来看看下面的代码。 /** * @author hackbase 递归的学习和使用，递归头和递归体. */ public class TestLoopDeep { public static void main(String[] args) { a(); ...
Java--递归
lanleihhh的博客
11-12 1024
递归 普通方法: 递归方法: 递归:递归将原本的问题转化为更小的同一问题(也就是函数/方法调用自身) 使用递归:代码中先写递归到底(递归结束条件)的情况,再写递归调用 先来看一个求累加的问题:1+2+3+…+100 最开始的时候我们使用循环去做,从1一直加到100或从100一直加到1 package com.company.project.homework; public class homework2 { public static void main(String[] args) {
Java中的方法介绍 方法语句 递归方法举例
weixin_45387721的博客
08-02 175
Java基础 Java Java方法 1.Java中的方法介绍 方法是实现特定功能的代码段的封装，在需要时可以多次调用方法来完成该功能，实现代码复用。 使用步骤： 1. 定义方法 2. 调用方法 2. 自定义方法 语法： 修饰符 返回值类型 方法名(参数){ 方法体 //语句组 } 说明： 修饰符：对方法的修饰，public static暂且认为是固定写法 返回值类型：方法执行后的返回值类型，如果没有返回值则指定为void 方法名：采用驼峰命名法，一般使用动词 参数：执行方法时
控制语句、方法、递归算法(二)
最新发布
11-11
控制语句、方法和递归算法是编程中常用的概念，让我为你解释一下： 控制语句： 控制语句用于控制程序执行流程，它可以根据条件执行不同的代码块，或者重复执行特定的代码块。常见的控制语句包括条件语句（如 if-...
控制语句、方法、递归算法(一)
11-11
控制语句、方法和递归算法是编程中常用的概念，让我为你解释一下： 控制语句： 控制语句用于控制程序执行流程，它可以根据条件执行不同的代码块，或者重复执行特定的代码块。常见的控制语句包括条件语句（如 if-...
第三章java流程控制语句.ppt
11-12
Java 流程控制语句 Java 流程控制语句是 Java 语言中控制程序执行顺序的语句，是程序中非常关键和基本的部分。该类型的语句可以把单个的语句组合成有意义的、能够完成一定功能的小逻辑块。 一、Java 语句概述 ...
java递归函数返回值_Java基础——方法返回值&递归
weixin_30577815的博客
02-17 4298
原标题：Java基础——方法返回值&递归声明：本栏目所使用的素材都是凯哥学堂VIP学员所写，学员有权匿名，对文章有最终解释权；凯哥学堂旨在促进VIP学员互相学习的基础上公开笔记。例题：写一个方法，功能是排序，然后颠倒我给你的方法传递一个数组，你就能把这个数组进行排序后倒序，然后在main方法输出的时候就能看到你运行后结果 方法返回值：方法结束后反馈了个结果。过程和方法类似，但是过程没有返回...
Java基础语法-递归方法
northcastle的博客
06-29 502
1.什么是递归 一句话递归 ： 方法A 调用 方法A。就是自己调用自己。 对递归的一个阐述 ： 利用递归可以用简单的程序解决复杂的问题。 它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。 递归只需少量的程序就可以描述出解题过程的多次重复计算，大大减少的代码量。 递归的能力在于用有限的语句来定义对象无限的集合。 递归结构的概述： 1.递归头：标志递归方法结束的条件。如果没有递归头，则会现如死循环。 2.递归体：递归方法的计算逻辑。 2.递归经典案例-阶乘 阶乘 ： 1
Java中的递归详解
write less , do more
04-27 1万+
概述 递归累加求和 计算1 ~ n的和 代码执行图解 递归求阶乘 递归打印多级目录 综合案例 文件搜索 文件过滤器优化 Lambda优化
java基础之递归调用
热门推荐
qq30211478的博客
10-24 3万+
一、递归概念 递归本质：程序调用自身的编程技巧叫做递归。 程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调； 用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过； 程所需要的多次重复计算，大大地减少了程序的代码量。...
java递归后面的语句_递归中关于递归语句后面内容的执行
weixin_30062621的博客
02-28 525
递归函数中，位于递归调用语句后的语句的执行顺序和各个被调用函数的顺序相反；下面看一个经典的例子：#includevoid up_and_down(int);int main(void){up_and_down(1);return 0;}void up_and_down(int n){printf("Level %d:n location %p/n",n,&n); /* 1 */if(n&l...
java递归算法（一）——详解以及几个经典示例
qq_40688338的博客
12-06 3万+
什么是递归 递归就是一个程序或函数在其中定义或说明有之间或者间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算，大大的减少了程序的代码量，递归的能力在于用有限的语句来定义对象的无限集合，一般来说，递归需要边界条件，递归前进段和递归返回段，当边界条件不满足时，递归前进，当边界条件满足时，递...
java递归-mysql篇
08-07 893
前言：小编用了一下午都写不出java的递归统计用户个数，网上一查mysql数据库递归，总结如下： 数据表结构： 查询上级：BEGIN DECLARE sTemp VARCHAR(1000); DECLARE sTempPar VARCHAR(1000); SET sTemp = ''; SET sTempPar =rootId; #循环递归
Math类的几个用法
Cleve_baby的博客
08-15 668
1.Math.PI 记录的圆周率 2.Math.E记录e的常量 3.Math.abs 求绝对值 4.Math.sin 正弦函数 Math.asin 反正弦函数 5.Math.cos 余弦函数 Math.acos 反余弦函数 6.Math.tan 正切函数 Math.atan 反正切函数 Math.atan2 商的反正切函数 7.Math.toDegrees 弧度转化为角度 
关于一些基础的Java问题的解答（五）
superxlcr的博客
03-19 796
21. 实现多线程的两种方法：Thread与Runable 22. 线程同步的方法：sychronized、lock、reentrantLock等 23. 锁的等级：对象锁、类锁 24. 写出生产者消费者模式 25. ThreadLocal的设计理念与作用
"Java流程控制语句总结与程序设计方法
根据控制流程的方式，Java语句可以分为三种基本类型：顺序结构、选择结构和循环结构。顺序结构是最简单的一种结构，程序按照语句的顺序执行。选择结构根据条件的结果选择执行不同的分支。循环结构根据条件的结果反复...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值