Java基础总复习笔记【一】：Java基础、基本数据类型、变量、修饰符、运算符、循环结构、条件语句、switch case、数组、对象和类、包

一、Java基础

1.Java 标识符

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
注意事项：
（1）所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（ $ ）、或者下划线（ _ ）开始
（2）首字符之后可以是字母（A-Z 或者 a-z）,美元符（ $ ）、下划线（ _ ）或数字的任何字符组合
（3）关键字不能用作标识符
（4）标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary

2.Java修饰符

Java可以使用修饰符来修饰类中方法和属性。
主要有两类修饰符：
（1）访问控制修饰符 : default, public , protected, private
（2）非访问控制修饰符 : final, abstract, static, synchronized

3.Java 变量

（1）局部变量
（2）类变量（静态变量）
（3）成员变量（非静态变量）

4.Java 关键字

以上图片来源于菜鸟教程

二、Java 基本数据类型

详细总结见以下链接：
https://blog.csdn.net/qq_45605223/article/details/102491247

1.内置数据类型

六种数字类型（四个整数型【byte 、short 、int 、long 】，两个浮点型【float 、double】），一种字符类型【char】，还有一种布尔型【boolean】。

2.引用数据类型

对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。

3.类型转换

低 ----------------------------------------------------------> 高
byte,short,char—> int —> long—> float —> double

数据类型转换规则：
（1）不能对boolean类型进行类型转换。
（2）不能把对象类型转换成不相关类的对象。
（3）在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
（4）转换过程中可能导致溢出或损失精度。
（5）浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入。

（1）自动类型转换

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

（2）强制类型转换

条件是转换的数据类型必须是兼容的。
格式：(type)value type是要强制类型转换后的数据类型。

三、Java变量

详细总结见以下链接：
https://blog.csdn.net/qq_45605223/article/details/108018775
Java语言支持的变量类型有：
类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

四、Java 修饰符

Java语言提供了很多修饰符，主要分为以下两类：
（1）访问修饰符
（2）非访问修饰符

1.访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
（1）default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
（2）private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
（3）public : 对所有类可见。使用对象：类、接口、变量、方法
（4）protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

范围	private	default	protected	public
同一包中的同一类	√	√	√	√
同一包中的不同类	×	√	√	√
不同包中的子类	×	×	√	√
不同包中的非子类	×	×	×	√
其他包	×	×	×	√

访问控制和继承

请注意以下方法继承的规则：
（1）父类中声明为 public 的方法在子类中也必须为 public。
（2）父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
（3）父类中声明为 private 的方法，不能够被继承。

2.非访问修饰符

（1）static 修饰符
静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

---

（2）final 修饰符
final 变量：
final变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
final 修饰符通常和 static 修饰符一起使用来创建类常量。
final 方法：
父类中的 final 方法可以被子类继承，但是不能被子类重写。
声明 final 方法的主要目的是防止该方法的内容被修改。
final 类：
final 类不能被继承，没有类能够继承 final 类的任何特性。

---

（3）abstract 修饰符
抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
抽象方法：
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

---

（4）synchronized 修饰符
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

---

（5）transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

---

（6）volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。

五、Java 运算符

详细总结见以下链接：
https://blog.csdn.net/qq_45605223/article/details/102491247

1.算术运算符

2.关系运算符

3.位运算符

4.逻辑运算符

5.赋值运算符

6.Java运算符优先级

六、Java 循环结构

1.while 循环

while( 布尔表达式 ) {
  //循环内容
}

只要布尔表达式为 true，循环就会一直执行下去。

2.do…while 循环

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {
       //代码语句
}while(布尔表达式);

注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

3.for循环

for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

关于 for 循环有以下几点说明：
最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。

4.break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。

5.continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

七、Java 条件语句

1.if语句

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。

2.if…else语句

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

3.if…else if…else 语句

if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。
使用 if，else if，else 语句的时候，需要注意下面几点：
if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

4.嵌套的 if…else 语句

使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。

if(布尔表达式 1){
   如果布尔表达式 1的值为true执行代码
   if(布尔表达式 2){
      如果布尔表达式 2的值为true执行代码
   }
}

八、Java switch case 语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

switch case 语句有如下规则：
（1）switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
（2）switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
（3）case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
（4）当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
（5）当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
（6）switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
（7）switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

九、Java数组

详细总结见以下链接：
https://blog.csdn.net/qq_45605223/article/details/102640941

1.遍历数组的方法：

(1)for循环：

int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

for可以通过下标去访问。

---

(2)for-each：

int[] arr = {1, 2, 3};//for(表达式1：表达式2)    
for (int x : arr) {    //表达式1：数组当中的变量及其类型
    System.out.println(x);  //表达式2：数组名
}

for-each不能用下标去访问。
for-each较for更方便快捷，可以避免循环条件和语句写错。

2.数组中常见的异常问题：

(1)越界异常。

int[] array={1,2,3,4,5,6};
System.out.println(array[12]);
//java.lang.ArrayIndexOutOfBoundsException: 12  报异常

---

(2) [I@1540e19d异常（地址的哈希码）

int[] array1 = {1,2,3,4,5};
System.out.println(array1);//[I@1540e19d

---

(3)空指针异常：

int[] array1 = null;//java.lang.NullPointerException
System.out.println(array1.length);//null是所有引用类型的初始值
String str=null;//java.lang.NullPointerException
System.out.println(str.length);
//点号(.)之前若是null，大概率情况下肯定会出现空指针异常

3.打印数组的方式：

Arrays.toString(数组名) 将数组以字符串形式输出。

int[] array={1,2,3,4,5};//用时需导入包java，util，Arrays
System.out.println(Arrays.toString(array));//Arrays：java当中操作数组的工具类
//输出结果：[1, 2, 3, 4, 5]

//自己实现一个to.String()方法来打印数组
public static String toString(int[] array) {
        String ret="[";
        for (int i=0;i<array.length;i++){
            if (i==array.length-1){
                ret+=array[i];
            }else {
                ret+=array[i]+",";
            }
        }
        ret+="]";
        return ret;
    }
    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        System.out.println(toString(array));
    }

4.数组的拷贝：

(1)for循环：（较麻烦，若数组内元素过多，则运行会很慢）

public static int[] copyOf(int[] arr) { 
	int[] ret = new int[arr.length]; 
 	for (int i = 0; i < arr.length; i++) { 
 		ret[i] = arr[i]; 
 	} 
 return ret; 
}

---

(2)Arrays.copyOf();(修改原数组, 不会影响到新数组.)

//Arrays.copyOf(int[] original, int newLength)
import java.util.Arrays 
int[] arr = {1,2,3,4,5,6}; 
int[] newArr = Arrays.copyOf(arr, arr.length); 
System.out.println("newArr: " + Arrays.toString(newArr)); 
arr[0] = 10; 
System.out.println("arr: " + Arrays.toString(arr)); 
System.out.println("newArr: " + Arrays.toString(newArr));

---

(3)System.arraycopy();被native修饰的方法

//System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
public static void main(String[] args) {
    int[] array1={1,2,3,4,5};
    int[] array2=new int[array1.length];//需要new
    System.out.println(Arrays.toString(array2));//输出结果：[0, 0, 0, 0, 0]  拷贝前
    System.arraycopy(array1, 0, array2, 0, array1.length);
    System.out.println(Arrays.toString(array2));//输出结果：[1, 2, 3, 4, 5]  拷贝后  
    //Array.toString(array)将数组以字符串输出（ 需要Java.util.Arrays包）
}

Arrays.copyOf();比System.arraycopy();速度慢，因为Arrays.copyOf();方法内部调用了System.arraycopy();

---

(4)数组名.clone(); 数组名为原数组，需要拷贝的数组

int[] array = {1,2,3,4,5,6,7,8,9,10};
int[] array2 = new int[array.length];//不算拷贝
array2 = array.clone();
System.out.println(Arrays.toString(array2));

以上四种拷贝方式，对数组当中，如果是简单类型来讲，就为深拷贝。如果数组当中存放的是引用类型，那么这四种拷贝方式就是浅拷贝。
如果两个引用同时指向一个对象，那么通过一个引用，也会受到影响，这种拷贝叫做浅拷贝。

十、Java 对象和类

详细总结见以下链接：
https://blog.csdn.net/qq_45605223/article/details/102883965

对象：对象是类的一个实例，有状态和行为。
类：类是一个模板，它描述一类对象的行为和状态。

1.Java对象

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：
（1）声明：声明一个对象，包括对象名称和对象类型。
（2）实例化：使用关键字 new 来创建一个对象。
（3）初始化：使用 new 创建对象时，会调用构造方法初始化对象。

对象就是这一类具体化的一个实例。java程序中可以使用new关键字来创建对象。
每个对象都保存着描述当前特征的信息，这就是对象的状态。但是，对象的状态并不能完全描述一个对象。

//实例化一个对象
<class_name_> 对象名 = new <class_name_>();

new执行的过程：（1）为对象分配内存空间（2）调用对象的构造方法
一个对象的产生分为两步：
（1）为对象分配内存；（2）调用适合的构造方法，构造方法不只一个。

2.Java类

类是构造对象的模板和蓝图。就是一类对象的统称。
由类构造对象的过程称为创建类的实例。

class类名{
	类体；
}

一个类可以包含以下类型变量：
（1）局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
（2）成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
（3）类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

十一、Java 包

详细总结见以下链接：
https://blog.csdn.net/qq_45605223/article/details/103036264
包主要用来对类和接口进行分类。当开发 Java 程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

1.import 语句

在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

package bao.bao1;

静态导入
使用 import static 可以导入包中的静态。

2.包的作用

1. 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2. 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3. 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。