三.Java基本语法

最新推荐文章于 2024-07-13 22:56:10 发布

ASDWYang

最新推荐文章于 2024-07-13 22:56:10 发布

阅读量222

点赞数

文章标签： java eclipse

本文链接：https://blog.csdn.net/m0_47489229/article/details/120588619

版权

本篇文章是根据视频学的，来源如下所示：

教程来源：	java基础到高级_零基础自学Java–尚硅谷–宋红康
教程视频地址：	java基础到高级_零基础自学Java--尚硅谷--宋红康_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1ny4y1Y7CW

43.使用Scanner从键盘获取int类型数据

44.使用Scanner从键盘获取多种数据类型

45.if-else的例题1

45.if-else的例题2

46.if-else课后练习题1：笔试题

47.if-else课后练习题2：狗的年龄

48.if-else课后练习题3：彩票问题

49.if-else课后练习4：高富帅

50.switch-case结构的基本使用

51.switch-case结构的使用说明

52.switch-case的例题1、2

53.switch-case课后练习：日积月累

54.switch-case与if-else的转换说明

1、关键字和保留字的说明

定义：被Java语言赋予了特殊的含义，有专门用途的字符串。
特点：关键字中，所有的字母都是小写

保留字：现有的版本尚未使用，但是以后的版本可能会作为关键字使用。如：goto、const。

2、标识符及命名规则

/*
标识符的使用：
1.标识符：凡是自己可以起名的地方。比如：类名、变量名等。
2.标识符的命名规则：  -------------如果不遵守，编译不通过
  （1）由26个字母大小写，0-9，_和$
  （2）数字不可以开头
  （3）不能使用关键字
  （4）标识符不能包含空格
  （5）标识符严格控制大小写，长度无限制，如:Static
*/
class  IdentiferTest
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

3、标识符的命名规则

3.Java中的命名规范:***********建议大家遵守
	（1）包名：多单词组成时所有字母都小写，xxxyyyzzz
	（2）类名、接口名：多单词组成时，所有单词首字母大写，其余小写，XxxYyyZzz
	（3）变量名、方法名：多单词组成时，第一个单词小写，其余单词首字母大写，xxxYyyZzz
	（4）常量名：所有字母都大写，有下划线分隔开，XXX_YYY_ZZZ
4.注意:
     (1)起名字要做到，见名知意
	 (2)java采用unicode字符集，因此标识符可以使用汉字，但是不建议使用。
*/
class  IdentiferTest
{
	public static void main(String[] args) 
	{
			int myNumber = 100;
			System.out.println(myNumber);

			int 学号 = 10000;
			System.out.println(学号);
	}
}

4、变量的定义

变量是最基本的存储单元，包含变量类型、变量名和存储的值。如：字符型、整型、浮点型、布尔型等。

/*
变量的使用
1.java定义变量的格式：数据类型 变量名 = 变量值；
*/
class  VariableTest
{
	public static void main(String[] args) 
	{
		//变量的定义
		int myAge = 12;
		//变量的使用
		System.out.println(myAge);
		//变量的声明
		int myNumber;
		//变量的赋值
		myNumber = 23;
		//变量的使用
		System.out.println(myNumber);
	}
}

5、定义变量的注意点

/*
2.说明：
  （1）变量必须先声明，后使用。
  （2）变量都定义在其作用域之内，在作用域里面是有效的，出了作用域，其是无效的。
  （3）同一个作用域内不可以声明两个同名的变量。通过反证法与逆向思维进行验证。

*/

class  VariableTest
{
	public static void main(String[] args) 
	{
		//变量的定义
		int myAge = 12;
		//变量的使用
		System.out.println(myAge);
		//变量的声明
		int myNumber;
		//变量的赋值
		myNumber = 23;
		//变量的使用
		System.out.println(myNumber);
	}

	public void method()
	{
		int myClass = 10;//只能在自己的大括号里面使用
	}
}

6、变量的分类

注意：字符串是一个类class

/*
Java定义的数据类型
一、变量按照数据类型来分
	基本数据类型：
		整形：byte/short/int/long
		浮点型：float/double
		字符型：char
		布尔型：boolean

	引用数据类型：
		类（class）
		接口（interface）
		数组（array）

二、变量在类之中声明的位置
		成员变量vs局部变量（等到第四章面向对象的时候再学）

*/
class VariableTest1 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

7、整型变量的使用说明

整形变量的区别如下所示：

byte:-2^7~2^7-1, short:-2^15~2^15-1, int:-2^31~2^31-1, long:-2^63~2^63-1

/*
Java定义的数据类型
一、变量按照数据类型来分
	基本数据类型：
		整形：byte/short/int/long
		浮点型：float/double
		字符型：char
		布尔型：boolean

	引用数据类型：
		类（class）
		接口（interface）
		数组（array）

二、变量在类之中声明的位置
		成员变量vs局部变量（等到第四章面向对象的时候再学）

*/
class VariableTest1 
{
	public static void main(String[] args) 
	{
		//整形：byte（1个字节=8bit）/short（2个字节）/int（4个字节）/long（8个字节）
	    //（1）byte的范围：-128~127
		byte b1 = 12;
		byte b2 = -128;
		//b2 = 128;编译不通过
		System.out.println(b1);
		System.out.println(b2);
		//（2）声明long变量必须以小写的l或者大写的L结尾
		//（3）通常使用的是int
		short s1 = 123;
		int i1 = 1234;
		long l1 = 123456789L;
		System.out.println(l1);
	}
}

8、浮点型变量的使用说明

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

		//2.浮点型：float（4字节)\double(8字节)
		//(1)浮点型，表示带有小数点的数值
		//(2)float表示数值的范围比long大
		double d1 = 123.4;
		System.out.println(d1+1);
		//(3)float类型变量在定义的时候，结尾要以f或者F结尾
		float f1 = 123.4f;
		System.out.println(f1+12);
		//(4)通常我们使用的浮点型是double类型
	}
}

9、char类型变量的使用说明

型是double类型

		//3.字符型：char（2个字节）
		//(1)定义char类型变量，通常是使用一对''，里面只能是一个字符，并且中文、日文或者韩语都可以。
		char c1 = '1';
		System.out.println(c1);
		//(2)表示方式：1.声明一个字符 2.转义字符 3.直接使用unicode值表示字符型常量
		char c2 = '\n';//换行符
		c2 = '\t';//制表符
		System.out.print("hello"+c2);
		System.out.println("world");

		char c3 = '\u0123';//没有相应的字符，因此显示为？
		c3 = '\u0043';//查阅CodeCharts.pdf可以知道他代表C
		System.out.println(c3);
	}
}

10.乱码的情况和字符集的说明

ASCII 码：上个世纪 60 年代，美国制定了一套字符编码，对英语字符与二进制位之间的

关系，做了统一规定。这被称为 ASCII 码。 ASCII 码一共规定了128个字符的编码，比如

空格“ SPACE” 是 32 （二进制 00100000 ），大写的字母 A 是 65 （二进制 01000001 ）。这

128 个符号（包括 32 个不能打印出来的控制符号），只占用了一个字节的后面 7 位，最前

面的 1 位统一规定为 0。
默认的存储方式是ANSI （GBK）写入与读必须是一致的

11.boolean型数据变量的使用

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

		//4.布尔类型：boolean
		//（1）只能取两个值之一：true或者false
		boolean bb1 = true;
		System.out.println(bb1);
		//(2)常用与条件判断
		boolean isMarried = true;
		if(isMarried)
		{
			System.out.println("不能参加\"单身\"派对！\\n非常抱歉");
		}
		else
		{
			System.out.println("赶快参加单身派对");
		}
	}
}

特别注意\的使用，详情见上面代码，可以通过排除法进行详解

12.自动类型提升运算

/*
基本数据类型之间的运算规则：

前提：这里讨论的是7中基本类型数据之间的数据运算，不包含boolean类型。
1.自动类型提升：
	当容量小的数据类型的变量与容量大的数据类型变量间的运算，结果自动提升为容量大的数据类型。
	byte->short->int->long->float->double
	char->int->long->float->double
	byte、short、char->int->long->float->double
	注意：当byte、char、short三种变量做运算时，结果为int类型。
*/
class VariableTest2 
{
	public static void main(String[] args) 
	{
		byte b1 = 2;
		int i1 = 123;
		//byte b2 = b1 + i1;编译不通过
		int  b2 = b1 + i1;
		long  b3 = b1 + i1;
		float  b4 = b1 + i1;
		System.out.println(b2);//125
		System.out.println(b3);//125
		System.out.println(b4);//125.0

		//************************************
		char c1 = 'a';
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);

		short s2 = 10;
		//char c2 = c1 + s2; 
		
		byte b5 = 10;
		//char c2 = c1 +b3; 


	}
}

13.强制类型转换运算（未完待续）

/*
2.强制类型转换：自动类型提升运算的逆运算，容量大的转换为容量小的
(1)需要使用强制转换符号：()
(2)注意点：强制类型转换可能会导致精度损失。
*/
class  VariableTest3
{
	public static void main(String[] args) 
	{
		//精度损失举例1
		double d1 = 12.3;
		int i1 = (int)d1;//截断操作
		System.out.println(i1);

		//没有精度损失
		long l1 = 123;
		short s2 = (short)l1;
		//精度损失举例2
		int i2 = 128;
		byte b = (byte)i2;
		System.out.println(b);
		}
}

14.变量运算规则的两个特殊情况

class VariableTest4 
{
	public static void main(String[] args) 
	{
		//1.编码情况1
		long l = 123123;//默认为int向long转换
		System.out.println(l);
		//long l1 =1231232123564;  //编译失败：过大的整数
        //float f1 = 12.3；        //必须后面加f或者F，因为默认为double向float转换，是不可行的

		//2.编码情况2
		//整型常量，默认类型是int型
		//浮点型常量，默认类型是double型
		byte b = 12;
		//byte b1 = b + 1;//编译失败
		//float f1 = b + 12.3;

	}
}

15.String类型变量的使用

/*
String类型变量的使用
1.String属于引用数据类型,翻译为字符串
2.声明String类型变量时，使用""
3.String可以和8种基本数据类型做运算，且运算只能是连接运算:+
4.运算的结果仍然是String类型
*/
class StringTest 
{
	public static void main(String[] args) 
	{
		String s1 = "Hello World";
		System.out.println(s1);
		String s2 = "a";
		String s3 = "";
		//char s4 = '';//注意：char类型只能是一个字符，多了和少了都是不可以的

		int number = 10001;
		String numberStr = "学号：";
		String info = numberStr + number;//+是连接运算符
		System.out.println(info);
		boolean b1 = true;
		String info1 = info + b1;
		System.out.println(info1);
	}
}

16.两个关于String的练习题

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


		//练习1
		char c ='a';
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);//107hello
		System.out.println(c + str + num);//ahello10
		System.out.println(c + (num + str));//a10hello
		System.out.println((c + num) + str);//107hello
		System.out.println(str + num + c);//hello10a
        
        //练习2
		//输出*	*
		System.out.println("*	*");//可以
		System.out.println('*' + '\t' + '*');//char+char=int
		System.out.println('*' + "\t" + '*');//可以，第二个是String类型
		System.out.println('*' + '\t' + "*");//char+char=int
		System.out.println('*' + ('\t' + "*"));//可以


	}
}

17.String使用的强化说明

下面是在课程之中的两个练习题

18.不同进制的表示方法

对于整数而言，有四种表示方法：

二进制：0,1，满2进1。以0b或者0B开头。

十进制：0-9，满10进1。

八进制：0-7，满8进1。以数字0开头。

十六进制：0-9及A-F，满16进1。以0x或者0X开头。

/*
计算机之中不同进制的学习
*/
class BinaryTest 
{
	public static void main(String[] args) 
	{ 
		int num1 = 0b110;
		int num2 = 110;
		int num3 = 0127;
		int num4 = 0x110A;

		System.out.println("num1 = " + num1);
		System.out.println("num2 = " + num2);
		System.out.println("num3 = " + num3);
		System.out.println("num4 = " + num4);
	}
}

19.二进制转换为十进制的说明

正数的原码、反码、补码相同。

20.二进制转换为十进制的练习

具体的转换使用计算器

21.十进制转换为二进制

十进制转换为二进制进行除以2取余数

22.二进制与八进制、十六进制之间的转换

二进制转换为八进制，三个一位
二进制转换为十六进制，四个一位

23.每日一考

标识符的命名规则有哪些？
标识符的命名规范有哪些？
Java变量按照数据类型怎么划分？并且找出Java的基本数据类型有哪8种，并指出各自占用的内存空间大小。
说明基本数据类型变量之间自动类型提升的运算规则。
说明基本数据类型变量之间强制类型转换的使用规则和强制可能出现的问题。

24.算数运算符的使用1

25.算数运算符的使用2

26.算数运算符的练习

27.关于敲代码和练指法

28.赋值运算符的使用

29.赋值运算符的课后练习

30.比较运算符的使用

（前面这几个博主写的时候忘记保存了，后面再补上）

31.逻辑运算符的使用说明

32.逻辑运算符的使用测试

注意短路情况的出现

/*
运算符之四：逻辑运算符

&  && |  || ! ^

说明：
1.逻辑运算符操作的都是boolean类型的变量


*/
class LogicTest {
	public static void main(String[] args) 
		{
		//区分& 与 &&
		//相同点1：& 与  && 的运算结果相同
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算
		//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
		//开发中，推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0))
		{
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num1 = " + num1);
		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0))
		{
			System.out.println("我现在在北京");
		}else
		{
			System.out.println("我现在在南京");
		}

		System.out.println("num2 = " + num2);

		// 区分：| 与 || 
		//相同点1：| 与  || 的运算结果相同
		//相同点2：当符号左边是false时，二者都会执行符号右边的运算
		//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
		//开发中，推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0))
		{
			System.out.println("我现在在北京");
		}else
		{
			System.out.println("我现在在南京");
		}
		System.out.println("num3 = " + num3);
		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0))
		{
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num4 = " + num4);
	}
}

33.逻辑运算符的课后练习

class LogicTest {
	public static void main(String[] args) 
		{
int x = 1;
int y=1;
if(x++==2 & ++y==2)
{
x =7;
}
System.out.println("x="+x+",y="+y);//x=2，y=2

int x = 1,y = 1;
if(x++==2 && ++y==2)
{
x =7;
}
System.out.println("x="+x+",y="+y);//x=2，y=1

int x = 1,y = 1;
if(x++==1 | ++y==1)
{
x =7;
}
System.out.println("x="+x+",y="+y);//x=7，y=2

int x = 1,y = 1;
if(x++==1 || ++y==1)
{
x =7;
}
System.out.println("x="+x+",y="+y);//x=7，y=1
}
}

 class Test {
 public static void main (String [] args) {
 boolean x=true;
 boolean y=false;
 short z=42;
 //if(y == true)
 if((z++==42)&&(y=true))z++;//z=44；这里应当注意y=true
 if((x=false) || (++z==45)) z++;//z=46

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

34.左移右移位运算符的使用

这里应当注意的是>>>与>>的不同。

/*
运算符之五：位运算符 （了解）
结论：
1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
   >> :在一定范围内，每向右移1位，相当于 / 2

面试题：最高效方式的计算2 * 8 ？ -------2 << 3或者说8 << 1
*/
class BitTest {
	public static void main(String[] args)
		{
		int i = 21;
		//i = -21;负数同正数一样
		System.out.println("i << 2 :" + (i << 2));//因为存在优先级的原因，故而应当加一个括号:i*2*2=84
		System.out.println("i << 3 :" + (i << 3));//i*2*2*2=168
		System.out.println("i << 27 :" + (i << 27));//移动过头了，最高位是一，变成了一个负数（过犹不及，物极必反）

	}
}

35.其他位运算符的使用

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

		int m = 12;
		int n = 5;
		System.out.println("m & n :" + (m & n));//4
		System.out.println("m | n :" + (m | n));//13
		System.out.println("m ^ n :" + (m ^ n));//9

	}
}

相应的解释如下所示：（取反运算符为字面意思）

36.位运算符的练习

class BitTest {
	public static void main(String[] args)
		{
		
		//练习：交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1 = " + num1 + ",num2 = " + num2);

		//方式一：定义临时变量的方式
		//推荐的方式
		int temp = num1;
		num1 = num2;
		num2 = temp;

		//方式二：好处：不用定义临时变量  
		//弊端：（1）相加操作可能超出存储范围 （2）有局限性：只能适用于数值类型
		//num1 = num1 + num2;
		//num2 = num1 - num2;
		//num1 = num1 - num2;

		//方式三：使用位运算符（异或^的使用），道理与方式二相同，只是方式不一样
		//有局限性：只能适用于数值类型
		//num1 = num1 ^ num2;
		//num2 = num1 ^ num2;
		//num1 = num1 ^ num2;

		System.out.println("num1 = " + num1 + ",num2 = " + num2);

	}
}

37.三元运算符的使用

（表达式）？表达式1：表达式2；如果表达式是True，返回表达式1，否则返回表达式2。

/*
运算符之六：三元运算符
1.结构：(条件表达式)? 表达式1 : 表达式2
2. 说明
（1）条件表达式的结果为boolean类型
（2）根据条件表达式真或假，决定执行表达式1，还是表达式2.
  如果表达式为true，则执行表达式1。
  如果表达式为false，则执行表达式2。
（3）表达式1 和表达式2要求是一致的。（他们的类型必须是一致的）
（4）三元运算符可以嵌套使用
*/
class SanYuanTest {
	public static void main(String[] args) 
		{
		//获取两个整数的较大值
		int m = 12;
		int n = 5;
		int max = (m > n)? m : n;
		System.out.println(max);

		double num = (m > n)? 2 : 1.0;
		//(m > n)? 2 : "n大";//编译错误

		//三木运算符的嵌套
		n = 12;
		String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
		System.out.println(maxStr);

		//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;
		
		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)? max1 : n3;
		System.out.println("三个数中的最大值为：" + max2);

		//不建议
		//int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
		System.out.println("三个数中的最大值为：" + max3);

	}
}

38.三目运算符与if-else的转换

/*
3. 凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。
4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
*/
class SanYuanTest {
	public static void main(String[] args) 
		{
		//获取两个整数的较大值
		int m = 12;
		int n = 5;

		//写成if-else:
		if(m > n){
			System.out.println(m);
		}else{
			System.out.println(n);
		}
	}
}

39.运算符的优先级

套用括号，除了面试或者应对考试，下面的符号不用记住。

40.关于流程控制的说明

三种基本流程结构：顺序结构、分支结构、循环结构。
程序员----码农

41.if-else结构的基本使用

三种格式：

1.if（条件表达式）{执行代码块；}

2.if（条件表达式）{执行代码块1；}else{执行代码块2；}

3.if（条件表达式）{执行代码块1；}else if{执行代码块2；}....else{执行代码块n；}

class IfTest {
	public static void main(String[] args)
		{
		//举例1
		int heartBeats = 79;
		if(heartBeats < 60 || heartBeats > 100)
		{
			System.out.println("需要做进一步检查");
		}
		System.out.println("检查结束");

		//举例2
		int age = 23;
		if(age < 18)
		{
			System.out.println("你还可以看动画片");
		}else
		{
			System.out.println("你可以看成人电影了");
		}

		//举例3
		if(age < 0)
		{
			System.out.println("您输入的数据非法");
		}else if(age < 18)
		{
			System.out.println("青少年时期");
		}else if(age < 35)
		{
			System.out.println("青壮年时期");
		}else if(age < 60)
		{
			System.out.println("中年时期");
		}else if(age < 120)
		{
			System.out.println("老年时期");
		}else
		{
			System.out.println("你是要成仙啊~~");
		}
	}
}

42.每天一考

"&"与"&&"的异同

答：二者都表示与功能，表示且的关系，全真为真。"&"的两边表达式都执行，"&&"的左边表达式为True时，才执行右边的表达式。

class OperatorTest {
	public static void main(String[] args) 
{
		boolean x = true;
		boolean y = false;
		short z = 40;
		if ((z++ == 40) && (y = true))
 {
			z++;
		}//z=42
		if ((x = false) || (++z == 43))
 {
			z++;
		}//z=44
		System.out.println("z = " + z);
	}
}

3.定义三个int型变量并赋值，使用三元运算符或者if-else获取这三个数中的较大数的实现

int num1 = 10,num2 = 21,num3 = -21;

int max;
if(num1 >= num2 && num1 >= num3)
{
    max = num1;
}
else if(num2 >= num1 && num2 >= num3)
{
    max = num2;
}
else
{
    max = num3;
}

System.out.println("三个数中的最大值为：" + max);

4.编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。否则，打印两数的乘积。

double d1 = 12.3;
double d2 = 32.1;
double he;
if(d1 > 10 && d2 < 20)
{
he = d1 + d2;
}
else
{
	he = d1 * d2;
}
System.out.println(he);

5. 交换两个变量值的代码的实现

String s1 = "北京";
String s2 = "南京";

String temp = s1;
         s1 = s2;
         s2 = temp;

43.使用Scanner从键盘获取int类型数据

/*
如何从键盘获取不同类型的变量：需要使用Scanner类

具体步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化;
3.调用Scanner类的相关方法获取指定类型的变量
*/
import java.util.Scanner;
class ScannerTest 
{
	public static void main(String[] args) 
	{
		Scanner scan = new Scanner (System.in);
		int num = scan.nextInt();
		System.out.println(num);

	}
}

44.使用Scanner从键盘获取多种数据类型

/*
如何从键盘获取不同类型的变量：需要使用Scanner类

具体步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化;Scanner scan = new Scanner (System.in);
3.调用Scanner类的相关方法获取指定类型的变量
4.String对应着scan.next，其余的类型对应着scan.nextXxx

注意：需要根据相应的方法，来输入指定的类型的数值。如果输入
      的数据类型与要求的数据类型不匹配时，会出现异常，会报InputMisMatchException导致程序停止。
*/
import java.util.Scanner;
class ScannerTest 
{
	public static void main(String[] args) 
	{
		Scanner scan = new Scanner (System.in);
		
		System.out.println("请输入你的姓名：");
		String name = scan.next();
		System.out.println(name);

		System.out.println("请输入你的年龄：");
		int age = scan.nextInt();
		System.out.println(age);

		System.out.println("请输入你的体重：");
		double weight = scan.nextDouble();
		System.out.println(weight);

		System.out.println("你是否看中我了呢？");//true/false
		boolean isLove = scan.nextBoolean();
		System.out.println(isLove);

		//对于char类型，没有对应的scan.nextXxx与之对应
		System.out.println("请输入你的性别：（男/女）");
		String gender = scan.next();//'男'

		char genderChar = gender.charAt(0);//获取索引位置为0上的字符
		System.out.println(genderChar);

	}
}

45.if-else的例题1

/*
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断

说明：
1. else 结构是可选的。
2. 针对于条件表达式：
   > 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
   > 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
   > 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
*/
import java.util.Scanner;
class IfTest 
{
	public static void main(String[] args) 
	{
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入岳小鹏的成绩：（0-100分）");
		int score = scan.nextInt();

		if(score == 100)
		{
			System.out.println("奖励一辆BMW");//be my wife！
		}
		else if ((80 < score )&&(score <= 99))
		{
			System.out.println("奖励一台iPhone xs max");
		}
		else if ((score >= 60)&&(score <= 80))
		{
			System.out.println("奖励一台iPad");
		}
		else
		{
			System.out.println("什么也没有");
		}

	}
}

45.if-else的例题2

注意：博主写的是从大到小的排序，视频是从小到大的排序。（写顺手了）

/*
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从大到小输出。

说明：
1. if-else结构是可以相互嵌套的。
2. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。
*/
import java.util.Scanner;
class IfTest2 
{
	public static void main(String[] args) 
	{
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入第一个整数：");
		int num1 = scanner.nextInt();
		System.out.println("请输入第二个整数：");
		int num2 = scanner.nextInt();
		System.out.println("请输入第三个整数：");
		int num3 = scanner.nextInt();

		if(num1 >= num2)
		{
			if(num2 >= num3)
			{
			System.out.println(num1 + "," + num2 + "," + num3);
			}
			else if(num3 >= num1)
			{
			System.out.println(num3 + "," + num1 + "," + num2);
			}
			else 
			{
			System.out.println(num1 + "," + num3 + "," + num2);
			}
		}
		else
		{
			if(num1 >= num3)
			{
			System.out.println(num2 + "," + num1 + "," + num3);
			}
			else if(num3 >= num2)
			{
			System.out.println(num3 + "," + num2 + "," + num1);
			}
			else 
			{
			System.out.println(num2 + "," + num3 + "," + num1);
			}
		}

		
	}
}

46.if-else课后练习题1：笔试题

//1)对下列代码，若有输出，指出输出结果。
int x = 4;
int y = 1;
if (x > 2) 
{
if (y > 2) 
System.out.println(x + y);
System.out.println("atguigu");
} 
else
System.out.println("x is " + x);

//结果是：atguigu

class IfExer 
{
	public static void main(String[] args) 
	{
		
	int x = 4;
	int y = 1;
	if (x > 2) 
	
	if (y > 2) 
	System.out.println(x + y);
	//System.out.println("atguigu");运行的时候这句话应当注释掉，否则会报错
	else//就近原则
	System.out.println("x is " + x);
	//结果是:4
	}
}

boolean b = true;
//如果写成if(b=false)能编译通过吗？如果能，结果是？
if(b == false) 
System.out.println("a");
else if(b)
System.out.println("b");//输出
else if(!b)
System.out.println("c");
else
System.out.println("d");

47.if-else课后练习题2：狗的年龄

class IfExer 
{
	public static void main(String[] args) 
	{
	/*3) 我家的狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前两年每
	一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗
	相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。
	*/
	double manAge;
	int dogAge = 5;
	if(dogAge <= 2)
		{
			manAge = 10.5 * dogAge;
		}
		else
		{
			manAge = 10.5 * 2 + (dogAge - 2) *4;
		}
		System.out.println(manAge);
	}
}

48.if-else课后练习题3：彩票问题

这里我们讲解随机数的产生问题，具体的代码在老师给的word里面有的，这里只要掌握相应的逻辑即可。

class IfExer 
{
	public static void main(String[] args) 
	{
		//课后练习4：如何获取随数：10-99
		int value = (int)(Math.random() * 90 + 10);//[0.0,1.0)-----------[0.0,90.0)-----------[10.0,100.0)--------[10,99]
		System.out.println(value);
		//公式：[a,b] : (int)(Math.random() * (b-a+1) + a )
	}
}

题目：假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入

一个两位数，然后按照下面的规则判定用户是否能赢。

1) 如果用户输入的数匹配彩票的实际顺序，奖金 10 000 美元。

2) 如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000 美元。

3) 如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金 1 000 美元。

4) 如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金 500 美元。

5) 如果用户输入的数字没有匹配任何一个数字，则彩票作废。

49.if-else课后练习4：高富帅

/*
大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出
一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”
*/
import java.util.Scanner;
class  IfExer1
{
	public static void main(String[] args) 
	{
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入你的身高：（cm）");
		int height = scan.nextInt();
		System.out.println("请输入你的财富：（千万）");
		double wealth = scan.nextDouble();
		/*方式一
		System.out.println("请输入你是否帅：（true/false）");
		boolean isHandsome = scan.nextBoolean();
		
		if(height >= 180 && wealth >= 1 && isHandsome)
		{
		System.out.println("我一定嫁给他");
		}
		else if(height >= 180 || wealth >= 1 || isHandsome)
		{
		System.out.println("嫁吧，比上不足，比下有余");
		}
		else
			{
				System.out.println("不嫁给他");
			}
		*/

		//方式二
		System.out.println("请输入你是否帅：（是/否）");
		String isHandsome = scan.next();

		if(height >= 180 && wealth >= 1 && isHandsome.equals("是"))
		{
		System.out.println("我一定嫁给他");
		}
		else if(height >= 180 || wealth >= 1 || isHandsome.equals("是"))
		{
		System.out.println("嫁吧，比上不足，比下有余");
		}
		else
			{
				System.out.println("不嫁给他");
			}
	}
}

50.switch-case结构的基本使用

/*
分支结构之二：switch-case
1.格式
switch（表达式）
case 常量1：
执行语句1；
break；
case 常量2：
执行语句2；
break；
case 常量3：
执行语句3；
break；
...
default：
执行语句n；
break；

2.说明：
(1)根据switch表达式中的数值，依次匹配各个case中的常量。一旦匹配后才能进入相应的case结构之中，调用其执行语句。
	当调用完执行语句以后，则仍然继续向下执行其他的case结构语句，直到遇到break，则跳出，终止。
（2）break，使用在switch-case结构之中，一旦执行到此关键字，则跳出。
*/
class SwitchCaseTest 
{
	public static void main(String[] args) 
	{
		int number = 2;
		switch(number)
		{
			case 0:
				System.out.println("zero");
				break;
			case 1:
				System.out.println("one");
				break;
			case 2:
				System.out.println("two");
				break;
			case 3:
				System.out.println("three");
				break;
			default:
				System.out.println("others");//可以不加break
		}
	}
}

51.switch-case结构的使用说明

/*
分支结构之二：switch-case


2.说明：
(1)根据switch表达式中的数值，依次匹配各个case中的常量。一旦匹配后才能进入相应的case结构之中，调用其执行语句。
	当调用完执行语句以后，则仍然继续向下执行其他的case结构语句，直到遇到break，则跳出，终止。
(2)break，使用在switch-case结构之中，一旦执行到此关键字，则跳出。
(3)switch结构之中的表达式，只能是如下六种数据类型之一：byte、short、char、int、枚举类型（JDK5.0）、String类型（JDK7.0）
(4)case之后只能是一个常量不能是一个范围
(5)break关键字是可选的
(6)default相当于if-else之中的else，就是个备胎，default结构是可选的，并且位置是灵活的
*/
class SwitchCaseTest 
{
	public static void main(String[] args) 
	{

		//错误示范：情况一
		/*
		boolean isHandsome = true;
		switch(isHandsome)
		{
			case true:
				System.out.println("我好帅呀..");
			break；
			case false:
				System.out.println("我好聪明呀..");
			break；

		}
		*/

		//错误示范：情况二
		/*
		int age = 10;
		switch(age)
		{
			case age > 18:
				System.out.println("我成年了");
			break;
			default:
				System.out.println("我未成年");
		}
		*/

		String season = "summer";
		switch(season)
		{
			case "spring":
				System.out.println("春暖花开");
			break;
			case "summer":
				System.out.println("夏日炎炎");
			break;
			case "autumn":
				System.out.println("秋风萧瑟");
			break;
			case "winter":
				System.out.println("白雪皑皑");
			break;
			default:
				System.out.println("输入有误");
		}
	}
}

52.switch-case的例题1、2

/*
1.使用 switch 把小写类型的 char型转为大写。只转换 a, b, c, d, e. 其它的输
出 “other”。
提示：String word = scan.next(); char c = word.charAt(0); switch(c){}
2.对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

*/
import java.util.Scanner;
class SwitchCaseTest1 
{
	public static void main(String[] args) 
	{
		//练习一
		Scanner scan = new Scanner(System.in);
		String word = scan.next();
		char c = word.charAt(0);
		switch(c)
		{
			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("other");
			break;
		}

		//练习二：多个语句相同，则考虑合并
		int score = 78;
		switch(score/10)
		{
			case 10:				
			case 9:				
			case 8:
			case 7:
			case 6:
				System.out.println("合格");
			break;
			default:
				System.out.println("不合格");
			break;
		}
		switch(score/60)//更便捷的方式
		{
			case 1:
				System.out.println("合格");
			break;
			default:
				System.out.println("不合格");
			break;
		}


	}
}

/*
编写程序：从键盘上输入2021年的“month”和“day”，要求通过程序输出输入的日期为2019年的第几天。
说明:break在switch-case中是可选的
*/
import java.util.Scanner;
class SwitchCaseTest2 
{
	public static void main(String[] args)
 {
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入2021年的month：");
		int month = scan.nextInt();
		System.out.println("请输入2021年的day：");
		int day = scan.nextInt();

		//定义一个变量来保存总天数
		int sumDays = 0;
		switch(month)
        {
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			sumDays += 28;
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}
		System.out.println("2021年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

53.switch-case课后练习：日积月累

/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
或 2）可以被400整除
*/
import java.util.Scanner;
class SwitchCaseExer
	{
	public static void main(String[] args) 
		{
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入year：");
		int year = scan.nextInt();
		System.out.println("请输入month：");
		int month = scan.nextInt();
		System.out.println("请输入day：");
		int day = scan.nextInt();

		//定义一个变量来保存总天数
		int sumDays = 0;
		switch(month)
		{
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			//sumDays += 28;
		//判断这个year是不是闰年
			if(year%4 == 0 && year%100 != 0 || year%400 ==0)
				{
					sumDays += 29;
				}
			else
				{
					sumDays += 28;
				}
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}
		System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

54.switch-case与if-else的转换说明

说明：

1.凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
2.当我们写分支结构时候，既可以使用switch-case（case的取值情况不太多），又可以使用if-else时候，我们优先使用switch-case。原因：switch-case的执行效率比较高一些

55.循环结构及for循环的理解

三种循环：for循环、while循环、do-while循环

56.for循环结构的使用

/*
for循环的使用
一、循环结构的四个要素：（1）初始化条件、（2）循环条件【是boolean类型】、（3）循环体、（4）迭代条件
二、for循环的结构
for（（1）；（2）；（4））{（3）}
执行过程：（1）-（2）-（3）-（4）-（2）-（3）-（4）-...-（2）【不满足】-------跳出循环
*/
class  ForTest
{
	public static void main(String[] args) 
	{
		for(int i = 0;i < 500;i++)
		{
		System.out.println("Hello World!");
		}//i在for循环以内有效，跳出循环无效

		//练习：
		int num = 1;
		for(System.out.print('a');num <=3;System.out.print('c'),num++)
		{
			System.out.print('b');
		}//输出：abcbcbc

		//例题：遍历100以内的偶数,输出所有偶数的和
		int sum = 0;
		int count = 0;
		for(int i = 1;i <= 100;i++)
		{
			if(i % 2 ==0)
			{
				System.out.println(i);
				sum += i;
				count++;
			}
		}
		System.out.println("总和为" + sum);
		System.out.println("个数为" + count);
	}
}

57.for循环的例题

class ForTest1 
{
	public static void main(String[] args) 
	{
		for(int i = 1;i <= 150;i++)
		{
			System.out.print(i);
			if(i%3 == 0)
			System.out.print(" foo");
			if(i%5 == 0)
			System.out.print(" biz");
			if(i%7 == 0)
			System.out.print(" baz");
			System.out.println();
		}
		System.out.println("Hello World!");
	}
}

58.每天一考

1.switch后面使用的表达式可以是哪些数据类型的。

答：byte 、 short 、char 、int 、枚举类型变量、String类型

2. 使用switch语句改写下列if语句：

原程序 
int a = 3;
      int x = 100;
      if(a==1)
        x+=5;
      else if(a==2)
        x+=10;
      else if(a==3)
        x+=16;
      else        
        x+=34;
修改的
int a = 3;
int x = 100;
switch(a)
{
case 1:
    x+=5;
    break;
case 2:
    x+=10;
    break;
case 3:
    x+=16;
    break;
default:
    x+=34;
    //break;
}

3. 谈谈你对三元运算符、if-else和switch-case结构使用场景的理解

答：三元运算符与switch-case可以转换为if-else，尽量使用前两种，因为其执行效率比较高。

4. 如何从控制台获取String和int型的变量，并输出？使用代码实现

1.import java.util.Scanner;

2. Scanner scan = new Scanner(System.in);

3. String info = scan.next(); 
   int id = scan.nextInt();

5. 使用for循环遍历100以内的奇数，并计算所有的奇数的和并输出。

int sum = 0;
for(int i = 1;i <= 100;i++)
{
    if(i % 2 != 0)
{
        System.out.println(i);
        sum += i;
    }
}
 System.out.println(sum);

59.for循环的例题2

/*
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用
*/
import java.util.Scanner;
class ForTest 
{
	public static void main(String[] args) 
	{
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入正整数m：");
		int m = scan.nextInt();
		System.out.println("请输入正整数n：");
		int n = scan.nextInt();

		//获取最大公约数
		//1.获取两个数之中的较小的数
		int min = (m <= n)? m : n;
		//2.遍历
		for (int i = min;i >= 1 ;i-- )
		{
			if(m % i == 0 && n % i ==0)
			{
				System.out.println("最大公约数为" + i);
				break;//一旦在循环之中执行到break，则跳出循环
			}
		}
		
		//获取最小公倍数
		//1.获取两个数之中的较大的数
		int max = (m >= n)? m : n;
		//2.遍历
		for (int i = max;i <= (m * n) ;i++ )
		{
			if(i % m == 0 && i % m ==0)
			{
				System.out.println("最大公倍数为" + i);
				break;//一旦在循环之中执行到break，则跳出循环
			}
		}

	}
}

60.for循环课后题

1.打印1~100之间所有奇数的和
2.打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数器的思想）
3.输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如： 153 = 1*1*1 + 3*3*3 + 5*5*5（这一道题在黑马程序员的课程之中看到过）

61.while循环的基本使用

/*
while循环的使用
一、循环条件的四个要素：（1）初始化条件、（2）循环条件----是boolean类型、（3）循环体、（4）迭代条件

二、while循环的结构
（1）
while（（2））
{
	(3);
	(4);
}
说明：
1.写while循环，千万不要忘记迭代条件，一旦丢了就会出现死循环。（写程序的时候要保证不会出现死循环）
2.for循环与while循环是可以相互转换的（小的区别在于初始化条件的作用范围不一样）
3.执行过程：（1）-（2）-（3）-（4）-（2）-（3）-（4）-...-（2）-（3）-（4）
*/
class WhileTest 
{
	public static void main(String[] args) 
	{
		//遍历100以内的偶数
		int i = 1;
		while(i <= 100)
		{
			if( i%2 == 0)
			{
				System.out.println(i);
			}
			i++;
		}			 
	}
}

62.do-while循环的基本使用

/*
do-while循环
一、循环条件的四个要素：（1）初始化条件、（2）循环条件----是boolean类型、（3）循环体、（4）迭代条件
二、结构

（1）
do
{
	（3）；
	（4）；

}while（（2））；
三、执行过程 （1）-（3）-（4）-（2）-（3）-（4）-（2）-...-（2）
四、说明1
	1.do-while至少执行一次
	2.for和while使用的更多一些，较少使用do-while

*/
class DoWhileTest 
{
	public static void main(String[] args) 
	{   //遍历100以内的偶数，并且计算所有的偶数的和以及偶数的个数
		int num = 1;
		int sum = 0;
		int count = 0;
		do
		{
			if(num%2 == 0)
			{
				System.out.println(num);
				sum += num;
				count++;
			}
			num++;
		}
		while (num<=100);
		System.out.println("总和是" + sum);
		System.out.println("个数是" + count);

		//********************
		int number = 10;
		while(number > 10)
		{
			System.out.println("Hello while");
			number--;
		}

		//do-while至少执行一次
		int number1 = 10;
		do
		{
			System.out.println("Hello while");
			number--;
		}
		while (number1 > 10);
	}
}

63.while（true）结构的使用

/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

说明：
1.不在循环条件部分限制次数的结构：for(;;)或者while(true)
2.结束循环的几种方式
  方式一：循环条件部分返回
  方式二：在循环体中执行break
*/
import java.util.Scanner;
class Practice 
{
	public static void main(String[] args) 
	{
		Scanner scan = new Scanner(System.in);
		
		int i = 0;//正数
		int j = 0;//负数

		for(;;)//while(true)//这里的处理方式需要注意一些
		{
			int Key = scan.nextInt();
			if(Key > 0)
			{
			i++;
			}
			else if(Key < 0)
			{
			j++;
			}
			else
			{
			 break;
			}
		}
		System.out.println("正数的个数:" + i);
		System.out.println("负数的个数:" + j);

	}
}

64.嵌套循环的使用1、2

/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，构成了嵌套循环
2.
外层循环：循环结构B
内层循环：循环结构A
3.说明
（1）内层循环遍历一次，相当于外部循环体执行了一次
（2）假设外层循环执行了m次，内层循环执行了n次，那么一共执行了m*n次
4.外层控制行数，内层控制列数
*/
class ForForTest 
{
	public static void main(String[] args) 
	{
		//******
		System.out.println("******");
		for(int i = 1; i <= 6;i++)
		{
			System.out.print('*');
		}
		System.out.println();
		System.out.println();

		/*
		****
		****
		****
		****
		*/
		for(int i = 1;i <= 4;i++)
		{
			for(int j = 1;j <=4;j++)
			{
				System.out.print('*');
			}
				System.out.println();
		}

		/*
		*
		**
		***
		****
		*/
        for(int i = 1;i <= 4;i++)//控制行数
		{
			for(int j = 1;j <= i;j++)//控制列数
			{
				System.out.print('*');
			}
				System.out.println();

		}

		/*
		****
		***
		**
		*
		*/
		int k = 4;
		for(int i = 1;i <= 4;i++)
		{
			for(int j = 1;j <= k;j++)//这里或者将k换成5-i
			{
				System.out.print('*');
			}
			k--;
				System.out.println();
		}
		/*易得
		*
		**
		***
		****
		****
		***
		**
		*
		*/

		/*
		*
	   * *
	  * * *
	 * * * * 
	  * * *
	   * *
	    *
		*/
		//上半部分和下半部分

       

	}
}

65.嵌套循环练习：九九乘法表

/*
九九乘法表
1*1=1
2*1=2 2*2=4
... ...
9*1=9 9*2=18 ... 9*9=81
*/
class NineNineTable 
{
	public static void main(String[] args) 
	{
		int mul;
		for(int i = 1; i <= 9; i++)
		{
		for(int j = 1; j <= i; j++)
		{   
			mul = i * j;
			System.out.print(i + "*" + j + "=" + mul + " ");
		}
		    System.out.println();
		}
	}
}

66.质数输出的实现方式一

/*
100以内的质数的输出
质数：素数，只能被1和它本身所整除的自然数。---从二开始到这个数减一结束都不能被这个数本身所整除。
最小的质数是:2
*/
class PrimeNumberTest 
{
	public static void main(String[] args) 
	{
		boolean isFlag = true;
		for(int i = 2;i <= 100;i++)//遍历100以内的自然数
		{
			for(int j = 2;j < i;j++)//j：被i去除
				{
					if(i%j == 0)
					{
						isFlag = false;//千万不要忘记去重置
					}
				}
			if(isFlag == true)//表明它是一个质数
			{
				System.out.println(i);
			}
			isFlag = true;//进行重置
		}
	}
}


class PrimeNumberTest 
{
	public static void main(String[] args) 
	{
		
		for(int i = 2;i <= 100;i++)//遍历100以内的自然数
		{
            boolean isFlag = true;
			for(int j = 2;j < i;j++)//j：被i去除
				{
					if(i%j == 0)
					{
						isFlag = false;//千万不要忘记去重置
					}
				}
			if(isFlag == true)//表明它是一个质数
			{
				System.out.println(i);
			}
		}
	}
}

67.质数输出的算法优化一

（今天有事明天接着更新）

ASDWYang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
三.Java基本语法

本篇文章是根据视频学的，来源如下所示：教程来源： java基础到高级_零基础自学Java–尚硅谷–宋红康教程视频地址： java基础到高级_零基础自学Java--尚硅谷--宋红康_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1ny4y1Y7CW 目录1、关键字和保留字的说明定义：被Java语言赋予了特殊的含义，有专门用途的字符串。特点：关键字中，所有的字母都是小写保留字：现...
复制链接

扫一扫