黑马程序员Java教程学习笔记（一）

末初mochu7

已于 2023-03-02 16:36:38 修改

11798

分类专栏： Java 文章标签： java

于 2022-01-17 17:10:23 首次发布

本文链接：https://blog.csdn.net/mochu7777777/article/details/122436030

版权

Java 专栏收录该内容

4 篇文章 4 订阅

订阅专栏

黑马程序员Java学习笔记

Java版本

Java(5.0)：是更新力度很大的一个版本，直接让Java的发展进入了快车道
Java(8.0)：是公司中生产/开发环境使用的最多的版本
Java(11.0)：是Java学习者使用的最多的版本

Java语言的跨平台原理

在需要运行Java应用程序的操作系统上，安装一个与操作系统相对应的Java虚拟机(JVM Java Virtual Machine)即可。

JRE和JDK

JRE(Java Runtime Environment)

是Java程序的运行时环境，包含JVM和运行时所需要的核心类库

只是想要运行一个Java程序，那么只需要安装JRE即可。
JDK(Java Development Kit)

是Java程序开发工具包，包含JRE和开发人员使用的工具。

其中的开发工具：编译工具(javac.exe)和运行工具(java.exe)

JDK、JRE、JVM的关系如下图：
在这里插入图片描述

JDK的下载和安装

Java11 for WIndows: https://www.oracle.com/java/technologies/downloads/#java11-windows

JDK的安装目录

目录名称	说明
`bin`	该路径下存放了JDK的各种工具命令。`javac`和`java`就在这个目录
conf	该路径下存放了JDK的相关配置文件
include	该路径下存放了一些平台特定的头文件
jmods	该路径下存放了JDK的各种模块
legal	该路径下存放了JDK各模块的授权文档
lib	该路径下存放了JDK工具的一些补充JAR包
其他	其余文件为说明性文档

HelloWorld案例

HelloWorld.java

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

D:\Java\mycode>javac HelloWorld.java

D:\Java\mycode>java HelloWorld
Hello World

D:\Java\mycode>

注释

单行注释
```
格式：	//注释信息
```

多行注释

格式：	
/*
注释信息
注释信息
*/

文档注释
```
格式：	
/**
注释信息
*/
```

/*
	Java程序中最基本的组成单位是类。

	类的定义格式:
	public class 类名 {
		
	}
	这是我定义的HelloWorld类
*/

public class HelloWorld {
	/*
		这是main方法
		main方法是程序的入口，代码的执行是从main方法开始的
	*/
	public static void main(String[] args) {
		//这是输出语句，""里面的内容是可以改变的
		System.out.println("Hello World");
	}
}

关键字

关键字的字母全部小写
常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观
Java的关键字有五十个左右

常量

常量：在程序运行中，其值不可以改变的的量

常量类型	说明	举例
字符串常量	用双引号括起来的内容	“HelloWold”，“黑马程序员”
整数常量	不带小数的数字	666，-88
小数常量	带小数的数字	13.14，-5.21
字符常量	用单引号括起来的内容	‘A’，‘0’，‘我’
布尔常量	布尔值，表示真假	只有两个值：true，false
空常量	一个特殊值，空值	值是：null

public class ConstantDemo {
	public static void main(String[] args) {
		//字符串常量
		System.out.println("Hello,World");
		System.out.println("黑马程序员");
		System.out.println("-------");

		//整数常量
		System.out.println(666);
		System.out.println(-88);
		System.out.println("-------");

		//小数常量
		System.out.println(13.14);
		System.out.println(-5.21);
		System.out.println("--------");

		//字符常量
		System.out.println('A');
		System.out.println('0');
		System.out.println('我');
		System.out.println("-------");

		//布尔常量
		System.out.println(true);
		System.out.println(false);
		System.out.println("-------");

		//空常量
		//空常量不能直接输出
		//System.out.println(null);
	}
}

D:\Java\mycode>javac ConstantDemo.java

D:\Java\mycode>java ConstantDemo
Hello,World
黑马程序员
-------
666
-88
-------
13.14
-5.21
--------
A
0
我
-------
true
false
-------

数据类型

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

在这里插入图片描述

数据类型	关键字	内存占用	取值范围
整数	byte	1Byte	-128~127
整数	short	2Byte	-32768~32767
整数	`int(默认)`	4Byte	-2³¹~2³¹-1
整数	long	8Byte	-2⁶³~2⁶³-1
浮点数	float	4Byte	负数：`-3.402823E+38`~`-1.401298E-45` 正数：`1.401298E-45`~`3.402823E+38`
浮点数	`double(默认)`	8Byte	负数：`-1.797693E+308`到`-4.9000000E-324` 正数：`4.9000000E-324`到`1.797693E+308`
字符	char	2Byte	0-65535
布尔	boolean	1Byte	true，false

说明：E+38表示是乘以10的38次方，同样，E-45表示乘以10的负45次方

标识符

规则：由数字、字母、下划线(_)、美元符($)组成
不能以数字开头
不能是关键字
区分大小写

《标识符常见命名规定》

小驼峰命名法：针对方法、变量

约定一：标识符是一个单词的时候，首字母小写

例如：name
约定二：标识符由多个单词组成的时候，第一个单词首写字母小写，其他单词首字母大写

例如：firstName

大驼峰命名法：针对类

约定一：标识符是一个单词的时候，首字母大写

例如：Student
约定二：标识符由多个单词组成的时候，每个单词首写字母大写

例如：GoodStudent

类型转换

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

public class ConversionDemo {
	public static void main(String[] args) {
		//自动类型转换
		double d = 10;
		System.out.println(d);

		//定义byte类型的变量
		byte b = 10;
		short s = b;
		int i = b;
		System.out.println(s);
		System.out.println(i);

		//这是不可以的，类型不兼容
		//char c = b;

		//强制类型转换
		int k = (int)88.88;
		System.out.println(k);
	}
}

D:\Java\mycode>javac ConversionDemo.java

D:\Java\mycode>java ConversionDemo
10.0
10
10
88

运算符

运算符：对常量或者变量进行操作的符号

表达式：用运算符把常量或者变量连接起来符合Java语法的式子就可以称为表达式。

不同的运算符连接的表达式体现的是不同类型的表达式

举例说明：

int a = 10;
int b = 20;
int c = a + b;

+ : 是运算符，并且是算术运算符

a + b : 是表达式，由于+是算术运算符，所以这个表达式叫算术表达式

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);
	}
}

D:\Java\mycode>javac OperatorDemo01.java

D:\Java\mycode>java OperatorDemo01
10
2
24
1
2
1.5

字符"+"操作

拿字符在计算机底层对应的数值来进行计算的，即ASCII码

A -> 65：A-Z是连续的
a -> 97：a-z是连续的
0 -> 48：0-9是连续的

算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升

提升规则：

byte类型，short类型和char类型将被提升到int类型
整个表达式的类型自动提升到表达式中最高等级操作数同样的类型

等级顺序：byte->short->char->int->long->float->double

public class OperatorDemo02 {
	public static void main (String[] args) {
		//定义两个变量
		int i = 10;
		char c = 'A';//'A'的值是65
		c = 'a';//'a'的值是97
		c = '0';
		System.out.println(i + c);

		//char ch = i + c;
		//char类型会被自动提升为int类型
		int j = i + c;
		System.out.println(j);

		//int k = 10 + 13.14;
		double d = 10 + 13.14;
		System.out.println(d);
	}
}

D:\Java\mycode>javac OperatorDemo02.java

D:\Java\mycode>java OperatorDemo02
58
58
23.14

字符串"+"操作

当+操作中出现字符串时，这个+是字符串连接符，而不是算术运算。
在+操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行+操作时，从左到右逐个执行。

  public class OperatorDemo03 {
  	public static void main(String[] args) {
  		System.out.println("it" + "heima");
  		System.out.println("itheima" + 666);
  		System.out.println(666 + "itheima");
  		System.out.println("黑马" + 6 + 66);
  		System.out.println(1 + 99 + "年黑马");
  	}
  }

  D:\Java\mycode>javac OperatorDemo03.java
  
  D:\Java\mycode>java OperatorDemo03
  itheima
  itheima666
  666itheima
  黑马666
  100年黑马

赋值运算符

符号	作用	说明
`=`	赋值	a=10，将10赋值给变量a
`+=`	加后赋值	a+=b，将a+b的值给a
`-=`	减后赋值	a-=b，将a-b的值给a
`*=`	乘后赋值	a=b，将ab的值给a
`/=`	除后赋值	a/=b，将a/b的商给a
`%=`	取余后赋值	a%=b，将a%b的余数给a

注意：扩展的赋值运算符隐含了强制类型转换

自增自减运算符

符号	作用	说明
`++`	自增	变量的值加1
`--`	自减	变量的值减1

注意事项：

++和--既可以放在变量后边，也可以放在变量的前边
单独使用的时候，++和--无论是放在变量前边还是后边，结果都是一样的。
参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。

参与操作的时候，如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。
最常见的用法：单独使用

关系运算符

符号	说明
`==`	a==b，判断a和b的值是否相等，成立为true，不成立为false
`!=`	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
`>`	a>b，判断a是否大于b，成立为true，不成立false
`>=`	a>=b，判断a是否大于等于b，成立为true，不成立为false
`<`	a<b，判断a是否小于b，成立为true，不成立为false
`<=`	a<=b，判断a是否小于等于b，成立为true，不成立为false

注意事项：关系运算符的结果都是boolean类型，要么是true，要么是false。

逻辑运算符

符号	作用	说明
`&`	逻辑与	a&b，a和b都是true，结果为true，否则为false
`	`	逻辑或
`^`	逻辑异或	a^b，a和b的结果不同为true，相同为false
`!`	逻辑非	!a，结果和a的结果正好相反

短路逻辑运算符

符号	作用	说明
`&&`	短路与	作用和`&`相同，但是有短路效果
`		`

注意事项：

逻辑与&，无论左边真假，右边都要执行。
短路与&&，如果左边为真，右边执行，如果左边为假，右边不执行。
逻辑或|，无论左边真假，右边都要执行。
短路或||，如果左边为假，右边执行；如果左边为真，右边不执行

最常用的逻辑运算符：&&、||、!

三元运算符

格式：关系表达式?表达式1:表达式2;
范例：a > b ? a : b;

计算规则：
    首先计算关系表达式的值
    如果值为true，表达式1的值就是运算结果
    如果值为false，表达式2的值就是运算结果

public class OperatorDemo {
	public static void main(String[] args) {
		//定义两个变量
		int a = 10;
		int b = 20;

		//获取两个数值当中的较大值
		int max = a > b ? a : b;
		System.out.println("max: " + max);
	}
}

D:\Java\mycode>javac OperatorDemo.java

D:\Java\mycode>java OperatorDemo
max: 20

案例：两只老虎

public class OperatorDemo {
	public static void main(String[] args) {
		int weight1 = 180;
		int weight2 = 200;

		boolean b = weight1 == weight2 ? true : false;

		System.out.println("b:" + b);
	}
}

D:\Java\mycode>javac OperatorDemo.java

D:\Java\mycode>java OperatorDemo
b:false

案例：三个和尚

public class OperatorDemo {
	public static void main(String[] args) {
		int height1 = 155;
		int height2 = 165;
		int height3 = 210;

		int tempHeight = height1 > height2 ? height1 : height2;
		int maxHeight = tempHeight > height3 ? tempHeight : height3;

		System.out.println("Max Height: " + maxHeight); 
	}
}

D:\Java\mycode>javac OperatorDemo.java

D:\Java\mycode>java OperatorDemo
Max Height: 210

数据输入

导包
```
import java.util.Scanner;
```
创建对象
```
Scanner sc = new Scanner(System.in);
```
sc为变量名
接收数据
```
int i = sc.nextInt();
```

   import java.util.Scanner;
   
   public class ScannerDemo {
   	public static void main(String[] args) {
   		Scanner sc = new Scanner(System.in);
   		int x = sc.nextInt();
   		System.out.println("x: " + x);
   	}
   }

   D:\Java\mycode>javac ScannerDemo.java
   
   D:\Java\mycode>java ScannerDemo
   77
   x: 77

案例：三个和尚升级版

import java.util.Scanner;

public class ScannerTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		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 + "cm");

	}
}

D:\Java\mycode>javac ScannerTest.java

D:\Java\mycode>java ScannerTest
请输入第一个和尚的身高：
177
请输入第二个和尚的身高：
189
请输入第三个和尚的身高：
176
这三个和尚中身高最高的是：189cm

if…else语句

public class IfDemo {
	public static void main(String[] args) {
		System.out.println("开始");
		int a = 10;
		int b = 20;
		if(a == b) {
			System.out.println("a等于b");
		}
		int c = 10;
		if(a == c) {
			System.out.println("a等于c");
		}
		System.out.println("结束");
	}
}

D:\Java\mycode>javac IfDemo.java

D:\Java\mycode>java IfDemo
开始
a等于c
结束

public class IfDemo {
	public static void main(String[] args) {
		System.out.println("开始");
		int a = 10;
		int b = 20;
		if(a > b) {
			System.out.println("a的值大于b");
		}else {
			System.out.println("a的值不大于b");
		}
		System.out.println("结束");
	}
}

D:\Java\mycode>javac IfDemo.java

D:\Java\mycode>java IfDemo
开始
a的值不大于b
结束

案例：判断奇偶数

import java.util.Scanner;

public class IfTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个数判断奇偶：");
		int number = sc.nextInt();
		if(number % 2 == 0) {
			System.out.println(number + "是偶数");
		}else {
			System.out.println(number + "是奇数");
		}

	}
}

D:\Java\mycode>javac IfTest.java

D:\Java\mycode>java IfTest
请输入一个数判断奇偶：
9
9是奇数

D:\Java\mycode>java IfTest
请输入一个数判断奇偶：
6
6是偶数

if…else…if结构

import java.util.Scanner;

public class IfDemo {
	public static void main(String[] args) {
		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 {
			System.out.println("星期天");
		}
	} 
}

D:\Java\mycode>javac IfDemo.java

D:\Java\mycode>java IfDemo
请输入一个星期数(1-7)：
7
星期天

D:\Java\mycode>java IfDemo
请输入一个星期数(1-7)：
2
星期二

D:\Java\mycode>java IfDemo
请输入一个星期数(1-7)：
5
星期五

案例：考试奖励

import java.util.Scanner;

public class IfTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个分数：");
		int score = sc.nextInt();
		if(score > 100 || score < 0) {
			System.out.println("你输入的分数有误");
		}else if(score >= 95 && score <= 100) {
			System.out.println("山地自行车一辆");
		}else if(score >= 90 && score <= 94) {
			System.out.println("游乐场玩一次");
		}else if(score >= 80 && score <= 89) {
			System.out.println("变形金刚玩具一个");
		}else {
			System.out.println("胖揍一顿");
		}
 	}
}

D:\Java\mycode>javac IfTest.java

D:\Java\mycode>java IfTest
请输入一个分数：
102
你输入的分数有误

D:\Java\mycode>java IfTest
请输入一个分数：
100
山地自行车一辆

D:\Java\mycode>java IfTest
请输入一个分数：
92
游乐场玩一次

D:\Java\mycode>java IfTest
请输入一个分数：
85
变形金刚玩具一个

D:\Java\mycode>java IfTest
请输入一个分数：
67
胖揍一顿

switch语句

switch(表达式) {
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        [break;]
        
}

格式说明：

表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String。
case：后面跟的是要和表达式进行比较的值
break：表示中断，结束的意思，用来结束switch语句
default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

执行流程：

首先计算表达式的值。
依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行过程中，遇到break就会结束。
如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。

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("请输入一个星期数(1-7)：");
		int week = sc.nextInt();

		switch(week) {
		case 1:
			System.out.println("星期一");
			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;
		}
		System.out.println("结束");
	}
}

D:\Java\mycode>javac SwitchDemo.java

D:\Java\mycode>java SwitchDemo
开始
请输入一个星期数(1-7)：
4
星期四
结束

D:\Java\mycode>java SwitchDemo
开始
请输入一个星期数(1-7)：
9
你输入的星期数有误
结束

D:\Java\mycode>java SwitchDemo
开始
请输入一个星期数(1-7)：
2
星期二
结束

案例：春夏秋冬

import java.util.Scanner;

public class SwitchTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入月份(1-12)：");
		int month = sc.nextInt();

		switch(month) {
		case 1:
		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:
			System.out.println("你输入的月份有误");
		}

	}
}

注意事项：在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值得情况下，向下运行，直到遇到break，或者整体switch语句结束

for循环语句

格式：

for(初始化语句;条件判断语句;条件控制语句;) {
    循环体语句;
}

在这里插入图片描述

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

D:\Java\mycode>javac ForDemo.java

D:\Java\mycode>java ForDemo
Hello,World
Hello,World
Hello,World
Hello,World
Hello,World

案例：输出数据

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

D:\Java\mycode>javac ForTest.java

D:\Java\mycode>java ForTest
1
2
3
4
5
--------
5
4
3
2
1

案例：求和

public class ForTest {
	public static void main(String[] args) {
		int sum = 0;
		for(int i=1; i<=5; i++) {
			sum += i;
		}
		System.out.println("1-5之间的数据和是：" + sum);
	}
}

D:\Java\mycode>javac ForTest.java

D:\Java\mycode>java ForTest
1-5之间的数据和是：15

案例：求偶数和

public class ForTest {
	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("1-100之间的偶数和：" + sum);
	}
}

D:\Java\mycode>javac ForTest.java

D:\Java\mycode>java ForTest
1-100之间的偶数和：2550

案例：水仙花数

水仙花数是一个三位数
水仙花数的个位、十位、百位的数字立方和等于原数

public class ForTest {
	public static void main(String[] args) {
		for(int i=100; i<1000; i++) {
			//在计算之前获取三位数中每个位上的值
			int ge = i % 10;
			int shi = i / 10 % 10;
			int bai = i / 10 / 10 % 10;
			//判定条件是将三位中数的每个数值取出来，计算立方和后与原始数字比较是否相等
			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
				//输出满足条件的数字就是水仙花数
				System.out.println(i);
			}
		}
	}
}

D:\Java\mycode>javac ForTest.java

D:\Java\mycode>java ForTest
153
370
371
407

案例：统计

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

D:\Java\mycode>javac ForTest.java

D:\Java\mycode>java ForTest
水仙花数共有4个

While循环语句

初始化语句;
while(条件判断语句) {
    循环体语句;
    条件控制语句;
}

在这里插入图片描述

public class WhileDemo {
	public static void main(String[] args) {
		int i = 1;
		while(i <= 5) {
			System.out.println(i);
			i++;
		}
	}
}

案例：珠穆朗玛峰

public class WhileTest {
	public static void main(String[] args) {
		int count = 0;
		double paper = 0.1;
		int zf = 8844430;
		while(paper <= zf) {
			paper *= 2;
			count++;
		}
		System.out.println("需要折叠： " + count + "次");
	}
}

D:\Java\mycode>javac WhileTest.java

D:\Java\mycode>java WhileTest
需要折叠： 27次

do…while语句

初始化语句;
do {
    循环体语句;
    条件控制语句;
}while(条件判断语句);

public class DoWhileDemo {
	public static void main(String[] args) {
		int i = 1;
		do {
			System.out.println("Hello,World");
			i++;
		}while(i<=5);
	}
}

D:\Java\mycode>javac DoWhileDemo.java

D:\Java\mycode>java DoWhileDemo
Hello,World
Hello,World
Hello,World
Hello,World
Hello,World

跳转控制语句

continue：用于在循环中，基于条件控制，跳过某次循环内容的执行，继续下一次的执行
break：用于在循环中，基于条件控制，终止循环内容的执行，也就是说结束当前整个循环

循环嵌套

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 + "分");
			}
			System.out.println("-------");
		}
	}
}

随机数Random

导包
```
import java.util.Random
```
创建对象
```
Random r = new Random();
```
r是变量名

获取随机数

int number = r.nextInt();//获取数据的范围：[0,10)，包括0，不包括10

import java.util.Random;

public class RandomDemo {
	public static void main(String[] args) {
		Random r = new Random();
		for(int i=0; i<10; i++) {
			int number = r.nextInt(10);
			System.out.println("number: " + number);
		}

		//获取一个1-100之间的随机数
		int x = r.nextInt(100) + 1;
		System.out.println("1~100之间的随机数：" + x);
	}
}

D:\Java\mycode>javac RandomDemo.java

D:\Java\mycode>java RandomDemo
number: 7
number: 6
number: 8
number: 1
number: 9
number: 9
number: 1
number: 7
number: 4
number: 5
1~100之间的随机数：61

案例：猜数字

import java.util.Scanner;
import java.util.Random;

public class RandomTest {
	public static void main(String[] args) {
		Random r = new Random();
		Scanner sc = new Scanner(System.in);
		System.out.println("《猜数字游戏》");
		int number = r.nextInt(100) + 1;
		while(true) {
			System.out.println("请输入你猜的数字(1~100)：");
			int guessNumber = sc.nextInt();
			if(number > guessNumber) {
				System.out.println("你猜的数字小了");
			}else if(number < guessNumber) {
				System.out.println("你猜的数字大了");
			}else {
				System.out.println("恭喜你猜对了！");
				break;
			}
		}
	}
}

D:\Java\mycode>javac RandomTest.java

D:\Java\mycode>java RandomTest
《猜数字游戏》
请输入你猜的数字(1~100)：
50
你猜的数字小了
请输入你猜的数字(1~100)：
75
你猜的数字小了
请输入你猜的数字(1~100)：
83
你猜的数字大了
请输入你猜的数字(1~100)：
80
你猜的数字大了
请输入你猜的数字(1~100)：
77
你猜的数字大了
请输入你猜的数字(1~100)：
76
恭喜你猜对了！

末初mochu7

关注

13
点赞
踩
64
收藏
打赏
2
评论
黑马程序员Java教程学习笔记（一）

文章目录黑马程序员Java学习笔记Java版本Java语言的跨平台原理JRE和JDKJDK的下载和安装HelloWorld案例注释关键字常量数据类型标识符类型转换运算符字符"+"操作字符串"+"操作复制运算符自增自减运算符关系运算符逻辑运算符三元运算符两只老虎三个和尚黑马程序员Java学习笔记Java版本Java(5.0)：是更新力度很大的一个版本，直接让Java的发展进入了快车道Java(8.0)：是公司中生产/开发环境使用的最多的版本Java(11.0)：是Java学习者使用的最
复制链接

扫一扫