Java 语法总结

Posted 2022-12-09 ayanwan

一、语法基础：

1.1  变量与常量

1、关键字：其实就是某种语言赋予了特殊含义的单词。

      保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词。

2、标示符：其实就是在程序中自定义的名词。比如类名，变量名，函数名。包含 0-9、a-z、$、_ ；

      注意：

1）数字不可以开头。

2）不可以使用关键字。

3、常量：是在程序中的不会变化的数据。

4、变量：其实就是内存中的一个存储空间，用于存储常量数据。

      作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。

      特点：变量空间可以重复使用。

      什么时候定义变量？只要是数据不确定的时候，就定义变量。

      变量空间的开辟需要什么要素呢？

1）这个空间要存储什么数据？数据类型。

2）这个空间叫什么名字啊？变量名称。

3）这个空间的第一次的数据是什么？ 变量的初始化值。

  （1）变量的作用域：作用域从变量定义的位置开始，到该变量所在的那对大括号结束；

  （2）生命周期：变量从定义的位置开始就在内存中活了；变量到达它所在的作用域的时候就在内存中消失了；

5、数据类型：

1）基本数据类型：byte、short、int、long、float、double、char、boolean

2）引用数据类型: 数组、类、接口。

级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double

自动类型转换：从低级别到高级别，系统自动转的；

强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；

1.2 运算符

1）算术运算符。+ - * / % %:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。+:连接符。++,--

2）赋值运算符。= += -= *= /= %=

3）比较运算符。特点：该运算符的特点是：运算完的结果，要么是true，要么是false。

4）逻辑运算符。& | ^ ! && ||    特点：逻辑运算符除了 ! 外都是用于连接两个boolean类型表达式

& : 只有两边都为true结果是true。否则就是false。

| :只要两边都为false结果是false，否则就是true

^ :异或：和或有点不一样。两边结果一样，就为false；两边结果不一样，就为true。

       & 和 &&区别：

 & ：无论左边结果是什么，右边都参与运算。

&&:短路与，如果左边为false，那么右边不参数与运算。

       | 和|| 区别：

|：两边都运算。

||：短路或，如果左边为true，那么右边不参与运算。

5）位运算符:用于操作二进制位的运算符。& | ^    << >> >>>(无符号右移)

1.3 控制语句

switch细节：

1）break是可以省略的，如果省略了就一直执行到遇到break为止；

2）switch 后面的小括号中的变量应该是byte,char,short,int四种类型中的一种；

3）default可以写在switch结构中的任意位置；如果将default语句放在了第一行，则不管expression与case中的value是否匹配，程序会从default开始执行直到第一个break出现。

        while和for可以进行互换。区别在于：如果需要定义变量控制循环次数。建议使用for。因为for循环完毕，变量在内存中释放。

        break:作用于switch ，和循环语句，用于跳出，或者称为结束。break语句单独存在时，下面不要定义其他语句，因为执行不到，编译会失败。当循环嵌套时，break只

跳出当前所在循环。要跳出嵌套中的外部循环，只要给循环起名字即可，这个名字称之为标号。

        continue:只作用于循环结构，继续循环用的。作用：结束本次循环，继续下次循环。该语句单独存在时，下面不可以定义语句，执行不到。

1.4 数组

1、数组：用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。

1）声明数组

语法： 数据类型[ ] 数组名；    或者     数据类型 数组名[ ]；

2）分配空间：简单地说，就是指定数组中最多可存储多少个元素

语法： 数组名 = new 数据类型 [ 数组长度 ]；

       其中，数组长度就是数组中能存放元素的个数，

3）赋值：分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的。

在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成。如：

int[] scores = 11,12,13,14;    等价于   int[] scores = new int[]11,12,13,14;

4） 数组名.length 用于获取数组的长度；

5） 使用 Arrays 类操作 Java 中的数组：

        Arrays.sort(数组名) 对数组进行升序排序；Arrays.toString(数组名)：将数组转换为字符串

1.5 函数

重载的定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。

判断方法重载的依据：

1、 必须是在同一个类中

2、 方法名相同

3、 方法参数的个数、顺序或类型不同

4、 与方法的修饰符或返回值没有关系

java分了5片内存。

1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。

栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；

只要数据运算完成所在的区域结束，该数据就会被释放。

堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。

1：每一个实体都有内存首地址值。

2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。

3：垃圾回收机制。

二、面向对象三大特性

2.1 类与对象

类的特点：是具有相同属性和方法的一组对象的集合。类是对象的类型。

通过 类名 对象名 = new 类名(); 可以创建类的对象

1、成员变量和局部变量

（1）作用域不同

局部变量的作用域仅限于定义它的方法

成员变量的作用域在整个类内部都是可见的

（2）初始值不同

         Java会给成员变量一个初始值，却不会给局部变量一个初始值；

2、构造函数

（1）一般的 new 一个新对象时，系统是执行一个构造方法，如果class中没有定义构造方法，系统自动生成无参的构造方法；

（2）当没有指定构造方法时，系统会自动添加一个无参构造方法；而当class中定义了构造方法，不管是有参的还是无参的，系统都不会在生成构造方法。

3、static静态变量

         使用 static 可以修饰变量、方法和代码块。Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。

静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问~~

4、static静态方法

1）静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员；

      如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。

2）静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

3）在普通成员方法中，则可以直接访问同类的非静态变量和静态变量；

5、static静态代码块

      在类的声明中，可以包含多个初始化块，当类的实例化时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。

      需要特别注意：静态初始化块只在类加载时执行，且只执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

6、toString()方法

          toString是Object类的方法，所有类都从Object类继承。

（1）如果你定义的类没有覆盖toString方法，则对象在调用toString方法时用的是Object类toString方法，返回的是“类名@hashcode"。如果是byte[] 类型的话，则是“[B@hashcode”

          System.out.println(obj)在参数是一个对象时，会默认调用该对象的toString方法。

（2）String类和StringBuffer类都覆盖了toString方法，都是返回字符串。所以带不带toString效果是一样的。

String s1 = "hello";
StringBuffer s2 = new StringBuffer(s1);
s2.append(" world");
System.out.println(s2.toString());
System.out.println(s2);

结果：
hello world

hello world

【PS : getBytes() vs new String()】

（1）String的getBytes()方法是得到一个系统默认的编码格式的字节数组。

（2）通过String.getBytes(String decode)方法来得到byte[]，通过new String()将byte[]数组还原。

String str = "570FF26603A91CC3";
byte[] bStr = str.getBytes();
System.out.println(new String(bStr));

结果：570FF26603A91CC3

分析：bStr = [53, 55, 48, 70, 70, 50, 54, 54, 48, 51, 65, 57, 49, 67, 67, 51]  ascii码的十进制显示。

【PS: hex编码】

        Hex就是16进制，本质上是将字节数组转化为16进制，然后用字符串的形式表现出来，我们知道16进制的取值范围就是在0-f之间，这样就可以将无法显示的字节数组数据显示出来。

        原理：一个8bit的数据，也就是（xxxx xxxx）,每4个bit可以转化为一个16进制表示，也就是8个bit会转化为（00-ff）之间的16进制数字。

        hex编码 ：指将数据编码16进制字符串；hex解码：指16进制字符串解码为数据。

public static void main(String[] args) 
		/************* getBytes() new String() toString() hex ****************/
		String str = "570FF26603A91CC3";
		byte[] bStr = str.getBytes();
		String Bhex = bcd2str(bStr);// hex编码

		byte[] hex2b = hexStringToBytes(Bhex);// hex解码
		String b2s = new String(hex2b);

		System.out.println("Bhex = " + Bhex);
		System.out.println("hex2s = " + b2s);

	

	public static byte[] hexStringToBytes(String hexString) 
		if (hexString == null || hexString.equals("")) 
			return null;
		
		hexString = hexString.toUpperCase();
		int length = hexString.length() / 2;
		char[] hexChars = hexString.toCharArray();
		byte[] d = new byte[length];
		for (int i = 0; i < length; i++) 
			int pos = i * 2;
			d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
		
		return d;
	

	private static byte charToByte(char c) 
		return (byte) "0123456789ABCDEF".indexOf(c);
	

	public static String bcd2str(byte[] bcds) 
		char[] ascii = "0123456789abcdef".toCharArray();
		byte[] temp = new byte[bcds.length * 2];
		for (int i = 0; i < bcds.length; i++) 
			temp[i * 2] = (byte) ((bcds[i] >> 4) & 0x0f);
			temp[i * 2 + 1] = (byte) (bcds[i] & 0x0f);
		
		StringBuffer res = new StringBuffer();

		for (int i = 0; i < temp.length; i++) 
			res.append(ascii[temp[i]]);
		
		return res.toString().toUpperCase();
	

2.2 封装

     类的封装：类的封装使用户通过类的作者指定的方法修改类的数据成员，而不使用户直接操作数据成员，这叫做类的封装。封装是为了隐藏属性，通过方法给属性赋值。

1、包的作用：管理Java文件；解决同名文件冲突

        注：必须放在Java源程序的第一行，必须小写。

2、访问控制符   

3、this

this关键字代表当前对象

this.属性 操作当前对象的属性

this.方法 调用当前对象的方法

封装对象的属性时，经常用this关键字

4、内部类

      内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

作用是：

1）内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类；

2）内部类的方法可以直接访问外部类的所有数据，包括私有的数据；

3）内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便。

内部类可分为以下几种：

（1）成员内部类：

        A、 外部类是不能直接使用内部类的成员和方法

        B、如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。

（2）静态内部类：

      静态内部类是 static 修饰的内部类，这种内部类的特点是：

      A、静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

      B、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

      C、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

（3）方法内部类

      方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

（4）匿名内部类

2.3 继承

          继承是类与类之间的关系，是一种is a的关系。子类拥有父类的所有属性和方法，private修饰的无效。

1、重写：如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。

      语法规则：a.返回值类型 b.方法名 c.参数类型及个数，都要与父类继承的方法相同，才叫方法的重写。

2、继承的初始化顺序：

     1）初始化父类再初始子类

     2）先执行初始化对象中属性，再执行构造方法中的初始化

3、final中文的意思就是最终的意思；它可以修饰类，方法，属性和变量；

final修饰类，则该类不能被继承；

final修饰方法，则该方法不能被重写或覆盖； final修饰属性，则该属性在类的初始化时必须有值；或者，在构造方法赋值（只能选择其一）； final修饰变量，则该变量就只能赋一次值，==常量。

4、super      1）子类的构造的过程当中必须调用其父类的构造方法。      2）如果子类的构造方法中没有调用父类的构造方法，则系统默认调用父类无参的构造方法。
     3）如果显示的调用构造方法，必须在子类的构造方法的第一行。
     4）如果子类构造方法中既没有显式调用父类的构造方法，而父类又没有无参的构造方法，则编译出错。（如果自定义一个有参的构造方法，系统就不会帮我们自动生成一个无参的构造方法）
5、object类      1）在Object类里面定义toString()方法的是返回的对象的哈希code码（对象地址字符串）      2）当我们new一个类的时候，得到的对象叫做 类的对象（对象的属性值的信息，或者说这个对象数据信息）；如果这个对象调用getClass()方法，得到的是 类对象（类对象描述的是类的代码信息）   

2.4 多态

1、多态：对象的多种形态     1）引用多态：父类引用（对象）可以指向本类对象也可以指向子类对象；     2）方法多态：不能调用子类独有方法，父类引用调用父类方法、子类引用调用子类方法（或父类的方法重载）；如果子类没有方法，则调用的是父类对应的方法。 2、多态的引用类型转换：     1）向上类型转换(隐式/自动类型转换)，是小类型到大类型的转换 无风险；
    2）向下类型转换( 强制类型转换)，是大类型到小类型 有风险；     3） instanceof运算符， 用来判断对象是否有相同属性，从而解决引用对象的类型，避免类型转换的安全性问题； 3、抽象类        在某个父类只知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法时候使用抽象类。抽象类没有方法体，以分号结束 ，抽象类不能直接创建变量，可以定义引用，限制规定子类必须使用某些方法但不关注实现细节。 4、接口         接口可理解为一种特殊的类，由全局常量和公共的抽象方法组成。类是一种具体实现体，而接口定义了某一批类所必须遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。和类定义不同，定义接口不再使用class，使用interface关键字。
        匿名内部类：就是直接new 接口，在接口里面实现方法。

三、常用工具类

3.1 异常处理

3.1.1 异常分类：

1）Java中的所有不正常类都继承于Throwable类。Throwable主要包括两个大类，一个是Error类，另一个是Exception类； 2）Error类中包括虚拟机错误和线程死锁，一旦Error出现了，程序就彻底的挂了，被称为程序终结者；
3）Exception类主要指编码、环境、用户操作输入出现问题，Exception主要包括两大类，非检查异常（RuntimeException）和检查异常（其他的一些异常）
4）RuntimeException异常主要包括以下四种异常：空指针异常、数组下标越界异常、类型转换异常、算术异常。
5）检查异常：IOException（文件异常）和SOL异常。

3.1.2 异常处理原则

1）程序出现后会终止运行，然后将程序的控制权交给catch块中的异常处理程序；
2）当使用多个catch块时，须按照先子类后父类的顺序；
3）finally 为 catch后 最终要执行的一些代码；finally 语句的优先级比较高 所以不管是否已经return 完 ，都会执行；

3.1.3 异常抛出

需要用到throw和throws：
1）throw：将产生的异常抛出(动作)；
2）throws：在添加方法的时候添加。声明将要抛出何种类型的异常；

3.1.4 自定义异常与异常链

1、自定义异常 格式：class 自定义异常类 extends 异常类型
注意：自定义异常： 必须继承相似的类或直接继承Exception 2、Java中的异常链：将捕获的异常包装成新的异常，然后在新的异常中添加对原始异常的引用，再把这个新的异常抛出。就像是链式反应一样，一个导致一个。

【总结】 1、处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
2、在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
3、对于不确定的代码，也可以加上try-catch，处理潜在的异常
4、尽量去处理异常，切记只是简单的调用printStackTrace（）去打印
5、具体如何处理异常，要根据不同的业务需求和异常类型去决定

3.2 集合框架

        集合框架有两大家族：分别是Collection接口，Map接口 （1）Collection中有三个常用的子接口：List,Queue,Set(无序不可重复)。他们下面又有3个实现类：ArrayList(数组序列)，LinkedList(链表)，HashSet。 （2）Map中有一个常用子接口：HashMap它是以（entry）键值对的形式存储数据的，就相当于一个字典集。

3.2.1 Collection接口

List(元素排列有序，可重复：序列)-ArrayList(数组序列)  Queue(有序，可重复，不常用：队列)LinkedList(链表)（也属List） Set(无序，不可重复：集)HashSet(哈希集) Map接口:----<key,value>----HashMap(哈希表)

3.2.2 Map接口

（1）Map提供了一种映射关系，其中的元素是以键值对（key - value）的形式存储的，能够实现根据key快速查找value （2）Map中的键值对以Entry类型的对象实例形式存在 （3）键（key值）不可重复，value值可以重复 （4）每个键最多只能映射到一个值 （5）Map接口提供了分别返回key值集合，value值集合以及Entry（键值对）集合的方法 （6）Map支持泛型，形式如：Map<K，V>

四、文件操作

4.1 进制转换

4.1.1 java进制转换

4.1.2 Java中类型数据转为字节

1、int类型：
1.1、byte(Byte)：8bit；
1.2、short(Short)：16bit；
1.3、int(Integer)：32bit；
1.4、long(Long)：64bit；
2、float类型：
2.1、单精度：float(Float)，32bit；
2.2、双精度：double(Double)，64bit；
3、boolean(Boolean)类型：取值true或false；
4、char(Character)类型：Unicode字符，16bit；

【int转byte】

//int转为byte
public static byte[] int2Bytes(int id) 
byte[] arr = new byte[4];
for (int i = 0; i < arr.length; i++) 
arr[i] = (byte) ((int) (id >> i * 8) & 0xff);

return arr;

//byte转为int
public static int byte2Int(byte[] arr) 
int result = 0;
for (int i = 0; i < arr.length; i++) 
result += (int) ((arr[i] & 0xff) << i * 8);

return result;

【String转byte】

（1）字符串转换为字节数组
String s = "hello";
byte[] bs = s.getByte();
（2）字节数组转换为字符串：
byte[] bs = new byte[int];
String s = new String(bs);或
String s = new String(bs,"UTF-8"); //指定编码方式