标识符、关键字、数据类型

Java知识点总结：想看的可以从这里进入

2.2 标识符、关键字

2.2.1 关键字

	分类	关键字	含义
1	基本数据类型	boolean	布尔型
2		byte	字节型
3		int	整型
4		short	短整型
5		long	长整型
6		char	字符
7		float	浮点型
8		double	双精度
9	空的	null	空
10	布尔值	true	真
11		false	假
12	访问控制，权限	private	私有的
13		public	公共的
14		protected	受保护的
15	程序控制	break	直接终止整个循环
16		continue	跳出当前循环进入下次循环
17		return	方法结束，并返回一个值
18		do	运行，循环体至少执行一次。
19		while	while循环
23		if	如果
20		else	否则
21		for	for循环
22		instanceof	确定对象所属的类。
23		switch	switch语句
24		case	标记 switch 语句中的每个分支
25		default	用来标记 switch 语句中的默认分支
26	类、方法和变量修饰符	abstract	声明抽象类
27		class	声明一个类
28		extends	类的继承
29		final	最终、不可改变
30		implements	实现接口
31		interface	声明接口
32		native	本地
33		new	创建对象
34		static	静态
35		strictfp	严格,精准
36		synchronized	线程、同步
37		transient	短暂
38		volatile	可以被多个线程异步修改的成员变量、
39	异常	try	捕获异常
40		catch	异常的的处理
41		finally	和try、catch一起使用不管是否异常都会执行
42		throw	抛出一个异常对象
43		throws	声明可能被抛出的异常
44	包相关	import	导入
45		package	包
46	变量引用	super	父类,超类
47		this	引用当前实例
48		void	无返回值
49	保留字	goto	跳转 不做使用，会造成程序结构的混乱
50		const	静态
51		native	本地

2.2.2 标识符

标识符是用来给变量、类、方法、包进行命名的。

​ 标识符通常包含：字母（az、AZ）、数字、、美元符（$）、下划线（_）

命名规范： 通常使用驼峰式命名。每个单词的首字母大写

1、类名：通常使用名词，首字母大写，后续使用驼峰式命名
2、方法名：通常使用动词，首字母小写，后续使用驼峰式命名
3、变量名：首字母小写，后续使用驼峰式命名
4、常量名：全部字母大写

标识符注意事项：

1、标识符必须以字母（a~z、A~Z）、美元符（$）、下划线（_）开头
2、后续字母可以是字母（a~z、A~Z）、美元符（$）、下划线（_）、数字的任意组合
3、不能使用关键字作为标识符
4、严格区分大小写
5、不能有空格键
6、不建议使用中文作为标识符

2.3 数据类型

​ Java是一种强类型语言，要求变量的使用要严格遵循规定，必须先定义后使用

• 强类型语言：如Java，必须明确数据类型，标明是什么类型就是什么类型。

  int a = 1;
  String str = "Java";
  

• 弱类型语言：如Python、JavaScript，不需要明确数据类型，可直接定义，语言解析器会自动进行隐式的转换。

  var a = 1;
  var str = "java";
  

数据类型的分类：

2.3.1 基本数据类型

1、整型

• byte 字节

  1、byte 数据类型是1个字节8位、有符号的，以二进制补码表示的整数；
  2、最小值是 -128（-2^7），最大值是 127（2^7-1）
  3、默认值是 0
  4、byte 类型用在大型数组中节约空间，主要代替整数，byte 变量占用的空间只有 int 类型的四分之一
  

  ​ 定义： byte b = 10;

• short 短整型

  1. short 数据类型是2个字节 16 位、有符号的以二进制补码表示的整数
  2. 最小值是 -32768（-2^15）, 最大值是 **32767（2^15 - 1
  3. 默认值是 0
  

  ​ 定义： short s = 10;

• int 整型

  1. int 数据类型是4个字节32位、有符号的以二进制补码表示的整数
  2. 最小值是 -2,147,483,648（-2^31,最大值是 2,147,483,647（2^31 - 1）
  2. 一般地整型变量默认为 int 类型；
  3. 默认值是 0 
  

  ​ 定义： int i = 10;

• long 长整型

  1、long 数据类型是 8个字节 64 位、有符号的以二进制补码表示的整数；
  2、最小值是 -9,223,372,036,854,775,808（-2^63），最大值是 9,223,372,036,854,775,807（2^63 -1）；
  3、这种类型主要使用在需要比较大整数的系统上；
  4、默认值是 0L
  5、"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。
  

  ​ 定义： long l = 10L;

public class Main {
    		//public公开的 class 是一个类 Main类名
    //main方法，是主方法，执行程序的方法 ，
	//前面必须为 public static void ，static是静态修饰符，void是，返回值类型，为无返回值 
    public static void main(String[] args) {
    		
        byte num1 = 125;	
        short num2 = 3576;
        int num3 = 45456465;
        long num4 = 54564545L;
        System.out.println(num1+num2+num3+num4);
    }
}
输出结果：100024598	

2、浮点型

是有限、离散的，有舍入的误差，结果为约等于，应避免使用浮点数进行比较，银行业务可以用BigDecimal工具类

• float 单精度小数

  1、float 数据类型是单精度、 4个字节 32位、符合 IEEE 754标准的浮点数；
  2、float 在储存大型浮点数组的时候可节省内存空间；
  3、默认值是 0.0f；
  4、浮点数不能用来表示精确的值，如货币；银行业务可以用BigDecimal工具类
  

  ​ 定义： float f = 10.0f

• double 双精度小数

  1、double 数据类型是双精度、 8个字节 64 位、符合IEEE 754标准的浮点数；
  2、浮点数的默认类型为double类型；
  3、double类型同样不能表示精确的值，如货币；
  4、默认值是 0.0d；
  

  ​ 定义： double d = 10.0d

3、char 字符

1、char类型是一个单一的 2个字节16位 Unicode 字符；
2、最小值是 \u0000（即为 0），最大值是 \uffff（即为65、535）；
3、char 数据类型可以储存任何字符；
4、可以进行计算，实质为Unicode编码间的计算。

​ 定义： char c1 = ‘a’ char c2 = ‘中’

4、boolean 布尔型

1、boolean数据类型表示一位的信息；
2、只有两个取值：true （1）和 false（0）；
3、这种类型只作为一种标志来记录 true/false 情况；
4、默认值是 false；
5、布尔型用于逻辑运算、条件控制语句、循环语句等

2.3.2 基本类型转换

​ java为强类型语言，数字表示范围小的数据类型可以自动转换成范围大的数据类型，但是大范围的数据转换成小范围数据需要强制类型转换，在计算时会自动向范围表示大的值的数据类型提升。

注意：

1、布尔值不参与类型转换
2、不能把对象类型转换为不相干的类型
3、大范围的数据转换成小范围数据需要`强制类型转换`   (type)value
4、强制转换存在内存溢出的问题，容易影响精度
5、浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

2.3.3 引用数据类型

1、 String字符串

​ 在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。Java语言中字符串必须包含在一个 “” 中。

字符串的创建：

1、String str1 = "name";    //创建一个字符串，编译器会使用该值自动创建一个 String 对象
2、String str2 = new String("name");		//通过new创建一个String对象
//new每次都会创建一个新的对象，而String创建的字符串如果值相同则每次指向的都是同一个对象
//String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了,
//重新赋值只是改变存储的数据地址
1和2两种创建方式的区别：
	1创建的字符串是存放在方法区的字符串常量池中
    2创建的字符串是把对象存放在堆内存中，值存放在常量池中。

​ String是最基本的实际类型吗？
​ 不是，基本数据类型有：byte、short、int、long、float、double、Boolean、char8种
​ Java.lang.String类是final类型的，所以String不能继承和修改。所以为提高效率节省空间，使用StringBuffer类

​ String、StringBuffer、StringBuilder的区别
​ 这三个类都是用于操作字符串，但是String类是final类型，内容不可改。而StringBuffer、StringBuilder类可修改。
​ StringBuilder的运行效率高，但是线程不安全。如果字符串变量在方法中定义，只能有一个线程访问的情况下使用
​ StringBuffer是线程安全的，在类里定义成员变量，且实例对象在多线程环境中使用，则用此类

常用的方法：

1、字符串的拼接：
    用'+'来拼接多個字符串
    	String a = "hello";  String b = "Java";  System.out.println(a+b);    
		結果：hello Java
    用'+'连接字符串和其他数据类型
        String a = "3+2=";		int b = 5;    System.out.println(a+b);       
		结果：3+2=5
        
2、获取字符串长度：
    str.length();
		
3、获取字符串中的字符：
    str.charAt(i);		//i是字符串内每个字符的索引位置从0开始，length-1结束

4、比较字符串
    不忽略字母大小写：str1.equals(str2);
	忽略字母大小写：str.equalsIgnoreCase(str2);

5、获取某一字符的位置：
    查找指定字符第一次出现的位置：str.indexOf("指定的字符")
	从指定位置(int)开始查找指定字符第一次出现的位置：str.indexOf("指定的字符",int)
    查找指定字符最后一次出现的位置：str.lastIndexOf("指定的字符")
    从指定位置(int)开始往前查找指定字符第一次出现的位置：str.lastIndexOf("指定的字符",int);

6、字符串的截取：
    从指定位置截取到最后：str.subString(int)
    从指定位置截取到指定位置：str.subString(int1,int2);  区间[int1,int2)

7、去除空格：
    去除首位空格：str.trim()
    去除所有空格(将所有空格替换)：str.replaceAll("//s","");

8、替换字符串中指定的字符
    将所有符合指定的字符串都替换成新字符串：str.replaceAll("原字符串","新字符串") 可使用字符串格式
    将指定字符替换换成其他字符：str.replace('原字符','新字符')	替换单个字符
    将符合指定字符串的第一个替换成新字符串，后续的不变：str.replaceFirst("原字符串","新字符串");

9、判断字符串的开头与结尾（返回的是布尔值）：
    判断某字符串是否以**开头：str.startsWith("**")
    判断字符串从指定位置开始是否以**开头：str.startsWith("**",int)
    判断某字符串是否以**结尾：str.endsWith("**");

10、字符串中大小写转换：
    大写变小写：str.toLowerCase()
    小写变大写：str.toUpperCase();

11、分割字符串：
    以指定字符分割：str.split('分隔符')
    以指定字符分割指定次数：str.split('分隔符',int);

12、判断是否为空字符串：
    str.isEmpty();

13、字符串的格式化：
    String str = String.formart("",);	//和格式化打印类似

2、 数组

​ 数组是固定长度、存储相同数据类型的一种数据结构，元素在内存中的体现是一个连续的内存空间。有索引值，可通过索引快速快速查询、修改相应元素。

基本特点：

1、数组的长度定义后不可更改，数组是有界限的[0,length-1]，所以在使用过程中经常会遇到数组下标越界的异常
2、一个数组的类型定义后不可改，内部保存的元素必须是相同的
3、数组可定义为任意数据类型类型
4、数组属于引用类型，对象保存在堆中，数据保存在栈中，保存的数据上是地址
5、数组的访问通过索引值

Arrays类：

​ 位于 java.util 包中，主要包含了操纵数组的各种方法

​ 常用的函数：

1、打印数组元素   toString
    Arrays.toString(数组名);			//一维数组
	Arrays.deepToString(数组名);		//多维数组
2、数组元素升序排列：sort
    Arrays.sort(数组名);		 //数值按大小排序，String类型数组按照字典顺序，数字、大写字母、小写字母汉字的顺序
3、填充值：fill
    Arrays.fill(数组名,值);		//用指定的值填充数组全部的元素
	Arrays.fill(数组名,start,end,值);	//数组下标为[start,end)的元素全部填充为指定值
4、比较数组：equals 
    Arrays.equals(数组1，数组2);
5、复制数组	copyOf、copyOfRange
    copyO(数组名,复制的长度)     //超过要复制的数组长度时，整型用0，char用null，小于数组长度截取数组
    copyOfRange(数组,start,end)  //[start,end)截取数组进行复制
6、数组查询     binarySearch
	binarySearch(数组,值)    //如果要搜索的值在数组内，则返回该值的索引，否则返回-1
    binarySearch(数组,start,end,值)   //在[start,end)范围内搜索相应的值
	

冒泡排序：
最常用的数组排序算法之一，将数组元素总是将小数往前放，大数往后放。基本思想是对比相邻的元素值，按规律进行交换。

public class BubbleSort {
    
    public static void main(String[] args) {
    
        int arr[] = {
    26,15,29,66,99,88,36,77,111,1,6,8,8};
        for(int i=0;i < arr.length-1;i++) {
    //外层循环控制排序趟数
            boolean flag = false;	//通过布尔值进行判断，可减少一定的循环次数
            for(int j=0; j< arr.length-i-1;j++) {
    //内层循环控制每一趟排序多少次
                // 把小的值交换到前面
                if (arr[j]>arr[j+1]) {
    
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = true;	//如果判断过，flag就为true
                }
            }
            if(!flag){
    
                break;
            }
        }
        System.out.println("最终排序结果：");
        for(int a = 0; a < arr.length;a++) {
    
            System.out.println(arr[a] + "\t");
        }
    }
}

2.3.4 枚举

枚举类型是Java 5中新增特性的一部分，它既是一种类(class，内部可以有方法和属性)却又比类多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性。

• 使用的场景

  • 需要定义一组常量的时候：一年4个季节、一年12个月份、一星期7天、男女性别、支付方式等等。

  • 创建单例模式的时候，内部只有一个对象，最简单的单例模式创建的方式

• 使用规则

  • 不能被继承
  • 不能被单独的new创建对象
  • 枚举成员是用,隔开的。

在定义枚举类型时我们使用的关键字是enum，enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Serializable 和 java.lang.Comparable 两个接口。有以下方法：

• values() 返回枚举类中所有的值。
• ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。
• valueOf()方法返回指定字符串值的枚举常量。

//枚举类型，使用关键字enum，定义周一到周日的常量
public enum Week {
    
    //不使用枚举需要定义常量
    // private final static String MONDAY = "星期一";.......
    MONDAY("星期一"), TUESDAY("星期二"), WEDNESDAY("星期三"),
    THURSDAY("星期四"), FRIDAY("星期五"), SATURDAY("星六"),
    SUNDAY("星期天");

    //枚举可以作为一个类，添加属性和方法
    Week(String name) {
    
        this.name = name;
    }
    private String name;
    public String getName() {
    
        return name;
    }
    public void setName(String name) {
    
        this.name = name;
    }
}

public static void main(String[] args) {
    
    Week week1 = Week.FRIDAY;
    //在switch中使用
    switch (week1){
    
        case MONDAY: case TUESDAY:   case WEDNESDAY:
        case THURSDAY: case FRIDAY: case SATURDAY:
        case SUNDAY:
            System.out.println(week1.getName());
            break;
        default:
            System.out.println("错误！！");
    }
    System.out.println("-----------分割线-------------");

    //迭代
    for (Week week2:Week.values()) {
    
        System.out.println(week2.getName());
    }
    System.out.println("-----------分割线-------------");

    //valueOf 通过指定字符串值返回枚举常量。
    Week week3 = Week.valueOf("MONDAY");
    System.out.println(week3.getName());
    System.out.println("-----------分割线-------------");

    //ordinal返回索引位置
    Week week = Week.FRIDAY;
    int ordinal = week.ordinal();
    System.out.println(ordinal);


}