测试开发之java语法基础篇

布满荆棘的人生 2023-09-25 12:43 44阅读 0赞

#### java基础语法 ####

*   *  java基础
     *   *  1.1 注释
         *  1.2 关键字
         *  1.3 常量
         *  1.4 数据类型
     *  变量
     *   *  2.1 变量的定义
         *  2.2 标识符
         *  2.3 类型转换
     *  运算符
     *   *  3.1 算术运算符
         *  3.2 赋值运算符
         *  3.3 自增自减运算符
         *  3.4 关系运算符
         *  3.5 逻辑运算符
         *  3 4.6 三元运算符
     *  Random
     *  数组
     *   *  4.1 数组动态初始化
         *  4.2 数组元素访问
         *  4.3 数组静态初始化
         *  4.4 数组遍历
         *  4.5 数组最值
     *  方法
     *   *  5.1 无参数方法定义和调用
         *   *  5.1.1 方法调用过程图解
         *  5.2 带参数方法定义和调用
         *   *  5.2.1 形参和实参
             *  5.2.2 带返回值方法定义和调用
         *  5.3 方法重载
         *  5.4 方法的参数传递
         *   *  5.4.1 方法参数传递基本类型
             *  5.4.2 方法参数传递引用类型，

### java基础 ###

#### 1.1 注释 ####

注释是对代码的解释和说明文字，可以提高程序的可读性，因此在程序中添加必要的注释文字十分重要。Java中的 注释分为三种:  
`单行注释`。单行注释的格式是使用//，从//开始至本行结尾的文字将作为注释文字。

// 这是单行注释文字

`多行注释`。多行注释的格式是使用/\* 和 \*/将一段较长的注释括起来。多行注释不能嵌套使用

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

#### 1.2 关键字 ####

关键字的特点:关键字的字母全部小写。  
常用的代码编辑器对关键字都有高亮显示，比如现在我们能看到的`public`、`class`、`static`等。

#### 1.3 常量 ####

`常量`:在程序运行过程中，其值不可以发生改变的量。  
`字符串常量` 用双引号括起来的多个字符(可以包含0个、一个或多个)，例如"a"、“abc”、"中国"等  
`整数常量` 整数，例如:-10、0、88等  
`小数常量` 小数，例如:-5.5、1.0、88.88等  
`字符常量` 用单引号括起来的一个字符，例如:‘a’、‘5’、‘B’、'中’等  
`布尔常量` 布尔值，表示真假，只有两个值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("欢迎来到黑马程序员"); // 输出字符串
        }
    }

#### 1.4 数据类型 ####

Java中的数据必须明确数据类型，Java中的数据类型包括基本数据类型和引用数据类型两种。  
![在这里插入图片描述][c4a7f0e613594710909272167f4929ae.png]

### 变量 ###

#### 2.1 变量的定义 ####

变量:在程序运行过程中，它的值是可以发生改变的量  
变量是最基本的存储单元，要素包括变量名，变量类型和作用域  
变量在使用前都必须声明数据类型，可以是基本数据类型，也可以是引用数据类型

*  局部变量：（方法或语句块内） 从申明变量开始，直到方法或语句块执行完毕，局部变量消失
 *  成员变量（实例变量）在类内部，方法外部 属于对象， 对象创建，成员变量也跟着创建，对象消失，成员变量也跟着消失
 *  静态变量 类内部static修饰，类被加载，静态变量就有效，类被卸载，静态变量就消失

什么时候成员变量声明为实例变量呢？

> 所有对象都有这个属性，且这个属性的值会随对象的变化而变化，不同对象的这个属性的值是不同的

什么时候成员变量声明为静态变量呢？

> 所有对象都有这个属性，且这个属性的值是唯一的就定义为静态变量，节省内存的开销

public class Java变量 {
        
        int studentNum;//成员变量（实例变量）
        static int companyId;//静态变量（类变量）
    
        public static void main(String[] args) {
        
            int a =5;//局部变量
            int b = a +3;
            System.out.println(b);
        }
        int k =200;//成员变量
        public void  doSonme(){
        
            int c =78;//局部变量
        }
    }

#### 2.2 标识符 ####

标识符是用户编程时使用的名字，用于给类、方法、变量、常量等命名。  
Java中标识符的组成规则:  
由字母、数字、下划线“\_”、美元符号“$”组成，第一个字符不能是数字。  
不能使用java中的关键字作为标识符。  
标识符对大小写敏感(区分大小写)。  
Java中标识符的命名约定:  
小驼峰式命名:变量名、方法名  
首字母小写，从第二个单词开始每个单词的首字母大写。  
大驼峰式命名:类名  
每个单词的首字母都大写。  
另外，标识符的命名最好可以做到见名知意  
例如:username、studentNumber等。

#### 2.3 类型转换 ####

在Java中，一些数据类型之间是可以相互转换的。  
分为两种情况:自动类型转换和强制类型转换。  
`自动类型转换`:  
把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可

double num =10;// 将int类型的10直接赋值给double类型
            System.out.println(num);  //输出10.0

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

double num1 = 5.5;
    int num2 = (int) num1; // 将double类型的num1强制转换为int类型
    System.out.println(num2); // 输出5(小数位直接舍弃)

### 运算符 ###

#### 3.1 算术运算符 ####

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

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

`注`：`当“+”操作中出现字符串时，这个”+”是 字符串的“+”操作，而不是算术运算`

#### 3.2 赋值运算符 ####

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量  
![在这里插入图片描述][4971851dec784d599ae5df1067da15cd.png]

#### 3.3 自增自减运算符 ####

\++和-- 既可以放在变量的后边，也可以放在变量的前边。  
如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–。  
如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。

int i = 10;
    i++; // 单独使用 System.out.println("i:" + i); // i:11
    int j = 10;
    ++j; // 单独使用 System.out.println("j:" + j); // j:11
    int x = 10;
    int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
    System.out.println("x:" + x + ", y:" + y); // x:11，y:10
    int m = 10;
    int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
    System.out.println("m:" + m + ", m:" + m); // m:11，m:11

![在这里插入图片描述][98b89ed2fc314784bccad0e4e40d5c49.png]

#### 3.4 关系运算符 ####

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于

int a = 10;
    int b = 20;
    System.out.println(a == b); // false
    System.out.println(a != b); // true
    System.out.println(a > b); // false
    System.out.println(a >= b); // false
    System.out.println(a < b); // true
    System.out.println(a <= b); // true
    // 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量 boolean flag = a > b;
    System.out.println(flag); // 输出false

#### 3.5 逻辑运算符 ####

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

//定义变量
    int i = 10; 
    int j = 20; 
    int k = 30;
    //& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
    System.out.println((i > j) & (i> k)); //false & false,输出false 
    System.out.println((i < j) & (i> k)); //true & false,输出false false 
    System.out.println((i > j) & (i< k)); //false & true,输出
    System.out.println((i < j) & (i< k)); //true & true,输出true
    System.out.println("--------");
    
    //| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
    System.out.println((i > j) | (i> k)); //false | false,输出false 
    System.out.println((i < j) | (i> k)); //true | false,输出true
    System.out.println((i > j) | (i< k)); //false | true,输出true
    System.out.println((i < j) | (i< k)); //true | true,输出true
    System.out.println("--------");
    
    
    //^ “异或”，相同为false，不同为true
    System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
    System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
    System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
    System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
    System.out.println("--------");
    //! “非”，取反
    System.out.println((i > j)); //false
    System.out.println(!(i > j)); //!false,输出true

#### 3 4.6 三元运算符 ####

需求:动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同

public class Test01 {
        
    	public static void main(String[] args) {
        
    		//1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。
    		int weight1 = 180;
    		int weight2 = 200;
    
    		//2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。
    		boolean b = weight1 == weight2 ? true : false;
    
    		//3：输出结果
    		System.out.println("b:" + b);
    	}
    }

### Random ###

Random产生随机数使用步骤：

*  导入包  
    import java.util.Random;
 *  创建对象  
    Random r = new Random();
 *  产生随机数  
    int num = r.nextInt(10);  
    `解释`： `10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19`

import java.util.Random;
    
    public class Demo {
        
    	public static void main(String[] args) {
        
    		//创建对象
    		Random r = new Random();
    
    		//用循环获取10个随机数
    		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(x);
    	}
    }

### 数组 ###

数组定义格式：数据类型\[\] 数组名

int[] arr;        
    double[] arr;      
    char[] arr;

#### 4.1 数组动态初始化 ####

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

等号左边：
    
    int:数组的数据类型
    
    []:代表这是一个数组
    
    arr:代表数组的名称
    
    等号右边：
    
    new:为数组开辟内存空间
    
    int:数组的数据类型
    
    []:代表这是一个数组
    
    3:代表数组的长度

#### 4.2 数组元素访问 ####

访问数组元素格式：数组名\[索引\];

public class Demo {
        
        public static void main(String[] args) {
        
            int[] arr = new int[3];
    
            //输出数组名
            System.out.println(arr); //[I@880ec60
    
            //输出数组中的元素
            System.out.println(arr[0]);
            System.out.println(arr[1]);
            System.out.println(arr[2]);
        }
    }

#### 4.3 数组静态初始化 ####

*  完整版格式：  
    数据类型\[\] 数组名 = new 数据类型\[\]\{元素1,元素2,…\};
 *  简化版格式：  
    数据类型\[\] 数组名 = \{元素1,元素2,…\};

public class Demo {
        
        public static void main(String[] args) {
        
            //定义数组
            int[] arr = {
        1, 2, 3};
    
            //输出数组名
            System.out.println(arr);
    
            //输出数组中的元素
            System.out.println(arr[0]);
            System.out.println(arr[1]);
            System.out.println(arr[2]);
        }
    }

#### 4.4 数组遍历 ####

数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。  
以下代码是可以将数组中每个元素全部遍历出来，但如果数组元素非常多，这种写法肯定不行，

public class ArrayTest {
        
    	public static void main(String[] args) {
        
    		int[] arr = {
         1, 2, 3, 4, 5 };
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		System.out.println(arr[3]);
    		System.out.println(arr[4]);
    	}
    }

因此我们需要改造成循环的写法。数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现

public class ArrayTest {
        
        public static void main(String[] args) {
        
            //定义数组
            int[] arr = {
        11, 22, 33, 44, 55};
    
            //使用通用的遍历格式
            for(int x=0; x<arr.length; x++) {
        
                System.out.println(arr[x]);
            }
        }
    }

#### 4.5 数组最值 ####

*  `最大值获取：从数组的所有元素中找出最大值。`
 *  `实现思路`：
 *  `定义变量，取数组中索引为0的第一个数据作为变量的初始值`
 *  `遍历数组，for循环获取出数组中的每个元素`
 *  `将遍历到的元素和保存数组0索引上值的变量进行比较`
 *  `如果数组元素的值大于变量的值，变量就存取新的值`
 *  `数组循环遍历结束，变量保存的就是数组中的最大值`

public class Array {
        
        public static void main(String[] args) {
        
            //定义数组
            int[] arr = {
        12, 45, 98, 73, 60};
    
            //定义一个变量，用于保存最大值
            //取数组中第一个数据作为变量的初始值
            int max = arr[0];
    
            //与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
            for(int x=1; x<arr.length; x++) {
        
                if(arr[x] > max) {
        
                    max = arr[x];
                }
            }
    
            //循环结束后打印变量的值
            System.out.println("max:" + max);
    
        }
    }

### 方法 ###

#### 5.1 无参数方法定义和调用 ####

定义格式：

public static void 方法名 (   ) {
        
    	// 方法体;
    }

调用格式：

方法名();

##### 5.1.1 方法调用过程图解 #####

总结：每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失  
![在这里插入图片描述][c6c9fcb137194005aed6ff5b26783a28.png]

#### 5.2 带参数方法定义和调用 ####

定义格式：参数：由数据类型和变量名组成 - 数据类型 变量名

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

调用格式：

isEvenNumber(10);
    
    getMax(10,20);

##### 5.2.1 形参和实参 #####

> 形参：方法定义中的参数 等同于变量定义格式，例如：int number  
> 实参：方法调用中的参数 等同于使用变量或常量，例如： 10number

需求：设计一个方法用于打印两个数中的较大数，数据来自于方法参数

public class Test {
        
        public static void main(String[] args) {
        
            //在main()方法中调用定义好的方法（使用常量）
            getMax(10,20);
            //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的
            //getMax(30);
            //getMax(10.0,20.0);
    
            //在main()方法中调用定义好的方法（使用变量）
            int a = 10;
            int b = 20;
            getMax(a, b);
        }
    
        //定义一个方法，用于打印两个数字中的较大数，例如getMax()
        //为方法定义两个参数，用于接收两个数字
        public static void getMax(int a, int b) {
        
            //使用分支语句分两种情况对两个数字的大小关系进行处理
            if(a > b) {
        
                System.out.println(a);
            } else {
        
                System.out.println(b);
            }
        }
    }

##### 5.2.2 带返回值方法定义和调用 #####

方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

public static 数据类型 方法名 ( 参数 ) {
         
    	return 数据 ;
    }
    public static boolean isEvenNumber( int number ) {
                   
    	return true ;
    }
    public static int getMax( int a, int b ) {
        
    	return  100 ;
    }

需求：设计一个方法可以获取两个数的较大值，数据来自于参数

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

#### 5.3 方法重载 ####

多个方法在同一个类中  
多个方法具有相同的方法名  
多个方法的参数不相同，类型不同或者数量不同  
重载仅对应方法的定义，与方法的调用无关，与返回值无关

public class MethodDemo {
        
    	public static void fn(int a) {
        
        	//方法体
        }
        public static int fn(double a) {
        
        	//方法体
        }
    }
    
    public class MethodDemo {
        
    	public static float fn(int a) {
        
        	//方法体
        }
        public static int fn(int a , int b) {
        
        	//方法体
        }
    }

#### 5.4 方法的参数传递 ####

##### 5.4.1 方法参数传递基本类型 #####

基本数据类型的参数，形式参数的改变，不影响实际参数

public class Demo {
        
        public static void main(String[] args) {
        
            int number = 100;
            System.out.println("调用change方法前：" + number);
            change(number);
            System.out.println("调用change方法后：" + number);
        }
    
        public static void change(int number) {
        
            number = 200;
        }
    }

##### 5.4.2 方法参数传递引用类型， #####

对于引用类型的参数，形式参数的改变，影响实际参数的值，引用数据类型的传参，传入的是地址值

public class ArgsDemo02 {
        
        public static void main(String[] args) {
        
            int[] arr = {
        10, 20, 30};
            System.out.println("调用change方法前：" + arr[1]);
            change(arr);
            System.out.println("调用change方法后：" + arr[1]);
        }
    
        public static void change(int[] arr) {
        
            arr[1] = 200;
        }
    }

[c4a7f0e613594710909272167f4929ae.png]: https://img-blog.csdnimg.cn/c4a7f0e613594710909272167f4929ae.png
[4971851dec784d599ae5df1067da15cd.png]: https://img-blog.csdnimg.cn/4971851dec784d599ae5df1067da15cd.png
[98b89ed2fc314784bccad0e4e40d5c49.png]: https://img-blog.csdnimg.cn/98b89ed2fc314784bccad0e4e40d5c49.png
[c6c9fcb137194005aed6ff5b26783a28.png]: https://img-blog.csdnimg.cn/c6c9fcb137194005aed6ff5b26783a28.png