2. java基础
1.输入、输出
代码示例：
//导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{
public static void main(String[] args){
//2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。
Scanner sc = new Scanner(System.in);
//3.接收数据
//当程序运行之后，我们在键盘输入的数据就会被变量i给接收了
System.out.println("请输入一个数字");
int i = sc.nextInt();
System.out.println(i);
}
}
2.注释、关键字
注释：单行注释、多行注释、文档注释
// 这是单行注释文字
/*
这是多行注释文字
*/
/**
这是多行注释文字
*/
关键字:被java赋予了特定涵义的英文单词
3.字面量
作用：告诉程序员，数据在程序中的书写格式。
| 字面量类型 | 说明 | 程序中的写法 |
|---|---|---|
| 整数 | 不带小数的数字 | 666，-88 |
| 小数 | 带小数的数字 | 13.14，-5.21 |
| 字符 | 必须使用单引号，有且仅能一个字符 | ‘A’，‘0’， ‘我’ |
| 字符串 | 必须使用双引号，内容可有可无 | “HelloWorld”，“黑马程序员” |
| 布尔值 | 布尔值，表示真假，只有两个值：true，false | true 、false |
| 空值 | 一个特殊的值，空值 | 值是：null |
public class Demo {
public static void main(String[] args) {
System.out.println(10); // 输出一个整数
System.out.println(5.5); // 输出一个小数
System.out.println('a'); // 输出一个字符
System.out.println(true); // 输出boolean值true
System.out.println("欢迎来到黑马程序员"); // 输出字符串
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AimmHAGZ-1665299988828)(file:///C:\Users\xiaoxiao\AppData\Roaming\Tencent\Users\943234357\QQ\WinTemp\RichOle%B}Z1%`R6U~X7VX%Y}98QJT.png)]
4.变量
变量的定义格式：数据类型 变量名 = 数据值；
举例：
public class VariableDemo{
public static void main(String[] args){
//定义一个整数类型的变量
//数据类型 变量名 = 数据值;
int a = 16;
System.out.println(a);//16
int a = 10, b = 20, c = 20,d = 20;
//定义一个小数类型的变量
double b = 10.1;
System.out.println(b);//10.1
}
}
标识符
业内大多数程序员都在遵守阿里巴巴的命名规则。
必须要这么做，否则代码会报错。
- 必须由数字、字母、下划线_、美元符号$组成。
- 数字不能开头
- 不能是关键字
- 区分大小写的
小驼峰命名法：适用于变量名和方法名
- 如果是一个单词，那么全部小写，比如：name
- 如果是多个单词，那么从第二个单词开始，首字母大写，比如：firstName、maxAge
大驼峰命名法：适用于类名
- 如果是一个单词，那么首字母大写。比如：Demo、Test。
- 如果是多个单词，那么每一个单词首字母都需要大写。比如：HelloWorld
不管起什么名字，都要做到见名知意。
阿里巴巴命名规范细节：
-
尽量不要用拼音。但是一些国际通用的拼音可视为英文单词。
正确：alibaba、hangzhou、nanjing
错误：jiage、dazhe
-
平时在给变量名、方法名、类名起名字的时候，不要使用下划线或美元符号。
错误：_name
正确：name
5.数据类型
Java语言数据类型的分类
- 基本数据类型
- 引用数据类型（面向对象的时候再深入学习）
基本数据类型的四类八种
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 整数 | byte | 1 | 负的2的7次方 ~ 2的7次方-1(-128~127) |
| short | 2 | 负的2的15次方 ~ 2的15次方-1(-32768~32767) | |
| int | 4 | 负的2的31次方 ~ 2的31次方-1 | |
| long | 8 | 负的2的63次方 ~ 2的63次方-1 | |
| 浮点数 | float | 4 | 1.401298e-45 ~ 3.402823e+38 |
| double | 8 | 4.9000000e-324 ~ 1.797693e+308 | |
| 字符 | char | 2 | 0-65535 |
| 布尔 | boolean | 1 | true，false |
说明
e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。
在java中整数默认是int类型，浮点数默认是double类型。
注意点
- 如果要定义 一个整数类型的变量，不知道选择哪种数据类型了，默认使用int。
- 如果要定义 一个小数类型的变量，不知道选择哪种数据类型了，默认使用double。
- 如果要定义一个long类型的变量，那么在数据值的后面需要加上L后缀。（大小写都可以，建议大写。）
- 如果要定义一个float类型的变量，那么在数据值的后面需要加上F后缀。（大小写都可以）
public class VariableDemo3{
public static void main(String[] args){
//1.定义字符串类型的变量记录老师的姓名
String name = "黑马谢广坤";
//3.定义int类型的变量
int c = 30;
System.out.println(c);
//4.定义long类型的变量
long d = 123456789123456789L;
System.out.println(d);
//5.定义float类型的变量
float e = 10.1F;
System.out.println(e);
//6.定义double类型的变量
double f = 20.3;
System.out.println(f);
//7.定义char类型的变量
char g = 'a';
System.out.println(g);
//8.定义boolean类型的变量
boolean h = true;
System.out.println(h);
}
}
6.运算符
6.1 算术运算符
+ - * / %
+=、-=、*=、/=、%=
= 赋值运算符
++ 自增运算符
-- 自减运算符
%：取模、取余。
/：
1.整数相除结果只能得到整除，如果结果想要是小数，必须要有小数参数。
2.小数直接参与运算，得到的结果有可能是不精确的。
案例：
System.out.println( 10 / 3);//3
System.out.println(10.0 / 3);//3.3333333333333335
int a=10;
System.out.println(++a);//11
System.out.println(a++);//11
System.out.println(a++); //12
6.2 强制转换
书写格式： 目标数据类型 变量名 = （目标数据类型）被强转的数据；
public class OperatorDemo2 {
public static void main(String[] args) {
double a = 12.3;
int b = (int) a;
System.out.println(b);//12
}
}
6.3 字符串的+操作和字符的+操作
字符串的+操作
- 当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
- 当连续进行+操作时，从左到右逐个执行的。
System.out.println(1 + "abc" + 1); //1abc1
字符的+操作
- 当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。
char c = 'a';
int result = c + 0;
System.out.println(result);//97
6.4 关系运算符
| 符号 | 解释 |
|---|---|
| == | 就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false |
| != | 就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false |
| > | 就是判断左边是否大于右边，如果成立就是true，如果不成立就是false |
| >= | 就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false |
| < | 就是判断左边是否小于右边，如果成立就是true，如果不成立就是false |
| <= | 就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false |
注意点：
- 关系运算符最终的结果一定是布尔类型的。要么是true，要么是false
- 在写==的时候，千万不要写成=
6.5 逻辑运算符
最为常用： && || ！
&：逻辑与（而且）
两边都为真，结果才是真，只要有一个为假，那么结果就是假。
|：逻辑或（或者）
两边都为假，结果才是假，只要有一个为真，那么结果就是真。
^（异或）的使用：在以后用的不多，了解一下即可。
计算规则：如果两边相同，结果为false，如果两边不同，结果为true
!（取反）的使用：是取反，也叫做非。
计算规则：false取反就是true，true取反就是false
短路逻辑运算符
&&：运算结果跟&是一模一样的，只不过具有短路效果。
||：运算结果跟|是一模一样的。只不过具有短路效果。
当左边不能确定整个表达式的结果，右边才会执行。
当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。
// & //两边都是真，结果才是真。
System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false
System.out.println("===================================");
// | 或 //两边都是假，结果才是假，如果有一个为真，那么结果就是真。
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true
//^ //左右不相同，结果才是true，左右相同结果就是false
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
//!取反
System.out.println(!false);//true
System.out.println(!true);//false
System.out.println(!!false);//注意点：取反最多只用一个。
6.6 三元运算符
**格式：**关系表达式 ？ 表达式1 ：表达式2 ；
计算规则：
- 计算关系表达式的值。
- 如果关系表达式的值为真，那么执行表达式1。
- 如果关系表达式的值为假，那么执行表达式2。
注意点：
三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来。
public class OperatorDemo12 {
public static void main(String[] args) {
//需求：求两个数的较大值
int a = 10;
int b = 20;
//格式：关系表达式 ？ 表达式1 ： 表达式2 ；
//注意点：
//三元运算符的最终结果一定要被使用。
//要么赋值给一个变量，要么直接输出。
int max = a > b ? a : b ;
System.out.println(max);//20
}
}
7.函数结构
顺序结构
判断和选择结构(if, switch)
循环结构(for, while, do…while)
7.1 判断语句：if语句
//格式：1
if (关系表达式) {
语句体;
}
//格式：2
if (关系表达式) {
语句体1;
} else {
语句体2;
}
//格式：3
if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
7.2 switch语句
switch (表达式) {
case 1:
语句体1;
break;
case 2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
//switch在JDK12的新特性
int number = 10;
switch (number) {
case 1 -> System.out.println("一");
case 2 -> System.out.println("二");
case 3 -> System.out.println("三");
default -> System.out.println("其他");
}
- 首先计算出表达式的值
- 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
- 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
7.3 循环结构
(1) for循环结构
for (初始化语句; 条件判断语句; 条件控制语句) {
循环体语句;
}
for (int i = 1; i <= 5; i++) {
System.out.println("HelloWorld");
}
(2)while循环
初始化语句;
while(条件判断语句){
循环体;
条件控制语句;
}
int i = 1;
while(i <= 5){
System.out.println("HelloWorld");
i++;
}
System.out.println(i);
(3)do…while循环
特点：先执行，再判断。
初始化语句;
do{
循环体;
条件控制语句;
}while(条件判断语句);
7.4 条件控制语句
break:不能单独存在的。可以用在switch和循环中，表示结束，跳出的意思。
continue:不能单独存在的。只能存在于循环当中。表示：跳过本次循环，继续执行下次循环。
//1.吃1~5号包子
for (int i = 1; i <= 5; i++) {
//2.第3个包子有虫子就跳过，继续吃下面的包子
if(i == 3){
//跳过本次循环（本次循环中，下面的代码就不执行了），继续执行下次循环。
continue;
}
System.out.println("在吃第" + i + "个包子");
}
8.生成随机数： Random
使用步骤：
- 导包
import java.util.Random;
导包的动作必须出现在类定义的上边。
- 创建对象
Random r = new Random ();
上面这个格式里面，只有r是变量名，可以变，其他的都不允许变。
- 生成随机数
int number = r.nextInt(随机数的范围);
上面这个格式里面，只有number是变量名，可以变，其他的都不允许变。
随机数范围的特点：从0开始，不包含指定值。比如：参数为10，生成的范围[0,10)
代码示例：
//1.导包
import java.util.Random;
public class RandomDemo1 {
public static void main(String[] args) {
//2.创建对象
Random r = new Random();
//3.生成随机数
int number = r.nextInt(100);//包左不包右，包头不包尾
//0 ~ 99
System.out.println(number);
}
}
9.数组
详解：
数据类型：限定了数组以后能存什么类型的数据。
方括号：表示现在定义的是一个数组。
数组名：就是一个名字而已，方便以后使用。
注意点：
方法括号跟数组名，谁写在前面，谁写在后面都是一样的。
平时习惯性使用第一种方式。
//格式一： 数据类型 [] 数组名
int [] array
//格式二：数据类型 数组名 []
int array []
9.1数组的两种初始化方式
(1)静态初始化
// 数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4...};
int[] arr = new int[]{11,22,33};
double[] arr = new double[]{1.1,1.2,1.3};
//简化格式
//数据类型[] 数组名 = {元素1，元素2，元素3，元素4...};
int[] array = {1,2,3,4,5};
double[] array = {1.1,1.2,1.3};
String[] namesArr = {"zhangsan","lisi","wangwu"};
数据类型：限定了数组以后能存什么类型的数据。前面和后面的数据类型一定要保持一致。
方括号：表示现在定义的是一个数组。
数组名：其实就是名字而已，方便以后使用，在起名字的时候遵循小驼峰命名法。
**大括号：**表示数组里面的元素。元素也就是存入到数组中的数据。
多个元素之间，一定要用逗号隔开。
注意点：
- 等号前后的数据类型必须保持一致。
- 数组一旦创建之后，长度不能发生变化。
(2）动态初始化
数据类型[] 数组名 = new 数据类型[数组的长度];
//1.定义一个数组，存3个人的年龄，年龄未知
int[] agesArr = new int[3];
//2.定义一个数组，存班级10名学生的考试成绩，考试成绩暂时未知，考完才知道。
int[] scoresArr = new int[10];
数组的默认初始化值：
整数类型：0
小数类型：0.0
布尔类型：false
字符类型：‘\u0000’
引用类型：null
(3)区别
静态初始化：int[] arr = {1,2,3,4,5};
动态初始化：int[] arr = new int[3];
静态初始化：手动指定数组的元素，系统会根据元素的个数，计算出数组的长度。
动态初始化：手动指定数组长度，由系统给出默认初始化值。
9.2 数组元素访问、索引
索引的特点：
- 索引一定是从0开始的。
- 连续不间断。
- 逐个+1增长。
public class ArrDemo2 {
/*
数组中元素访问的格式：数组名[索引];
作用：
1.获取指定索引上对应的元素
2.修改指定索引上对应的元素
*/
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
//需求1：获取arr数组中，3索引上的值
int number = arr[3];
System.out.println(number);
System.out.println(arr[3]);
//需求2：将arr数组中，3索引上的值修改为10
arr[3] = 10;
System.out.println("修改之后为:" + arr[3]);
}
}
9.3 数组的遍历
遍历：就是把数组里面所有的内容一个一个全部取出来。
数组的长度：数组名.length;
for(int i = 0; i < arr.length; i++){
//在循环的过程中，i依次表示数组中的每一个索引
sout(arr[i]);//就可以把数组里面的每一个元素都获取出来，并打印在控制台上了。
}
10.方法
方法（method）是程序中最小的执行单元
- 注意：
- 方法必须先创建才可以使用，该过程成为方法定义
- 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用
10.1 方法的定义和调用
无参数方法定义和调用
public static void 方法名 ( ) {
// 方法体;
}
//调用格式：
方法名();
//例子
public class MethodTest {
public static void main(String[] args) {
//在main()方法中调用定义好的方法
getMax();
}
public static void getMax() {
//定义一个方法，用于打印两个数字中的较大数，例如getMax()
//方法中定义两个变量，用于保存两个数字
int a = 10;
int b = 20;
//使用分支语句分两种情况对两个数字的大小关系进行处理
if(a > b) {
System.out.println(a);
} else {
System.out.println(b);
}
}
}
带参数方法定义和调用
public static void 方法名 (参数1) {
方法体;
}
public static void 方法名 (参数1, 参数2, 参数3...) {
方法体;
}
//调用格式：
方法名(参数)；
方法名(参数1,参数2);
带返回值方法的定义和调用
public static 数据类型 方法名 ( 参数 ) {
return 数据 ;
}
方法名 ( 参数 ) ;
数据类型 变量名 = 方法名 ( 参数 ) ;
public static boolean isEvenNumber( int number ) {
return true ;
}
public static int getMax( int a, int b ) {
return 100 ;
}
isEvenNumber ( 5 ) ;
boolean flag = isEvenNumber ( 5 );
public class MethodTest {
public static void main(String[] args) {
//在main()方法中调用定义好的方法并使用变量保存
int result = getMax(10,20);
System.out.println(result);
//在main()方法中调用定义好的方法并直接打印结果
System.out.println(getMax(10,20));
}
//定义一个方法，用于获取两个数字中的较大数
public static int getMax(int a, int b) {
//使用分支语句分两种情况对两个数字的大小关系进行处理
//根据题设分别设置两种情况下对应的返回结果
if(a > b) {
return a;
} else {
return b;
}
}
}
10.2 方法的注意事项
-
方法不能嵌套定义
-
示例代码：
public class MethodDemo { public static void main(String[] args) { } public static void methodOne() { public static void methodTwo() { // 这里会引发编译错误!!! } } }
-
-
void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
-
示例代码：
public class MethodDemo { public static void main(String[] args) { } public static void methodTwo() { //return 100; 编译错误，因为没有具体返回值类型 return; //System.out.println(100); return语句后面不能跟数据或代码 } }
-
10.3 方法重载
-
在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能。
-
每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系
-
简单记:同一个类中，方法名相同，参数不同的方法。与返回值无关。
参数不同:个数不同、类型不同、顺序不同 -
正确范例：
public class MethodDemo {
public static float fn(int a) {
//方法体
}
public static int fn(int a , int b) {
//方法体
}
}
public class MethodDemo {
public static void fn(int a) {
//方法体
}
public static int fn(double a) {
//方法体
}
}
- 错误范例
public class MethodDemo {
public static void fn(int a) {
//方法体
}
public static int fn(int a) { /*错误原因：重载与返回值无关*/
//方法体
}
}
public class MethodDemo01 {
public static void fn(int a) {
//方法体
}
}
public class MethodDemo02 {
public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/
//方法体
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
