java学习笔记-(4) 第五章-程序控制结构（完结）

最新推荐文章于 2022-12-26 19:30:00 发布
最新推荐文章于 2022-12-26 19:30:00 发布
阅读量368 收藏 1
点赞数 1
分类专栏： java 文章标签： java java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50736744/article/details/120536529
版权

1.顺序控制

  • 程序流程控制介绍
    在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

    1. 顺序控制
    2. 分支控制
    3. 循环控制

  • 顺序控制
    在这里插入图片描述

2.分支控制if-else–“单分支”

  • 分支控制if-else 介绍
    让程序有选择的的执行,分支控制有三种
    1. 单分支if
    2. 双分支if-else
    3. 多分支if-else if -…-else
  • 单分支在这里插入图片描述
import java.util.Scanner;//导入
public class If01 { 
	//编写一个main方法
	public static void main(String[] args) {
		//编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,
		//则输出 "你年龄大于18,要对自己的行为负责,送入监狱"	
		
		//思路分析
		//1. 接收输入的年龄, 应该定义一个Scanner 对象
		//2. 把年龄保存到一个变量 int age
		//3. 使用 if 判断，输出对应信息
		
		//应该定义一个Scanner 对象
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入年龄");
		//把年龄保存到一个变量 int age
		int age = myScanner.nextInt();
		//使用 if 判断，输出对应信息
		if(age > 18) {
			System.out.println("你年龄大于18,要对自己的行为负责,送入监狱");
		}
		System.out.println("程序继续...");
	}
}
  • 单分支流程图
    在这里插入图片描述

3.分支控制if-else–“双分支”

  • 基本语法
    在这里插入图片描述
  • 代码演示
import java.util.Scanner;//导入
public class If02 { 
	//编写一个main方法
	public static void main(String[] args) {
		//编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,
		//则输出 "你年龄大于18,要对
		//自己的行为负责, 送入监狱"。否则 ,输出"你的年龄不大这次放过你了."

		//思路分析
		//1. 接收输入的年龄, 应该定义一个Scanner 对象
		//2. 把年龄保存到一个变量 int age
		//3. 使用 if-else 判断，输出对应信息
		
		//应该定义一个Scanner 对象
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入年龄");
		//把年龄保存到一个变量 int age
		int age = myScanner.nextInt();
		//使用 if-else 判断，输出对应信息
		if(age > 18) {
			System.out.println("你年龄大于18,要对自己的行为负责,送入监狱");
		} else {//双分支
			System.out.println("你的年龄不大这次放过你了");
		}
		System.out.println("程序继续...");
	}
}
  • 双分支流程图
    在这里插入图片描述

4.单分支、双分支练习题

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

		//第1题，编写程序，声明2个double型变量并赋值。
		//判断第一个数大于10.0，且第2个数小于20.0，打印两数之和
		double d1 = 33.5;
		double d2 = 2.6;
		if(d1 > 10.0 && d2 < 20.0) {
			System.out.println("两个数和=" + (d1 + d2));
		}

		//第2题，定义两个变量int，判断二者的和，
		//是否能被3又能被5整除，打印提示信息
		
		//思路分析
		//1. 定义两个变量int num1, num2
		//2. 定义一个变量 int sum = num1 + num2;
		//3. sum % 3 , 5 后 等于0 说明可以整除
		//4. 使用 if - else 来提示对应信息
		//走代码
		int num1 = 10;
		int num2 = 1;
		int sum = num1 + num2;
		if(sum % 3 == 0 && sum % 5 == 0) {  //等号千万是两个==，不能是=
			System.out.println("和可以被3又能被5整除");
		} else {
			System.out.println("和不能·被3和5整除..");
		}

		//第3题，判断一个年份是否是闰年，闰年的条件是符合下面二者之一：
		//(1)年份能被4整除，但不能被100整除；(2)能被400整除
		
		//思路分析
		//1. 定义 int year 保存年
		//2. 年份能被4整除，但不能被100整除, 
		//   => year % 4 == 0 && year % 100 != 0 
		//3. 能被400整除 => year % 400 == 0
		//4. 上面的 2 和  3 是 或的关系 
		//代码实现
		int year = 2028;
		if( (year % 4 == 0 && year % 100 != 0) ||  year % 400 == 0 ) {
			System.out.println(year + " 是 闰年");
		} else {
			System.out.println(year + " 不是 闰年");
		}
	}
}

5.分支控制if-else–“多分支”

  • 基本语法
    在这里插入图片描述

  • 流程图
    在这里插入图片描述

  • 课堂练习
    注意：grade > 80 && grade <= 99，千万不能写成 80 < grade <=99

import java.util.Scanner;
public class If03 { 

	//编写一个main方法
	public static void main(String[] args) {
		/* 习题1
		输入保国同志的芝麻信用分：
		如果：
		信用分为100分时，输出 信用极好；
		信用分为(80，99]时，输出 信用优秀；
		信用分为[60,80]时，输出 信用一般；
		其它情况 ，输出 信用 不及格 
		请从键盘输入保国的芝麻信用分，并加以判断
		假定信用分数为int
		 */
		
		Scanner myScanner = new Scanner(System.in);
		//接收用户输入
		System.out.println("请输入信用分(1-100):");
		//请思考：如果小伙伴输入的不是整数，而是hello..
		//==>这里我们后面可以使用异常处理机制搞定-》老师点一下
		int grade = myScanner.nextInt();

		//先对输入的信用分，进行一个范围的有效判断 1-100, 否则提示输入错误

		if(grade >=1 && grade <= 100) {
			//因为有4种情况，所以使用多分支
			if(grade == 100) {
				System.out.println("信用极好");
			} else if (grade > 80 && grade <= 99) { //信用分为(80，99]时，输出 信用优秀；
				System.out.println("信用优秀");
			} else if (grade >= 60 && grade <= 80) {//信用分为[60,80]时，输出 信用一般
				System.out.println("信用一般");
			} else {//其它情况 ，输出 信用 不及格 
				System.out.println("信用不及格");
			}

		} else {
			System.out.println("信用分需要在1-100,请重新输入:)");
		}

	}
}

习题2 ：
在这里插入图片描述

6.嵌套分支

  • 基本介绍

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。建议: 不要超过3 层（可读性不好）

  • 基本语法
if (){
		if(){
			//if-else...
		}else{
		  //if-else...
		  }
     }
  • 案例演示
import java.util.Scanner;
public class NestedIf { 
	//编写一个main方法
	public static void main(String[] args) {
		/*
		参加歌手比赛，如果初赛成绩大于8.0进入决赛，
		否则提示淘汰。并且根据性别提示进入男子组或女子组。
		【可以让学员先练习下】, 输入成绩和性别，进行判断和输出信息。
		[NestedIf.java]

		提示: double score; char gender; 
		接收字符: char gender = scanner.next().charAt(0)
		
		 */
		//思路分析
		//1. 创建Scanner对象，接收用户输入
		//2. 接收 成绩保存到 double score
		//3. 使用 if-else 判断 如果初赛成绩大于8.0进入决赛，否则提示淘汰
		//4. 如果进入到 决赛，再接收 char gender, 使用 if-else 输出信息
		//代码实现 => 思路 --> java代码
		
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入该歌手的成绩");
		double score = myScanner.nextDouble();
		if( score > 8.0 ) {
			System.out.println("请输入性别");
			char gender = myScanner.next().charAt(0); 
			if( gender == '男' ) {
				System.out.println("进入男子组");
			} else if(gender == '女') {
				System.out.println("进入女子组");
			} else {
				System.out.println("你的性别有误，不能参加决赛~");
			}
		} else {
			System.out.println("sorry ,你被淘汰了~");
		}
	}
}

7.switch分支结构

  • 基本语法
    在这里插入图片描述

  • 流程图
    在这里插入图片描述

  • 案例
    案例：Switch01.java
    请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g
    a 表示星期一，b 表示星期二…
    根据用户的输入显示相应的信息.要求使用switch 语句完成。

import java.util.Scanner;
public class Switch01 { 

	//编写一个main方法
	public static void main(String[] args) {
		/*思路分析
		1. 接收一个字符 , 创建Scanner对象
		2. 使用switch 来完成匹配,并输出对应信息
		 */
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入一个字符(a-g)");
		char c1 = myScanner.next().charAt(0);//
		//在java中，只要是有值返回，就是一个表达式
		switch(c1) {
			case 'a' : 
				System.out.println("今天星期一,猴子穿新衣");
				break;
			case 'b' : 
				System.out.println("今天星期二,猴子当小二");
				break;
			case 'c' : 
				System.out.println("今天星期三,猴子爬雪山..");
				break;
			//.....
			default:
				System.out.println("你输入的字符不正确，没有匹配的");
		}
		System.out.println("退出了switch ,继续执行程序");
	}
}
  • 注意事项和细节
    在这里插入图片描述
    case子句中的值必须是常量(1,‘a’)或者是常量表达式,而不能是变量
  • 课堂练习
  1. 使用switch 把小写类型的char 型转为大写(键盘输入)。只转换a, b, c, d, e. 其它的输出"other"。
  2. 对学生成绩大于60 分的，输出"合格"。低于60 分的，输出"不合格"。(注：输入的成绩不能大于100), 提示成绩/60
  3. 根据用于指定月份，打印该月份所属的季节。3,4,5 春季6,7,8 夏季9,10,11 秋季12, 1, 2 冬季[课堂练习, 提示使用穿透]
//第一题
import java.util.Scanner;
public class SwitchExercise { 
	//编写一个main方法
	public static void main(String[] args) {
		//使用 switch 把小写类型的 
		//char型转为大写(键盘输入)。只转换 a->A, b->B, c, d, e. 
		//其它的输出 "other"。
		//创建Scanner对象
		 Scanner myScanner = new Scanner(System.in);
		 System.out.println("请输入a-e");
		 char c1 = myScanner.next().charAt(0);
		 switch(c1) {
		 	case 'a' :
		 		System.out.println("A");
		 		break;
		 	case 'b' :
		 		System.out.println("B");
		 		break;
		 	case 'c' :
		 		System.out.println("C");
		 		break;
		 	case 'd' :
		 		System.out.println("D");
		 		break;
			case 'e' :
		 		System.out.println("E");
		 		break;
		 	default :
		 		System.out.println("你的输入有误~");
		 }

//第二题
import java.util.Scanner;
public class zuoye{
	public static void main(String[] args){

		// 这道题，可以使用 分支来完成， 但是要求使用switch
		// 这里我们需要进行一个转换, 编程思路 : 
		//   如果成绩在 [60,100] , (int)(成绩/60) = 1 
		//   如果成绩在 [0,60) , (int)(成绩/60) = 0 
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入学生成绩，0-100分");
		int score = myScanner.nextInt();
		
		if (score  >= 0 && score <= 100) {
			
			switch((int)(score/60)){ //运用了强转
		
			 case 0:      //注意不要写成case '0'
			  System.out.println("不合格");
			  break;
			  
			case 1 :      //注意不要写成case '1'
			  System.out.println("合格");
			  break;			
			}
		}else{
			System.out.println("输入有误");
		}	
	}
}


//第三题
		Scanner myScanner = new Scanner(System.in);
		System.out.println("输入月份");
		int month = myScanner.nextInt();
		switch(month) {
			case 3:
			case 4:
			case 5: 
				System.out.println("这是春季");
				break;
			case 6:
			case 7:
			case 8: 
				System.out.println("这是夏季");
				break;
			case 9:
			case 10:
			case 11: 
				System.out.println("这是秋季");
				break;
			case 1:
			case 2:
			case 12: 
				System.out.println("这是冬季");
				break;
			default :
				System.out.println("你输入的月份不对(1-12)");
		}
	}
}

8. switch 和if 的比较

  1. 如果判断的具体数值不多，而且符合byte、short 、int、char, enum[枚举], String 这6 种类型。虽然两个语句都可以使用，建议使用swtich 语句。
  2. 其他情况：对区间判断，对结果为boolean 类型判断，使用if，if 的使用范围更广

9.for 循环控制(!!!)

基本介绍:听其名而知其意,就是让你的代码可以循环的执行.
看一个实际需求，请大家看个案例[For01.java]:
编写一个程序, 可以打印10 句"你好，韩顺平教育!"。请大家想想怎么做?

  • 基本语法
    在这里插入图片描述
    说明：

  • for 关键字，表示循环控制

  • for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代

  • 循环操作, 这里可以有多条语句，也就是我们要循环执行的代码

  • 如果循环操作(语句) 只有一条语句，可以省略{}, 建议不要省略

  • for 循环执行流程分析
    流程图
    在这里插入图片描述
    代码执行内存分析
    代码执行内存分析

  • 注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
  3. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。
  4. 使用内存分析法，老师分析输出下面代码输出什么?
    在这里插入图片描述

//演示for的使用细节

public class ForDetail { 

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

	/* for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
		。。。这样的好处是for循环完之后还可以用变量i   ***/
		
		// 使用for循环控制
		// int i = 1;//循环变量初始化
		// for( ; i <= 10 ; ) {
		// 	System.out.println("hello，韩顺平教育" + i);
		// 	i++;
		// }

		// System.out.println("i=" + i);//11 ok
		

		// int j = 1;
		// //补充
		// for(;;) { //表示一个无限循环,死循环
		// 	System.out.println("ok~" + (j++));
		// }

		//循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，
		//循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开
		//老师使用内存分析法，看看下面代码输出什么?
		int count = 3;
		for (int i = 0,j = 0;  i < count; i++, j += 2) {
			System.out.println("i=" + i + " j=" + j);
		}

	}
}
  • 练习题
  1. 打印1~100 之间所有是9 的倍数的整数，统计个数及总和.[化繁为简,先死后活]
public class zuoye { 
	//编写一个main方法
	public static void main(String[] args) {
		//打印1~100之间所有是9的倍数的整数，统计个数  及 总和.[化繁为简,先死后活]
		//老韩的两个编程思想(技巧)
		//1. 化繁为简 : 即将复杂的需求，拆解成简单的需求，逐步完成
		//2. 先死后活 : 先考虑固定的值，然后转成可以灵活变化的值
		//
		//思路分析
		//打印1~100之间所有是9的倍数的整数，统计个数  及 总和
		//化繁为简
		//(1) 完成 输出 1-100的值
		//(2) 在输出的过程中，进行过滤，只输出9的倍数  i % 9 ==0
		//(3) 统计个数 定义一个变量 int count = 0; 当 条件满足时 count++;
		//(4) 总和 , 定义一个变量 int sum = 0; 当条件满足时累积 sum += i;
		//先死后活
		//(1) 为了适应更好的需求，把范围的开始的值和结束的值，做成变量
		//(2) 还可以更进一步 9 倍数也做成变量 int t = 9;

		int count = 0; //统计9的倍数个数 变量
		int sum = 0; //总和
		int start = 1;
		int end = 100;
		int t = 9; // 倍数
		for(int i = start; i <= end; i++) {
			if( i % t == 0) {
				System.out.println("i=" + i);
				count++;
				sum += i;//累积
			}
		}
		System.out.println("count=" + count);
		System.out.println("sum=" + sum);

	}
}

2.完成下面的表达式输出[老师评讲ForExercise02.java] 化繁为简 先死后活
在这里插入图片描述

//先简单来一下
public class zuoye { 

	public static void main(String[] args) {
		
		for(int i = 0, b = 5; i <= 5 && b >= 0; i++,b--) {
		 
				System.out.println(i + "+" + b + "=5"  );
		
		}
	}
}

//换成变量，先死后活
public class zuoye { 

	public static void main(String[] args) {
		
		int a1 = 2;
		int a2 = 10;
		for(int i = a1, b = a2; i <= a2 && b >= a1; i++,b--) {
		 
				System.out.println(i + "+" + b + "=" + a2 );
		
		}
	}
}

10.while循环

  • 基本语法
    在这里插入图片描述
  • 流程分析

在这里插入图片描述
内存分析
在这里插入图片描述

  • 注意事项和细节说明
  1. 循环条件是返回一个布尔值的表达式
  2. while 循环是先判断再执行语句
  • 课堂练习题 WhileExercise.java
  1. 打印1—100 之间所有能被3 整除的数[使用while, 老师评讲]
  2. 打印40—200 之间所有的偶数[使用while, 课后练习]

public class WhileExercise { 

	public static void main(String[] args) {

		// 第1题：打印1―100之间所有能被3整除的数 [使用while, 老师评讲 ]
		// 化繁为简, 先死后活
		
		int i = 1;
		int endNum = 100;
		while( i <= endNum) {
			if( i % 3 == 0) {
				System.out.println("i=" + i);
			}

			i++;//变量自增
		}

		// 第2题：打印40―200之间所有的偶数 [使用while, 课后练习]
		// 化繁为简, 先死后活(利于思考)
		//
		System.out.println("========");

		int j = 40; //变量初始化
		while ( j <= 200) {
			//判断
			if( j % 2 == 0) {
				System.out.println("j=" + j);
			}
			j++;//循环变量的迭代
		}
	}
}

11.do while循环

  • 基本语法

循环变量初始化;
do{
循环体(语句);
循环变量迭代;
}while(循环条件);

  • 说明:
  1. do while 是关键字
  2. 也有循环四要素, 只是位置不一样
  3. 先执行，再判断，也就是说，一定会至少执行一次
  4. 最后有一个分号;
  5. while 和do…while 区别举例: 要账
  • 流程图
    在这里插入图片描述
  • 内存分析
    在这里插入图片描述
  • 注意事项和细节说明
    (1)循环条件是返回一个布尔值的表达式
    (2) do…while 循环是先执行，再判断， 因此它至少执行一次
  • 课堂练习题】
    (1) 打印1—100 [学生做]
    (2) 计算1—100 的和[学生做]
    (3) 统计1—200 之间能被5 整除但不能被3 整除的个数(DoWhileExercise01.java)
    (4)如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止[System.out.println(“老韩问：还钱吗？y/n”)] do…while … DoWhileExercise02.java
//第1,2题
public static void main(String[] args) {		
		int i = 1;
		int sum =0;
		do{
			System.out.println(i );
			sum += i;
			i ++;
		}
		while(i <= 100);
		System.out.println(sum);
	}
}

//第3题
public class DoWhileExercise01 { 

	//编写一个main方法
	public static void main(String[] args) {
		//统计1---200之间能被5整除但不能被3整除的个数
		//化繁为简
		//(1) 使用do-while输出 1-200
		//(2) 过滤 能被5整除但不能被3整除的数 %
		//(3) 统计满足条件的个数 int count = 0; 
		//先死后活
		//(1) 范围的值 1-200 你可以做出变量
		//(2) 能被5整除但不能被3整除的 , 5 和 3 可以改成变量 
		int i = 1;
		int count = 0; //统计满足条件的个数
		do {
			if( i % 5 == 0 && i % 3 != 0 ) {
				System.out.println("i=" + i);
				count++;  //计数的count要放在这
			}
			i++;
		}while(i <= 200);
		System.out.println("count=" + count);
	}
}

//第4题
import java.util.Scanner;
public class DoWhileExercise02 { 
	public static void main(String[] args) {
	
		//如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为
		//[System.out.println("老韩问：还钱吗？y/n")]   do...while ..
		//
		//化繁为简
		//(1) 不停的问还钱吗?
		//(2) 使用char answer 接收回答, 定义一个Scanner对象
		//(3) 在do-while 的while 判断如果是 y 就不在循环

		Scanner myScanner  = new Scanner(System.in);
		char answer = ' ';
		do {
			System.out.println("老韩使出五连鞭~");
			System.out.println("老韩问：还钱吗？y/n");
			answer = myScanner.next().charAt(0);
			System.out.println("他的回答是" + answer);
		}while(answer != 'y');//判断条件很关键

		System.out.println("李三还钱了");
	}
}

12.多重循环控制

  • 介绍
  1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。
    【建议一般使用两层，最多不要超过3 层, 否则，代码的可读性很差】
  2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环[听不懂，走案例]。
  3. 设外层循环次数为m 次，内层为n 次，则内层循环体实际上需要执行m*n 次。
    在这里插入图片描述

  • 多重循环执行步骤分析
    在这里插入图片描述

  • 应用实例
    （1） 统计3 个班成绩情况，每个班有5 名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
    （2） 统计三个班及格人数，每个班有5 名同学。

import java.util.Scanner;
public class MulForExercise01 { 

	//编写一个main方法
	public static void main(String[] args) {
		//统计3个班成绩情况，每个班有5名同学，
		//求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
		//统计三个班及格人数，每个班有5名同学。
		//
		//思路分析:
		//化繁为简
		//(1) 先计算一个班 , 5个学生的成绩和平均分 , 使用for
		//1.1 创建 Scanner 对象然后，接收用户输入
		//1.2 得到该班级的平均分 , 定义一个 doubel sum 把该班级5个学生的成绩累积 
		
		//(2) 统计3个班(每个班5个学生) 平均分
		//(3) 所有班级的平均分
		//3.1 定义一个变量，double totalScore 累积所有学生的成绩
		//3.2 当多重循环结束后，totalScore / (3 * 5) 
		//(4) 统计三个班及格人数
		//4.1 定义变量 int passNum = 0; 当有一个学生成绩>=60, passNum++
		//4.2 如果 >= 60 passNum++
		//(5) 可以优化[效率，可读性, 结构]
		
		//创建 Scanner 对象
		Scanner myScanner = new Scanner(System.in);
		double totalScore = 0; //累积所有学生的成绩
		int passNum = 0;//累积 及格人数
		int classNum = 3; //班级个数
		int stuNum = 5;//学生个数
		for( int i = 1; i <= classNum; i++) {//i 表示班级

			double sum = 0; //一个班级的总分
			for( int j = 1; j <= stuNum; j++) {//j 表示学生
				System.out.println("请数第"+i+"个班的第"+j+"个学生的成绩");
				double score = myScanner.nextDouble();
				//当有一个学生成绩>=60, passNum++
				if(score >= 60) {
					passNum++;
				}
				sum += score; //累积
				System.out.println("成绩为" + score);
			}
			//因为sum 是 5个学生的总成绩
			System.out.println("sum=" + sum + " 平均分=" + (sum / stuNum));
			//把 sum 累积到 totalScore
			totalScore += sum;
		}
		System.out.println("三个班总分="+ totalScore 
			+ " 平均分=" + totalScore / (classNum*stuNum));
		System.out.println("及格人数=" + passNum);
	}
}
  • 经典的打印金字塔

使用for 循环完成下面的案例
请编写一个程序，可以接收一个整数,表示层数（totalLevel），打印出金字塔。(Stars.java) [化繁为简, 先死后活]
在这里插入图片描述



public class Stars { 

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

		/*
		
			    *
			  *  *
			 *    *
			********

		思路分析
		化繁为简
		1. 先打印一个矩形
		*****
		*****
		*****
		*****
		*****         */
		for(int i = 1; i <= 5 ;i++){
			System.out.println("*****");
		}	

		/*  2. 打印半个金字塔

		*    	//第1层 有 1个*
		**   	//第2层 有 2个*
		***		//第3层 有 3个*
		****    //第4层 有 4个*
		*****   //第5层 有 5个*     */

		for(int i = 1; i <= 5 ;i++){ //i表示层数
			//控制打印每层*的个数
			for(int j = 1;j <= i; j++){ //i=1 进入循环体,j=1,输出一个*后j++,j=2,退出循环体.
			         //i++,i=2,进入循环体,j=1,输出一个*后j++,j=2,再输出一个*后j++,j=3,退出循环体.
				System.out.print("*");
			}
			//每打印完一层的*后就换行，pirntln本身就会换行
			System.out.println(" ");
		}
	/*	3. 打印整个金字塔
		*       //第1层 有 1个*   2 * 1 -1   有4=(总层数-1)个空格
	   ***      //第2层 有 3个*   2 * 2 -1   有3=(总层数-2)个空格
	  *****     //第3层 有 5个*   2 * 3 -1   有2=(总层数-3)个空格
	 *******    //第4层 有 7个*   2 * 4 -1   有1=(总层数-4)个空格
	*********   //第5层 有 9个*   2 * 5 -1   有0=(总层数-5)个空格    */
		for(int i = 1; i <= 5; i++) { //i 表示层数

			//在输出*之前，还有输出 对应空格 = 总层数-当前层
			for(int k = 1; k <= 5 - i; k++ ) {
				System.out.print(" ");
			}

			//控制打印每层的*个数
			for(int j = 1;j <= 2 * i - 1;j++) {
				
					System.out.print("*");
				}
			
			//每打印完一层的*后，就换行 println本身会换行
			System.out.println("");
		}
	
	/*	4. 打印空心的金字塔 [最难的]
	    *       //第1层 有 1个*   当前行的第一个位置是*,最后一个位置也是*
	   * *      //第2层 有 2个*   当前行的第一个位置是*,最后一个位置也是*
	  *   *     //第3层 有 2个*   当前行的第一个位置是*,最后一个位置也是*
	 *     *    //第4层 有 2个*   当前行的第一个位置是*,最后一个位置也是*   
	*********   //第5层 有 9个*   全部输出*          */
	
	for(int i = 1; i <= 5; i++) { //i 表示层数

			//在输出*之前，还有输出 对应空格 = 总层数-当前层
			for(int k = 1; k <= 5 - i; k++ ) {
				System.out.print(" ");
			}

			//控制打印每层的*个数
			for(int j = 1;j <= 2 * i - 1;j++) {
				//当前行的第一个位置是*,最后一个位置也是*, 最后一层全部 *
				if(j == 1 || j == 2 * i - 1 || i == 5) {
					System.out.print("*");
				} else { //其他情况输出空格
					System.out.print(" ");
				}
			}
			//每打印完一层的*后，就换行 println本身会换行
			System.out.println("");
		}
	/*	先死后活
		5 层数做成变量 int totalLevel = 5;
	
	//小伙伴 技术到位，就可以很快的把代码写出
		 */
	int totalLevel = 20; //层数
		for(int i = 1; i <= totalLevel; i++) { //i 表示层数

			//在输出*之前，还有输出 对应空格 = 总层数-当前层
			for(int k = 1; k <= totalLevel - i; k++ ) {
				System.out.print(" ");
			}

			//控制打印每层的*个数
			for(int j = 1;j <= 2 * i - 1;j++) {
				//当前行的第一个位置是*,最后一个位置也是*, 最后一层全部 *
				if(j == 1 || j == 2 * i - 1 || i == totalLevel) {
					System.out.print("*");
				} else { //其他情况输出空格
					System.out.print(" ");
				}
			}
			//每打印完一层的*后，就换行 println本身会换行
			System.out.println("");
		}
	}
}

13.跳转控制语句-break

  • 看下面一个需求

随机生成1-100 的一个数，直到生成了97 这个数，看看你一共用了几次?
提示使用(int)(Math.random() * 100) + 1
思路分析：
循环，但是循环的次数不知道. -> break ,当某个条件满足时，终止循环
通过该需求可以说明其它流程控制的必要性，比如break

  • 基本介绍：

break 语句用于终止某个语句块的执行，一般使用在switch 或者循环[for , while , do-while]中

  • 基本语法：
    { ……
    break;
    ……
    }
  • 以while 使用break 为例,画出示意图
    在这里插入图片描述
  • 快速入门

在这里插入图片描述

  • 注意事项和细节说明

在这里插入图片描述
上图代码输出 i=0;i=1。

  • 课堂练习
  1. 1-100 以内的数求和，求出当和第一次大于20 的当前数【for + break】
    法1：
public class BreakExercise { 
	//编写一个main方法
	public static void main(String[] args) {
		//1-100以内的数求和，求出 当和 第一次大于20的当前数 【for + break】
		
		//思路分析
		//1. 循环 1-100, 求和 sum  
		//2. 当 sum > 20 时，记录下当前数，然后break
		//3. 在for循环外部，定义变量 n , 把当前i 赋给 n
		int sum = 0; //累积和

		//注意i 的作用范围在 for{}
		int n = 0;
		for(int i = 1; i <= 100; i++) {
			sum += i;//累积
			if(sum > 20) {
				System.out.println("和>20时候 当前数i=" + i);
				n = i;
				break;
			} 
		}

		System.out.println("和>20时候 当前数=" + n);
	}
}

法2 ：把 i 定义在for循环外边 ，后边还可以继续使用i

public class zuoye{
	public static void main(String[] args){

	int sum  = 0;

		int i = 0;
		for( ; i <= 100; i++){
		
		sum += i;
		
			if (sum >=20){
			System.out.println(i);
			break;
			}
		}
		System.out.println(i);
	}
	
}
  1. 实现登录验证，有3 次机会，如果用户名为"丁真" ,密码"666"提示登录成功，否则提示还有几次机会，请使用for+break完成BreakExercise02.java
import java.util.Scanner;
public class BreakExercise02 { 

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

		//实现登录验证，有3次机会，如果用户名为"丁真" ,密码"666"提示登录成功，
		//否则提示还有几次机会，请使用for+break完成
		//
		// 思路分析
		// 1. 创建Scanner对象接收用户输入  
		// 2. 定义 String name ; String passwd; 保存用户名和密码
		// 3. 最多循环3次[登录3次]，如果 满足条件就提前退出
		// 4. 定义一般变量 int chance 记录还有几次登录机会
		// 
		// 代码实现
		
		Scanner myScanner  = new Scanner(System.in);
		String name = "";
		String passwd = "";
		int chance = 3; //登录一次 ，就减少一次
		for( int i = 1; i <= 3; i++) {//3次登录机会
			System.out.println("请输入名字");
			name = myScanner.next();
			System.out.println("请输入密码");
			passwd = myScanner.next();
			//比较输入的名字和密码是否正确
			//补充说明字符串 的内容 比较 使用的 方法 equals
			if("丁真".equals(name) && "666".equals(passwd)) {
				System.out.println("恭喜你，登录成功~");
				break;
			}

			//登录的机会就减少一次
			chance--;
			System.out.println("你还有" + chance + "次登录机会");

		}
	}
}

14.跳转控制语句-continue

  • 基本介绍：
  1. continue 语句用于结束本次循环，继续执行下一次循环。
  2. continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环, 这个和前面的标签的
    使用的规则一样.
  • 基本语法：
    { ……
    continue;
    ……
    }
  • 以while 使用continue 为例,画出示意图
    在这里插入图片描述
  • 快速入门案例
    在这里插入图片描述
  • 细节案例分析和说明

public class ContinueDetail { 

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

		label1:
		for(int j = 0; j < 2; j++){
			label2:
			for(int i = 0; i < 10; i++){
				if(i == 2){
			//看看分别输出什么值，并分析
			//continue ; //等价于 continue label2  输出2遍i=0 1 3 4 5 6 7 8 9
			//continue label2;//等价 continue;
			continue label1; //输出 2次[0,1]
				}
				System.out.println("i = " + i);
	        }
	     }
	}
}

15.跳转控制语句-return

return 使用在方法，表示跳出所在的方法，在讲解方法的时候，会详细的介绍，这里我们简单的提一下。注意：如果return 写在main 方法，退出程序…Return01.java


public class Return01 { 

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

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

			if(i==3) {
		        System.out.println("韩顺平教育 "+i);
			return; //当return用在方法时，表示跳出方法，如果使用在main,表示退出程序。
				     //所以这里只输出hello hello 韩顺平3就结束程序
			//如果return换成break，输出的是hello hello 韩顺平3 go
			//如果return换成continue，输出的是hello hello 韩顺平3 hello hello go
			}
			System.out.println("Hello World!");
		}
		System.out.println("go on..");
	}
}

16.本章作业（1-9题）

在这里插入图片描述


public class Homework01 { 

	//编写一个main方法
	public static void main(String[] args) {
		/*
		某人有100,000元,每经过一次路口，需要交费,规则如下:
		1) 当现金>50000时,每次交5%
		2) 当现金<=50000时,每次交1000
		编程计算该人可以经过多少次路口, 要求: 使用 while + break方式完成

		思路分析
		1. 定义 double money 保存 100000
		2. 根据题的要求，我们分析出来有三种情况 
			money > 50000 
			money >=1000 && money <= 50000
			money < 1000 
		3. 使用多分支 if-elseif-else 
		4. while+break[money < 1000], 同时使用一个变量count来保存通过路口
		代码实现
		 */
		double money = 100000;//还有多少钱
		int count = 0; //累积过的路口
		while(true) { //无限循环
			if(money > 50000) { //过路口
				//money = money -  money * 0.05;可以，太啰嗦 
				money *= 0.95; //过了这个路口后，还有这么多钱
				count++;
			} else if(money >=1000) {
				money -= 1000;
				count++;
			} else { //钱不够1000
				break;
			}
		}
		System.out.println("100000 可以过 " + count + " 路口..");
	}
}

法2


public class zuoye{
	public  static void main(String[] args){
		double money = 100000;
		int y = 0; //y表示>50000时可以过多少路口
		int x = 0;//x表示<=50000时可以过多少路口
		while(money > 50000){
			money = money * 0.95 ;
			y++;
		System.out.println(y);		
		}

		while(money <= 50000 && money > 1000){
			money = money - 1000 ;		
				x ++;
			System.out.println(x);
		}
	}
}

方法3：


public class zuoye { 

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

		double money = 100000;//还有多少钱
		int count = 0; //累积过的路口
		for( ; money > 50000;money *= 0.95 ) { //无限循环
				count++;
		}
		for( ;money >=1000 &&  money <= 50000;money -= 1000 ) { //无限循环
				count++;
		}	 
		System.out.println("100000 可以过 " + count + " 路口..");
	}
}

题目2-4
在这里插入图片描述

//第2题
import java.util.Scanner;
public class zuoye{
	public static void main(String[] args){

		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入一个整数");
		int num = myScanner.nextInt();
		if(num > 0){
			System.out.println("您输入数字的范围为>0");
		}else if(num < 0){
			System.out.println("您输入数字的范围为<0");
		}else{
			System.out.println("您输入数字的范围为=0");
		}
	}
}

第4题

import java.util.Scanner;
public class zuoye{
	public static void main(String[] args){
	/*
		4. 判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，
		其各个位上数字立方和等于其本身。
		例如： 153 = 1*1*1 + 3*3*3 + 5*5*5

		思路分析 => 多听. 见多识广..
		1. 比如 int n = 153; 
		2. 先得到 n的百位，十位 ，各位的数字, 使用 if 判断他们的立方和是否相等
		3. n的百位 = n / 100
		4. n的十位 = n % 100 / 10
		5. n的各位 = n % 10
		6. 判断即可
		 */
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入一个三位数");
		int n = myScanner.nextInt();
		int n1 = n / 100;
		int n2 = n % 100 / 10;
		int n3 = n % 10;
		if(n1 * n1 * n1 + n2 * n2 * n2 + n3 * n3 * n3 == n) {
			System.out.println(n + "是水仙花数");
		} else {
			System.out.println(n + "不是水仙花数");
		}
	}
}

在这里插入图片描述
在这里插入图片描述
第6题

public class Homework06 { 
	//编写一个main方法
	public static void main(String[] args) {
		/*
		输出1-100之间的不能被5整除的数，每5个一行

		思路分析
		1. 先输出1-100的所有数
		2. 然后过滤输出 不能被5整除的数 i % 5 !=0
		3. 每5个一行, 我们使用 int count 统计输出的个数 当 count%5=0就说明
			输出了5个，这时，我们输出 一个换行即可控制
		代码实现
		 */
		int count = 0; //统计输出的个数
		for(int i = 1; i <= 100; i++) {
			if(i % 5 != 0) {
				count++;
				System.out.print(i + "\t");//这样就不换行了

				//判断, 每满5个，就输出一个换行..
				if(count % 5 == 0) {
					System.out.println();
				}
			}
		}
	}
}

第7题 法1

public class Homework07 { 
	//编写一个main方法
	public static void main(String[] args) {
	
		//输出小写的a-z以及大写的Z-A
		//考察我们对 a-z编码和 for的综合使用
		//思路分析
		//1. 'b' = 'a' + 1 c = 'a' + 2
		//2. 使用for搞定
		
		for(char c1 = 'a'; c1 <= 'z'; c1++) {
			System.out.print(c1 +" ");
		} 
		System.out.println("============");
		//灵活的使用，编程..
		for(char c1 = 'Z'; c1 >= 'A'; c1--) {
			System.out.print(c1 +" ");
		}	
	}
}

第7题 法2


public class zuoye{
	public static void main(String[] args){

		for(int i = 97; i <= 122; i++){
			System.out.print((char)i + " ");//强转
		}

		System.out.print("\n");//
		
		for(int j = 90; j >= 65; j--){
			System.out.print((char)j+ " ");//强转
		}
	}
}

第8题


public class Homework08 { 

	//编写一个main方法
	public static void main(String[] args) {
		/*
		求出1-1/2+1/3-1/4…..1/100的和
		思路分析
		1. 1-1/2+1/3-1/4…..1/100 = (1/1)-(1/2)+(1/3)-(1/4)...1/100
		2. 从上面的分析我们可以看到 
		(1) 一共有100数 ， 分子为1 , 分母从1-100
		(2) 还发现 当分母为奇数时，前面是 +, 当分母是偶数时，前面是-
		3. 我们可以使用 for + 判断即可完成
		4. 把结果存放到 double sum 
		5. 这里有一个隐藏的陷阱，要把 公式分子 1 写出1.0 才能得到精确的小数
		 */
		
		double sum = 0;
		for(int i = 1; i <= 100; i++) {
			//判断是奇数还是偶数，然后做不同的处理
			if( i % 2 != 0) {//分母为奇数
				sum =  sum + (1.0/i);
			} else { //分母我偶数
				sum = sum - (1.0/i);
			}
		}

		System.out.println("sum=" + sum);
	}
}

第9题


public class Homework09 { 

	//编写一个main方法
	public static void main(String[] args) {
		//求(1)+（1+2）+（1+2+3）+（1+2+3+4）+...+(1+2+3+..+100)的结果
		//
		//思路分析
		//1. 一共有100项相加
		//2. 每一项的数字在逐渐增加
		//3. 很像一个双层循环
		//i 可以表示是第几项,同时也是当前项的最后一个数
		//4. 使用 sum 进行累计即可
		int sum = 0;
		for(int i = 1; i <= 100; i++) {
			for(int j = 1;j <= i; j++) {//内层对1-i进行循环
				sum += j;
			}
		}
		System.out.println("sum=" + sum);  
	}
}
码农小C
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java/JavaEE 学习笔记
03-20
Core Java学习笔记...........31 第一章 JAVA前言..31 第二章 标识符，关键字，类型........35 第三章 表达式与流控制....................41 第四章 数组.............50 第五章 对象和类（OO思想）.........53 第...
Java学习笔记 --- 双分支
乌云的博客
09-14 855
1
11-Golang中的单分支、双分支、多分支
weixin_49750432的博客
12-26 1235
if 条件表达式{执行代码块}说明：当条件表达式为true的时候，就会执行{}的代码。注意{}是必须要有的，就算只有一行代码var age int fmt . Println("请输入你的年龄：") fmt . Scanln(& age) if age > 18 {fmt . Println("我猜你已经成年了doge") } //golang中支持在if中，直接定义一个变量 if age := 20;
两个线程并发执行以下代码,假设a是全局变量,那么以下输出___哪个是可能的?
hyqsong的专栏
12-28 1万+
两个线程并发执行以下代码,假设a是全局变量,那么以下输出_哪个是可能的?int a=1; void foo(){ ++a; printf("%d",a); }解析假设线程x和y同时执行，x和y可随时被抢占，a的初始值为1 A：3, 2 y先执行++a，a为2; y再执行printf，a入栈，在打印到终端之前切换到x x执行＋＋a，a为3; x执行printf，输出3;再切换到
计算机操作系统（第四版）题（一）
Valendia的博客
06-26 1万+
↵ 1.计算机系统的组成包括（）。[2分] A.程序和数据 B.处理器和内存 C.计算机硬件和计算机软件D.处理器、存储器和外围设备 计算机系统包括计算机软件和硬件 2.（）是多道操作系统不可缺少的硬件支持。[2分] A.打印机B.中断机构 C.软盘 D.鼠标 中断技术出现可以让CPU实现在不同程序切换执行 3.（）操作不是P操作可完成的。[2分]A.为进程分配处理机 B.使信号量的值变小 C.可用于进程的同步 D.使进程进入阻塞状态 分配处理机是由进程调度中的分派程序完...
Java笔试题（一）单选题
热门推荐
互联网叫兽
08-15 13万+
1、下列哪一种叙述是正确的 A． abstract修饰符可修饰字段、方法和类 B． 抽象方法的body部分必须用一对大括号{ }包住 C． 声明抽象方法，大括号可有可无 D． 声明抽象方法不可写出大括号 答案：D abstract（抽象）修饰符，可以修饰类和方法 abstract修饰符在修饰类时必须放在类名前。 public abstract void method(); 2、如下代码，...
Oracle 10g 学习笔记
12-30
│ Oracle Direct-Path Insert学习笔记 - NyThing的Java日记 - JavaEye技术网站.mht │ oracle 常用傻瓜1000问 - oracle10g - 小呵呵.mht │ oracle 常用傻瓜1000问 - oracle10g - 小呵呵.mht.lnk │ ORACLE 面试...
Java开发详解.zip
09-02
000000_【课程介绍 —— 写在前面的话】_Java学习概述笔记.pdf 010101_【第1章：JAVA概述及开发环境搭建】_JAVA发展概述笔记.pdf 010102_【第1章：JAVA概述及开发环境搭建】_Java开发环境搭建笔记.pdf 010201_【第2...
整理后java开发全套达内学习笔记（含练习）
06-06
FrameWork [java] 结构,框架 ['freimwә:k] Generic [java] 泛型 [dʒi'nerik] goto (保留字) 跳转 heap n.堆 [hi:p] implements (关键字) 实现 ['implimәnt] import (关键字) 引入(进口,输入) Info n.信息 ...
J2EE学习笔记
06-28
第五章：软件系统架构设计 167 第六章：J2EE专题学习 167 6.1:EJB 167 6.2:JMS 172 6.3:Socket 182 6.4:WebService 189 6.5:集群分布式应用(以JBOSS为例) 190 6.6:JNLP原理及应用： 190 6.7:Log4原理及应用： 191 ...
数据挖掘一些面试题总结（Data　Mining）
Blog of Benley
07-14 2万+
Data-Mining试题 2011Alibaba数据分析师（实习）试题解析 一、异常值是指什么？请列举1种识别连续型变量异常值的方法？ 异常值（Outlier） 是指样本中的个别值，其数值明显偏离所属样本的其余观测值。在数理统计里一般是指一组观测值中与平均值的偏差超过两倍标准差的测定值。 Grubbs’ test（是以Frank E.Grubbs命名的），又叫maximumnormed
第二章 进程管理-操作系统原理和实践
aiqq136的博客
04-14 4094
上章回顾 在前一节的内容中我们讨论了操作系统的的一些相关内容， 包括：OS的目标和作业、OS的发展过程、OS的基本特性、OS的主要功能和OS的结构设计。 其中需要特别强调的是OS的四大基本特征（并发性、共享性、虚拟技术、异步性） 1）并发性 -- 并发与并行 （并行性是指多个事件在同一时刻同时发生，并发性是指多个事件在同一时间间隔内发生。 在多道程序环境下，并发性指在一段时间内宏观上有多个程序在同时运行， 在单处理机环境上同一时刻只能运行一道程序，所有微观上这些程序都是分时地交替执行。 如果有多个处理机
两个线程并发执行以下代码，假设a是全局变量，那么以下输出______是不可能的？...
weixin_34194551的博客
08-29 668
3、两个线程并发执行以下代码，假设a是全局变量，那么以下输出______是不可能的？voidfoo(){++a;printf("%d",a);}A、32B、23C、33D、22 1.读a5.读a2.a+16.a+13.写a7.写a4.打印a8.打印aB...
第三章 流程控制语句结构
shield911的博客
09-15 2082
if条件，for循环，while循环，do...while循环等流程控制语句
双分支流程图
xiaochenxiaoren的博客
11-05 5334
问题：画流程图，输入两个整数a和b，输出其中的大值。
JavaScript学习笔记（四）三大基本程序控制结构
ozp483618589的博客
12-01 2364
目录JavaScript学习笔记（四）三大基本程序控制结构一、顺序结构二、分支结构（一）if语句（二）if…else语句（三）多重if…else语句（四）switch语句三、循环结构（一）for循环（二）while循环（三）do…while循环 JavaScript学习笔记（四）三大基本程序控制结构 在JavaScript中，程序的基本控制结构有三种，分别是顺序结构、分支结构和循环结构，任何简单或者复杂的算法都可以由这三种基本结构构成。下面让我们来了解一下这三种基本结构。 一、顺序结构 顺序结构是程序设
3、分支结构流程图
AntaresYF的博客
01-08 4万+
绘图工具：Microsoft Visio 2013 1. 单分支结构流程图——大值 问题：画流程图，输入两个整数a和b，输出其中的大值。 （提示：当a&lt;b时，交换a和b，最后输出的a一定是其中的大值。流程图中可以直接给出交换a和b的具体算法，也可以用文字“交换a和b”说明。流程图是面向人的设计语言，人能看明白即可。） 2. 双分支结构流程图——大值 问题：画流程图，输入两个整数a和b，输出...
#java练习#编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。否则，打印两数的乘积。
weixin_51661198的博客
03-30 2134
class AriTest{ public static void main(String[] args){ double a = 9.3; double b = 19.1; if(a > 10.0 & b <20.0) System.out.println(a + b); else System.out.println(a * b); } }
MapObject学习笔记－第一讲 MO概述及程序设计入门
最新发布
05-25
MapObject（简称MO）是一种用于开发GIS应用程序的可视化编程组件，可以在VB、VC、Delphi、C#等开发环境中使用。其主要功能包括地图显示、地图浏览、地图查询、符号绘制、地图分析等。 MO的核心是Map对象，它代表了一张地图。Map对象包含了地图数据、地图的显示方式、地图的空间参考等信息。在MO中，地图数据通常以Shapefile格式存储，可以包括点、线、面等空间要素。 MO的编程模型是基于事件的，即程序通过响应组件的事件来完成操作。例如，当用户在地图上点击时，会触发Map控件的MouseDown事件，程序可以在该事件中编写代码来响应用户的操作。 MO的程序设计入门可以从以下几个方面来学习： 1. 创建地图控件：在VB、VC等开发环境中，可以通过向窗体添加Map控件来创建地图控件。在Delphi中，需要在窗体上添加一个TMapControl控件，再通过代码创建Map对象并将其与TMapControl关联起来。 2. 加载地图数据：可以使用Map对象的AddLayer方法，将Shapefile文件加载到地图中。加载后，可以设置要素的显示方式、标注等属性。 3. 地图操作：可以通过Map控件提供的方法，实现地图的缩放、平移、旋转等操作。例如，可以通过调用Map控件的ZoomIn方法实现地图放大，通过调用Map控件的Pan方法实现地图平移。 4. 地图查询：可以使用Map对象的SelectByShape方法，根据指定的查询条件进行地图查询。查询结果可以在地图上高亮显示。 5. 符号绘制：可以使用Map对象中的Symbol对象，绘制点、线、面等符号。例如，可以使用Symbol对象的DrawPoint方法，绘制一个点符号。 以上是MO的一些基础概念和编程入门，希望可以帮助你进行MO的学习和应用开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农小C

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值