2. java基础

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);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2.注释、关键字

注释：单行注释、多行注释、文档注释

// 这是单行注释文字

/*
这是多行注释文字
*/

/**
这是多行注释文字
*/
1
2
3
4
5
6
7
8
9

关键字:被java赋予了特定涵义的英文单词

3.字面量

作用：告诉程序员，数据在程序中的书写格式。

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("欢迎来到黑马程序员"); // 输出字符串
    }
}
1
2
3
4
5
6
7
8
9

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

标识符

业内大多数程序员都在遵守阿里巴巴的命名规则。

必须要这么做，否则代码会报错。

• 必须由数字、字母、下划线_、美元符号$组成。
• 数字不能开头
• 不能是关键字
• 区分大小写的

小驼峰命名法：适用于变量名和方法名

• 如果是一个单词，那么全部小写，比如：name
• 如果是多个单词，那么从第二个单词开始，首字母大写，比如：firstName、maxAge

大驼峰命名法：适用于类名

• 如果是一个单词，那么首字母大写。比如：Demo、Test。
• 如果是多个单词，那么每一个单词首字母都需要大写。比如：HelloWorld

不管起什么名字，都要做到见名知意。

阿里巴巴命名规范细节：

1. 尽量不要用拼音。但是一些国际通用的拼音可视为英文单词。

   正确：alibaba、hangzhou、nanjing

   错误：jiage、dazhe

2. 平时在给变量名、方法名、类名起名字的时候，不要使用下划线或美元符号。

   错误：_name

   正确：name

5.数据类型

Java语言数据类型的分类

• 基本数据类型
• 引用数据类型（面向对象的时候再深入学习）

基本数据类型的四类八种

说明

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

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

6.运算符

6.1 算术运算符

+ - * / %
+=、-=、*=、/=、%=    
=   赋值运算符
++  自增运算符
--  自减运算符
1
2
3
4
5

%：取模、取余。
/：
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
1
2
3
4
5
6
7
8
9
10
11
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
    }
}
1
2
3
4
5
6
7
8
9

6.3 字符串的+操作和字符的+操作

字符串的+操作

• 当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
• 当连续进行+操作时，从左到右逐个执行的。

System.out.println(1 + "abc" + 1); //1abc1

1
2

字符的+操作

• 当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。

char c = 'a';
int result = c + 0;
System.out.println(result);//97

1
2
3
4

6.4 关系运算符

注意点：

• 关系运算符最终的结果一定是布尔类型的。要么是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);//注意点：取反最多只用一个。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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("其他");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

7.3 循环结构

(1) for循环结构

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

for (int i = 1; i <= 5; i++) {
    System.out.println("HelloWorld");
}

1
2
3
4
5
6
7
8

(2)while循环

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

int i = 1;
while(i <= 5){
    System.out.println("HelloWorld");
    i++;
}
System.out.println(i);

1
2
3
4
5
6
7
8
9
10
11
12
13

(3)do…while循环

特点：先执行，再判断。

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

1
2
3
4
5
6

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 + "个包子");
}

1
2
3
4
5
6
7
8
9
10

8.生成随机数： Random

使用步骤：

1. 导包

import java.util.Random;
导包的动作必须出现在类定义的上边。

1
2
3

2. 创建对象

Random r = new Random ();
上面这个格式里面，只有r是变量名，可以变，其他的都不允许变。

1
2
3

3. 生成随机数

int number = r.nextInt(随机数的范围);
上面这个格式里面，只有number是变量名，可以变，其他的都不允许变。
随机数范围的特点：从0开始，不包含指定值。比如：参数为10，生成的范围[0,10)

1
2
3
4

代码示例：

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

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

9.数组

详解：

数据类型：限定了数组以后能存什么类型的数据。

方括号：表示现在定义的是一个数组。

数组名：就是一个名字而已，方便以后使用。

注意点：

​ 方法括号跟数组名，谁写在前面，谁写在后面都是一样的。

​ 平时习惯性使用第一种方式。

//格式一：  数据类型 [] 数组名
int [] array

//格式二：数据类型  数组名 []
 int array []

1
2
3
4
5
6

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

1
2
3
4
5
6
7
8
9
10
11

数据类型：限定了数组以后能存什么类型的数据。前面和后面的数据类型一定要保持一致。

​ 方括号：表示现在定义的是一个数组。

​ 数组名：其实就是名字而已，方便以后使用，在起名字的时候遵循小驼峰命名法。

​ **大括号：**表示数组里面的元素。元素也就是存入到数组中的数据。

​ 多个元素之间，一定要用逗号隔开。

注意点：

• 等号前后的数据类型必须保持一致。
• 数组一旦创建之后，长度不能发生变化。

(2）动态初始化

数据类型[] 数组名 = new 数据类型[数组的长度];

//1.定义一个数组，存3个人的年龄，年龄未知
int[] agesArr = new int[3];

//2.定义一个数组，存班级10名学生的考试成绩，考试成绩暂时未知，考完才知道。
int[] scoresArr = new int[10];

1
2
3
4
5
6

数组的默认初始化值：

整数类型：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]);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

9.3 数组的遍历

遍历：就是把数组里面所有的内容一个一个全部取出来。

数组的长度：数组名.length;

for(int i = 0; i < arr.length; i++){
    //在循环的过程中，i依次表示数组中的每一个索引
    sout(arr[i]);//就可以把数组里面的每一个元素都获取出来，并打印在控制台上了。
}

1
2
3
4
5

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

带参数方法定义和调用

public static void 方法名 (参数1) {
	方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}

//调用格式：
方法名(参数)；

方法名(参数1,参数2);


1
2
3
4
5
6
7
8
9
10
11
12
13
14

带返回值方法的定义和调用

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

10.2 方法的注意事项

• 方法不能嵌套定义

  • 示例代码：

    public class MethodDemo {
        public static void main(String[] args) {
    
        }
    
        public static void methodOne() {
    		public static void methodTwo() {
           		// 这里会引发编译错误!!!
        	}
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

• void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

  • 示例代码：

    public class MethodDemo {
        public static void main(String[] args) {
    
        }
        public static void methodTwo() {
            //return 100; 编译错误，因为没有具体返回值类型
            return;	
            //System.out.println(100); return语句后面不能跟数据或代码
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

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) {
    	//方法体
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 错误范例

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方法*/
        //方法体
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20