黑马全套Java教程（一）

本博客配套黑马的教学视频：链接

1 Java概述

1.0 JDK下载与安装

https://blog.csdn.net/qq_39236499/article/details/119602147

1.1 Java基本介绍

Java语言是美国Sun公司在1995年退出的计算机语言

Java版本

• 5.0是更新力度最大的版本
• 8.0是公司用的最多的版本
• 11.0是学习Java基础使用的版本
  
  

Java语言跨平台原理
Java语言可以在任意操作系统上运行，只需要安装JVM（Java虚拟机）

JRE和JDK
JRE：是Java程序运行时的环境，包含JVM和运行所需要的核心类库，我们想要运行一个已有的Java程序，那么只需要安装JRE即可

JDK：是Java程序开发工具包，包含JRE和开发人员使用的工具，其中的开发工具：编译工具（javac.exe）和运行工具（java.exe）

1.2 JDK的安装目录

2 Java基础语法

2.0 Java编译和运行

开发Java程序，需要三个步骤：编写程序，编译程序，运行程序

编译和运行：打开cmd窗口，进入到HelloWorld.java对应目录下，输入：
编译：java 文件名.java
范例：java HelloWorld.java
运行：java 类名
范例：java HelloWorld

2.1 hello world案例

HelloWorld.java

public class HelloWorld{
	public static void main(String[] args){
		System.out.println("HelloWorld，黑马");
	}
}

编译和运行如下：（记得要切换到HelloWorld.java的目录下）

2.2 注释

• 单行注释：//内容
• 多行注释：/内容/
• 文档注释：/*内容/

// 这是单行注释
/* 这是多行注释*/

/*
	JAVA程序中最基本的组成单位是类。
	类的定义格式：
		public class 类名{
			
		}
	这是我定义的HelloWorld类
*/
public class HelloWorld{
	/*
		这是main方法
		main方法是程序的入口方法，代码的执行是从main方法开始的
	*/
	public static void main(String[] args){
		//这是输出语句
		System.out.println("HelloWorld，黑马");
	}
}

2.3 关键字

关键字？：被Java语言赋予了特定含义的单词
关键字特点？：关键字字母全部小写

2.4 常量

常量：在程序运行过程中，其值不会发生改变的量

ConstantDemo.java

/*
	常量：
		在程序运行过程中，其值不发生改变的量
	常量分类：6类
		1.字符串常量：双引号括起来
		2.整数常量
		3.小数常量
		4.字符常量：单引号括起来
		5.布尔常量：布尔值，表示真假，true，false
		6.空常量：null
*/

public class ConstantDemo{
	//字符串常量
	public static void main(String[] args){
		//1.字符串常量
		System.out.println("1.字符串常量");
		System.out.println("HelloWorld");
		System.out.println("黑马");
		System.out.println("--------------");
		
		//2.整数常量
		System.out.println("2.整数常量");
		System.out.println(66);
		System.out.println(-88);
		System.out.println("--------------");
		
		//3.小数常量
		System.out.println("3.小数常量");
		System.out.println(3.14);
		System.out.println(-5.21);
		System.out.println("--------------");
		
		//4.字符常量
		System.out.println("4.字符常量");
		System.out.println('A');
		System.out.println('0');
		System.out.println('我');
		System.out.println("--------------");
		
		//5.布尔常量
		System.out.println("5.布尔常量");
		System.out.println(true);  //true和false是关键字
		System.out.println(false);
		System.out.println("--------------");
		
		//6.空常量：不能直接输出
		System.out.println("6.空常量");
		System.out.println("空常量不能直接输出");
		//System.out.println(null);
	}
}

2.5 数据类型

计算机存储单元
计算机存储设备的最小信息单元叫位（bit），我们又称之为比特位，通常用小写字母b表示
而计算机中最小存储单元叫字节（byte），通常用大写字母B表示
一个字节由连续的8个位组成

Java语言是强类型语言，对于每一种书库都给出了明确的数据类型，不同的数据类型也分配了不同内存空间，所以它们表示的数据大小也是不一样的

数据类型内存占用和取值范围

2.6 变量

变量：在程序运行过程中，其值发生改变
从本质上讲，变量是内存中一小块区域

变量由三部分组成：变量名，数据类型，变量值
格式： 数据类型 变量名 = 变量值;
范例：int a = 10;

例子

/*
	基本数据类型：
		byte,short,int,long,float,double,char,boolean
*/
public class VariableDemo01{
	public static void main(String[] args){
		//定义变量
		int a = 10;
		//输出变量
		System.out.println(a);
		
		//修改变量
		a = 20;
		System.out.println(a);
	}
}

注意事项：

1. 不要定义相同的变量名
2. 定义变量时需要赋值
3. long类型加L
4. float类型加F

例2

public class VariableDemo02{
	public static void main(String[] args){
		//定义byte类型的变量
		byte b = 10;
		System.out.println(b);
		
		//定义short类型的变量
		short s = 100;
		System.out.println(s);
		
		//定义int类型的变量
		int i = 10000;
		System.out.println(i);
		
		//定义double类型的变量
		char c = 'a';
		System.out.println(c);
		
		//定义boolean类型的变量
		//boolean b = true;       //错误，b与上面变量同名
		//System.out.println(b);
		boolean bb = true; 
		System.out.println(bb);
		
		//定义long类型的变量
		long l = 100000000000L;   //这里需要加L
		System.out.println(l);
		
		//定义float类型的变量
		//float f = 13.14;   //错误，浮点数默认double类型
		float f = 13.14F;    //这里需要加F
		System.out.println(f);
	}
}

2.7 标识符

标识符：给类、方法、变量等起名字的符号

定义规则：

• 由字母、数字、下划线和美元符号组成
• 不能以数字开头
• 不能是关键字
• 区分大小写
  

常见命名约定：
（小驼峰命名法，针对方法和变量命名）
标识符第一个单词首字母小写，后面的单词首字母大写，其他小写
范例：name，firstName

（大驼峰命名法，针对类命名）
标识符第一个单词首字母大写，后面的单词首字母大写，其他小写
范例：Student，GoodStudent

2.8 类型转换

类型转换又分自动类型转换和强制类型转换

自动类型转换：把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量
范例：double d = 10;

强制类型转换：把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
格式：目标数据类型 变量名 = (目标数据类型)值或者变量
范例：int k = (int)88.88;

ConversionDemo.java

public class ConversionDemo{
	public static void main(String[] args){
		//自动类型转换
		double d = 10;
		System.out.println(d); //会输出10.0，为浮点数
		
		//定义byte类型的变量
		byte b = 10;
		short s = b;
		int i = b;
		//这是不可以的，类型不兼容
		//char c = b;
		
		
		//强制类型转换
		int k = (int)88.88;   //浮点数强制转化为int,再赋值给k
		System.out.println(k);  //输出88，整型
	}
}

3 运算符

3.1 算术运算符

/*
	算术运算符
*/
public class OperatorDemo01{
	public static void main(String[] args){
		//定义两个变量
		int a = 6;
		int b = 4;
		System.out.println(a+b);
		System.out.println(a-b);
		System.out.println(a*b);
		System.out.println(a/b);   //得到整数
		System.out.println(a%b);
		//整数相除只能得到整数，要想得到小数必须有浮点数参与
		System.out.println(6.0/4);
	}
}

例：字符加操作

/*
	字符的“+”操作
*/
public class OperatorDemo02{
	public static void main(String[] args){
		//定义两个变量
		int i = 10;
		char c = 'A';              //值为65
		System.out.println(i+c);   //输出75
		System.out.println(i+'a');  //107
		System.out.println(i+'0');   //58
		
		//char ch = i + '0';    //错误
		//char类型会被自动提升为int类型
		int j = i + '0';
		System.out.println(j);
		
		
		//int k = 10 + 13.14;
		double d = 10 + 13.14;
		System.out.println(d);
		int dd = 10 + (int)13.14;
		System.out.println(dd);
	}
}

例2：字符串加操作

/*
	字符串的“+”操作
*/
public class OperatorDemo03{
	public static void main(String[] args){
		System.out.println("IT" + "heima");   //拼接
		System.out.println("IT" + 666); 
		System.out.println(666 + "IT heima"); 
		
		System.out.println("黑马" + 6 + 666); 
		System.out.println(6 + 666 + "黑马" );  //先加再拼接
	}
}

3.2 赋值运算符

/*
	赋值运算符
*/
public class OperatorDemo04{
	public static void main(String[] args){
		//把10赋值给int类型的变量i
		int i = 10;
		System.out.println("i:" + i);
		
		// +=
		i += 20;
		System.out.println("i:" + i);
		
		//注意：扩展的赋值运算符底层隐含了强制类型转换
		short s = 10;
		s += 40;  //用这个最好
		//s = s + 40;  //错误，40为int类型
		s = (short)(s+40);
		System.out.println("s:" + s);
	}
}

3.3 自增自减运算符

/*
	自增自减运算符
*/
public class OperatorDemo05{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		System.out.println("i:" + i);
		
		i++;
		System.out.println("i:" + i);
		
		++i;
		System.out.println("i:" + i);
		
		
		//参与操作使用
		//i++：先进行赋值再加1
		//++i：先加1再进行赋值
		int j = i++;
		System.out.println("i++赋值给j：");
		System.out.println("i:" + i);   //13
		System.out.println("j:" + j);   //12
		
		int m = 12;
		int n = ++m;
		System.out.println("++m赋值给n：");
		System.out.println("m:" + m);   //13
		System.out.println("n:" + n);   //13
		
	}
}

3.4 关系运算符

/*
	关系运算符
*/
public class OperatorDemo06{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 10;
		
		//==
		System.out.println(i==j);
		System.out.println(i==k);
		System.out.println("----------");
		
		//!=
		System.out.println(i!=j);
		System.out.println(i!=k);
		System.out.println("----------");
		
		//>
		System.out.println(i>j);
		System.out.println(i>k);
		System.out.println("----------");
		
		//>=
		System.out.println(i>=j);
		System.out.println(i>=k);
		System.out.println("----------");		
		
		//不小心把==写成了=
		System.out.println(i=j);  //j赋值给i，并输出i
	}
}

3.5 逻辑运算符

/*
	逻辑运算符
*/
public class OperatorDemo07{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		
		//&
		System.out.println((i<j)&(i<k));
		System.out.println("--------------------");
		
		//|
		System.out.println((i>j)|(i<k));
		System.out.println("--------------------");
		
		// ^ 异或：相异为1，相同为0
		System.out.println((i>j)^(i<k));
		System.out.println((i<j)^(i<k));
		System.out.println("--------------------");
		
		// !
		System.out.println(i>j);
		System.out.println(!(i>j));
		System.out.println(!!(i>j));
		System.out.println(!!!(i>j));
	}
}

短路逻辑运算符

/*
	短路逻辑运算符
*/
public class OperatorDemo08{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		
		//&&：这里与&结论一样
		System.out.println((i>j)&&(i>k));
		System.out.println((i>j)&&(i<k));		
		System.out.println((i<j)&&(i<k));
		System.out.println((i<j)&&(i>k));
		System.out.println("--------------------");
		
		//||：这里与|结论一样
		System.out.println((i>j)||(i>k));
		System.out.println((i>j)||(i<k));		
		System.out.println((i<j)||(i<k));
		System.out.println((i<j)||(i>k));
		System.out.println("--------------------");
		
		//&&和&
		System.out.println((i++>100) & (j++>100));  //false & false     这两个都进行了运算  i=11,j=21
		//&&检测到左边是false时，右边就不执行了
		//System.out.println((i++>100) && (j++>100));  //false & false     i=11,j=20
		System.out.println("i:" + i);
		System.out.println("j:" + j);
	}
}

3.6 三元运算符

格式：关系表达式 ？ 表达式1 : 表达式2;
范例：a>b ? a : b;
若关系表达式结果为true，则运算结果为表达式1,；否则为表达式2

/*
	三元运算符
	
	格式：
		关系表达式？表达式1:表达式2;
	范例：
		a > b ? a : b;
	执行流程：
		首先计算关系表达式的值
		如果值为true，表达式1的值就是运算结果
		如果值为false，表达式2的值就是运算结果
*/
public class OperatorDemo09{
	public static void main(String[] args){
		//定义两个变量
		int a = 10;
		int b = 20;
		//获取最大值
		int max = a > b ? a : b;
		
		System.out.println("max:" + max);
	}
}

案例：两只老虎
例：判断两只老虎体重是否相同

/*
	两只老虎
	
	需求：判断体重是否相同，用三元运算符
*/
public class OperatorTest01
{
	public static void main(String[] args)
	{
		//1.定义体重
		int weight1 = 100;
		int weight2 = 120;
		
		//2.三元运算符判断比较
		boolean b = weight1==weight2 ? true : false;
		
		//3.打印输出
		System.out.println("b:" + b);
	}
}

案例：三个和尚
输出三个和尚的最高身高

/*
	三个和尚
	
	需求：输出最高身高，用三元运算符
*/
public class OperatorTest02
{
	public static void main(String[] args)
	{
		//1.定义身高
		int weight1 = 100;
		int weight2 = 200;
		int weight3 = 300;
		
		//2.比较
		int temp = weight1>weight2 ? weight1 : weight2;
		int max = temp>weight3 ? temp : weight3;
		
		//3.输出
		System.out.println("max:" + max);
	}
}

4 Scanner

用Scanner实现数据输入，Scanner使用的基本步骤如下：

1. 导包：import java.util.Scanner;
2. 创建对象：Scanner sc = new Scanner(System.in);
3. 接收数据：int i = sc.nextInt();

ScannerDemo.java

import java.util.Scanner;

public class ScannerDemo{
	public static void main(String[] args){
		//2.创建对象
		Scanner sc = new Scanner(System.in);
		
		//3.接收数据
		int x = sc.nextInt();
		
		//输出数据
		System.out.println("x:" + x);
	}
}

案例：三个和尚升级版（手动输入升高）

/*
	三个和尚
	需求：
		一座寺庙里面住着三个和尚，他们的身高必须经过测量得出，请用程序实现获取最高身高
*/

//1.导包
import java.util.Scanner;

public class ScannerTest{
	public static void main(String[] args){
		//2.创建对象
		Scanner sc = new Scanner(System.in);
		
		//3.接收数据
		System.out.println("请输入第一个和尚的身高：");
		int height1 = sc.nextInt();
		
		System.out.println("请输入第二个和尚的身高：");
		int height2 = sc.nextInt();
		
		System.out.println("请输入第三个和尚的身高：");
		int height3 = sc.nextInt();
		
		int tempHeight = height1>height2 ? height1:height2;
		int maxHeight = tempHeight>height3 ? tempHeight:height3;
		
		System.out.println("maxHeight:" + maxHeight);
	}
}

5 分支语句

• 顺序结构
• 分支结构（if，switch）
• 循环结构（for，while，do…while）

5.1 顺序结构

正常的代码流程结构，从上到下

5.2 if语句

if语句总有三种格式：

1. if
2. if…else
3. if…else if…else

例1：if语句

/*
	if语句格式1
	
	格式：
		if(关系表达式){
			语句体;
		}
	
	执行流程：
		1：首先计算关系表达式的值
		2：如果关系表达式的值为ture就执行语句体
		3：如果关系表达式的值为false就不执行语句体
		4：继续执行后面的语句内容
*/
public class IfDemo
{
	public static void main(String[] args)
	{
		System.out.println("开始");
		
		//定义两个变量
		int a = 10;
		int b = 20;
		
		//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
		if (a==b)
		{
			System.out.println("a等于b");
		}
		
		int c = 10;
		if (a==c)
		{
			System.out.println("a等于c");
		}
		
		System.out.println("结束");
	}
}

例2：if…else

/*
	if语句格式2
	
	格式：
		if(关系表达式)
		{
			语句体1；
		}
		else
		{
			语句体2；
		}
	
	执行流程：
		1.首先计算关系表达式的值
		2.如果关系表达式的值为ture就执行语句体1
		3.如果关系表达式的值为false就执行语句体2
		4.继续执行后面的语句内容
*/
public class IfDemo02{
	public static void main(String[] srgs){
		System.out.println("开始");
		
		//定义两个变量
		int a = 10;
		int b = 20;
		b = 5;
		
		if(a>b)
		{
			System.out.println("a大于b");
		}
		else
		{
			System.out.println("a不大于b");
		}
		
		System.out.println("结束");
	}
}

例3：if…else if…else

/*
	格式：
		if(关系表达式1)
		{
			语句体1；
		}
		else if(关系表达式2)
		{
			语句体2；
		}	
		else
		{
			语句体3；
		}
*/

import java.util.Scanner;

public class IfDemo03{
	public static void main(String[] args)
	{
		System.out.println("开始");
		
		//需求：键盘录入一个星期数(1,2,...,7)输出对应的星期一，星期二，...，星期日
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个星期数(1-7): ");
		int week = sc.nextInt();
		
		if(week==1)
		{
			System.out.println("星期一");
		}
		else if(week==2)
		{
			System.out.println("星期二");
		}
		else if(week==3)
		{
			System.out.println("星期三");
		}
		else if(week==4)
		{
			System.out.println("星期四");
		}
		else if(week==5)
		{
			System.out.println("星期五");
		}
		else if(week==6)
		{
			System.out.println("星期六");
		}
		else if(week==7)
		{
			System.out.println("星期日");
		}
		else 
		{
			System.out.println("输入错误！");
		}
		System.out.println("结束");
	}
}

案例：判断奇偶数
输入一个整数，判断奇偶数，并输出

//1.导包
import java.util.Scanner;

public class IfTest{
	public static void main(String[] args)
	{
		//2.创建对象
		Scanner sc = new Scanner(System.in);
		
		//3.接收数据
		int number = sc.nextInt();
		
		if( number%2==0)
		{
			System.out.println(number + "是偶数");
		}
		else
		{
			System.out.println(number + "是奇数");
		}
	}
}

5.3 switch语句

import java.util.Scanner;

public class SwitchDemo
{
	public static void main(String[] args)
	{
		System.out.println("开始");
		//需求：按对应数字输出星期一，星期二，...星期日
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个数字：");
		int week = sc.nextInt();
		
		switch(week)
		{
			case 1:
				System.out.println("星期一");
				break;    //不写break下面也会执行，直到遇到break
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;				
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期日");
				break;		
			default:
				System.out.println("输入错误！");
				break;   //这个break可以省略
		}
		
		System.out.println("结束");
	}
}

案例：春夏秋冬
输入月份，输出季节

/*
	输入月份判断季节
	
	春：3,4,5
	夏：6,7,8
	秋：9,10,11
	冬：1,2,12
*/
//1.daobao 
import java.util.Scanner;

public class SwitchTest
{
	public static void main(String[] args)
	{
		//2.创建对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入年份：");
		//3.接收数据
		int month = sc.nextInt();
		
		switch(month)
		{
			case 1:    //case穿透
			case 2:
			case 12:
				System.out.println("冬季");
				break;
			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;				
			default:   //这个可以不需要break
				System.out.println("你输入的月份有误！");
		}
	}
}

5.4 for循环

/*
	for语句
	
	格式：
		for(初始化语句;条件判断语句;条件控制语句)
		{
			循环体语句;
		}
		
	执行流程：
		1.执行初始化语句
		2.执行条件判断语句，看结果是true还是false
		3.执行循环体语句
		4.执行条件控制语句
		5.回到2继续
*/

public class ForDemo
{
	public static void main(String[] args)
	{
		for(int i=0; i<5; i++)
			{
				System.out.println("Hello World!");
			}
	}
}

案例：输出数据

/*
	输出数据
	
	需求：
		在控制台输出1-5和5-1
*/

public class ForTest01
{
	public static void main(String[] args)
	{
		System.out.println("输出1-5:");
		for (int i=1; i<=5; i++)
		{
			System.out.println("i:" + i);
		}
		
		System.out.println("输出5-1:");
		for (int i=5; i>=1; i--)
		{
			System.out.println("i:" + i);
		}
	}
}

案例：求和
求1-5的和，并输出

/*
	求和
	
	需求：
		求1-5之和，并输出
*/
public class ForTest02
{
	public static void main(String[] args)
	{
		int sum = 0;
		for (int i=1; i<=5; i++)
		{
			sum += i;
		}
		System.out.println("sum=" + sum);
	}
}

案例：求偶数和

/*
	求偶数和
	
	需求：
		求1-100之间的偶数和，并输出
*/
public class ForTest03
{
	public static void main(String[] args)
	{
		int sum = 0;
		for (int i=1; i<=100; i++)
		{
			if (i%2==0)
			{
				sum += i;
			}
		}
		System.out.println("sum=" + sum);
	}
}

案例4：输出所有水仙花数

/*
	水仙花数
		个位的立方 + 十位的立方 + 百位的立方 == 这个数
*/

public class ForTest04
{
	public static void main(String[] args)
	{
		int count = 0;
		for (int i=100; i<1000; i++)
		{
			int geWei = i%10;
			int shiWei = (i/10)%10;
			int baiWei = i/100;
			if (geWei*geWei*geWei + shiWei*shiWei*shiWei + baiWei*baiWei*baiWei == i)
			{
				System.out.println(i);
				count += 1;
			} 
		}
		System.out.println("共有" + count + "个水仙花数！");
	}
}

5.5 while循环语句

while语句这里有两种：

1. while
2. do…while

例：while语句

/*
	while语句
	
	基本格式：
		while(条件判断语句)
		{
			循环体语句;
			条件控制语句;
		}
*/
public class WhileDemo{
	public static void main(String[] args)
	{
		//输出五次hello world
		for (int i=0; i<5; i++)
		{
			System.out.println("Hello World!");
		}
		System.out.println("--------------");
		
		int i = 0;
		while(i<5)
		{
			System.out.println("Hello World!");
			i++;
		}
	}
}

案例：珠穆朗玛峰
纸折叠多少次达到珠穆朗玛峰的高度

/*
	珠穆朗玛峰
*/

public class WhileDemo02
{
	public static void main(String[] args)
	{
		double temp = 0.1;
		int count = 0;
		while(temp<8844430)
		{
			temp = temp*2;
			count += 1;
		}
		System.out.println("共折叠了" + count + "次！");
	}
}

例：do…while语句

/*
	do...while语句
	
	基本格式：
		初始化语句;
		do
		{
			循环体语句;
			条件控制语句;
		}
		while(条件判断语句);
*/
public class DoWhileDemo
{
	public static void main(String[] args)
	{
		int i = 0;
		do
		{
			System.out.println("Hello world!");
			i++;
		}
		while(i<5);   //注意这个有分号
	}
}

三种循环的区别：do…while先执行，再判断

/*
	三种循环的区别
*/
public class LoopTest
{
	public static void main(String[] args)
	{
		//for循环
		for (int i=3; i<3; i++)
		{
			System.out.println("我爱Java");
		}
		System.out.println("1.---------------------");
		
		//while循环
		int j = 3;
		while(j<3)
		{
			System.out.println("我爱Java");
			j++;
		}
		System.out.println("2.---------------------");
		
		//do...while循环
		int k = 3;
		do   //先执行do再执行while
		{
			System.out.println("我爱Java");
			k++;
		}
		while(k<3);
		
		//死循环
		/*
		for(;;)
		{
			System.out.println("for");
		}
		
		while(true)
		{
			System.out.println("while");
		}

		do
		{
			System.out.println("do...while");
		}
		while(true);
		*/
	}
}

6 break、continue

• continue：用在循环体中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
• break：用于结束循环

/*
	continue：用在循环体中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
	break：用于结束循环
*/
public class ControlDemo
{
	public static void main(String[] args)
	{
		for(int i=1; i<=5; i++)
		{
			if(i%2==0)   //跳过2,4
			{
				continue;
				//break;  //这个只会输出1，遇到2就打破了循环
			}
			
			System.out.println(i);
		}
	}	
}

例：循环嵌套

/*
	循环嵌套：
		循环语句中包含循环语句
	
	需求：
		在控制台输出一天的小时和分钟
		
		分钟和小时的范围：
			分钟：0<=minute<60
			小时：0<=hour<24
*/
public class ForForDemo
{
	public static void main(String[] args)
	{
		for(int hour=0; hour<24; hour++)
		{
			for(int minute=0; minute<60; minute++)
			{
				System.out.println(hour + "时" + minute + "分");
			}
		}
	}
}

7 Random

Random用于产生一个随机数
具体使用步骤如下：

1. 导包：import java.util.Random;
2. 创建对象：Random r = new Random();
3. 获取[0, 10)随机数：int number = r.nextInt(10);

RandomDemo.java

import java.util.Random;

public class RandomDemo
{
	public static void main(String[] args)
	{
		//创建对象
		Random r = new Random();
		
		//需求：获取5次10以内随机数
		for(int i=0; i<5; i++)
		{
			int number = r.nextInt(10);   //0~9
			System.out.println("number:" + number);   
		}	
		
		System.out.println("----------------");
		
		//需求：获取一个1~100之间的随机数
		int x = r.nextInt(100) + 1;
		System.out.println(x);
	}
}

案例：猜数字

//1.导包
import java.util.Random;
import java.util.Scanner;

public class RandomTest
{
	public static void main(String[] args)
	{
		//2.创建对象
		Random r = new Random();
		Scanner sc = new Scanner(System.in);
		
		//3.接收随机数
		int trueNum = r.nextInt(100) + 1;
		
		System.out.println("请输入你猜的数字(1-100):");
		int myNum = sc.nextInt();
		
		while(myNum != trueNum)   //或者while死循环到正确，break退出
		{
			if (myNum < trueNum)
			{
				System.out.println("小了");
			}
			else if (myNum > 100)
			{
				System.out.println("输入的数字超出范围(1-100)！");
			}
			else 
			{
				System.out.println("大了");
			}
			
			System.out.println("请重新输入：");
			myNum = sc.nextInt();
		}
		System.out.println("正确");
	}
}