Java基础知识导学

「爱情、让人受尽委屈。」 2022-03-02 11:10 294阅读 0赞

## 1.Java与面向对象编程 ##

机器语言，汇编语言，高级语言，面向对象的语言  
面向对象的思想：将客观事物看作具有集体状态和行为的对象，通过抽象找出同一类对象的共同状态和行为，构成类。  
面向对象的益处：可重用性；可靠性。  
面向对象语言的基本特征：抽象和封装；继承；多态。  
Java程序编译执行过程：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZJTllJRQ_size_16_color_FFFFFF_t_70]

2.集本数据类型与表达式  
变量与常量：  
**文字量**:直接出现在程序中并被编译器直接使用，比如30，3.14。也称为常量，即生存期内值不可改变的量。  
**标识符**：一个名称，与内存中的某个位置（地址）相对应；标识符的第一个字母必须是下列字符之一：大小写字母，下划线，美元符号。标识符的第二个字符及后即字符必须是上诉的任意字符，数字符号。  
**变量**：一个由标识符命名的项；每个变量都有类型；变量的值可以被改变。  
**常量**：常量一旦被初始化后就不可改变。  
基本数据类型：（编译器能直接识别的内置数据类型）  
**数值型**：

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>带符号微整数 8 位</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>带符号短整数 16位</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>带符号整数 32位</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>带符号长整数 64位</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>单精度浮点数 32位</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>双精度浮点数 64位</td> 
  </tr> 
 </tbody> 
</table>

数值型文字常量：

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>文字量</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte,short,int</td> 
   <td>十进制数，开头不为o：oX跟十六进制数，如oXFC; o跟八进制数，如o726</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>同上，但后面跟 l 或 L，如：8l ， oXF19L</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>数字后跟f或F，如1.23324F， 1.987F</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>后面可选d或D做后缀，如：1.23D</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>true 或 false</td> 
  </tr> 
 </tbody> 
</table>

**字符型**  
字符类型的文字量是由单引号括起来的字符或者转义序列。如：‘Z’；‘\\t’。  
用16位的Unicode字符作为编码方式，如下面代码所示：

char var_char= ' a ' ;
    char char_tab = ' \t ' ;

某些特殊的字符型常量需要使用转义的形式来表示：（有些字符是不可解释的）

<table> 
 <thead> 
  <tr> 
   <th>转义字符</th> 
   <th>表示含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>’</td> 
   <td>单引号字符</td> 
  </tr> 
  <tr> 
   <td>‘’</td> 
   <td>双引号字符</td> 
  </tr> 
  <tr> 
   <td>\</td> 
   <td>反斜杠字符</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>回车</td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td>回车并换行</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>水平制表符</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>退格</td> 
  </tr> 
 </tbody> 
</table>

**布尔类型**是一个逻辑量，有两个取值：true和false。

booleaan is_salaried:
    	boolean is_hourly;
    	is_salaried = true ; //将is_salaried设置为true
    	is_hourly = false; //将is_hourly设置为false

**字符串**：String是一个类：String类是JDK标准类集合中的一部分  
`String animal = “walrus ”；`  
字符串文字量：由多个，零个字符组成，以双引号括起来；每个字符都可以用转义序列来表示。

“”  //空字符串
    “ \ ""  //只包含”的字符串
    “This is a string " // 有16个字符的字符串
    “This is a "+" string"  //字符串常量表达式，由两个字符串常量组成

**运算符与表达式**  
**算术运算符**  
运算符 ：++ 和 – ；  
一元运算符： + 和 - ；  
加法运算符：+ 和 - ；  
乘法运算符：*, / ，和 %；  
**赋值运算符**  
简单运算符：= ；  
复合运算符：*= ; /=; %= ;+=; -= ; <<=; >>=; >>>=; &=; ^=; |=  
**关系云算符**  
关系表达式的类型永远是布尔类型：（bool）。  
算术比较运算符 < , <= , > , >=  
类型比较运算符（Java特有）：instanceof `e instanceof Point //Point是一个类`  
相等关系运算符  
数值相等运算符/布尔相等运算符/引用相等运算符（Java特有） == ， ！=  
**逻辑运算符**  
“与”运算 &&：如果两个操作数的值都为true运算结果位true；否则，结果为false  
“或”运算|| ：如果两个操作数的值都为false运算结果为false；否则，结果为true  
“非”运算符 ！：操作数的类型必须是布尔类型；如果操作数的结果为false，则表达式的结果为true，如果操作数的结果为true，则表达式的结果为false。  
**条件运算符** （表达式1？表达式2：表达式3）  
首先计算表达式1，如果表达式1的值为真，则选择表达式2的值，如果表达式的值为false，则选择表达式3的值。  
**类型转换**  
每个表达式都有类型  
如果表达式的类型对于上下文不合适：有时导致编译错误；有时语言会进行隐含类型转换。  
扩展转换：byte,char,short,int,long,float,double ;从一种整数类型转换到另一种整数类型，或者从float到double的转换不损失任何信息。但从整数类型向float和double转换，会损失精度。  
窄化转化：可能会丢失信息。  
隐含转换：  
赋值转换：将表达式类型转换为制定变量的类型。  
方法调用转换：适用于方法或构造方法调用中的每一个参数。  
字符串转换（Java）：任何类型都可以转换为字符串类型，当一个操作数是String类型时，适用于+运算符的操作数。  
显式转换：（强制转换）：将一个表达式转换为指定的类型 `（float）5.0`。

3.数组  
数组由同一类型的对象或基本数据组成，并封装在同一个标识符（数组名称）下。  
数组是对象：动态初始化；可以赋值给Object类型的变量；在数组中可以调用类Object的所有方法；每个数组都有一个由public final 修饰的成员变量：length，即数组含有元素的个数（length可以是正数或零）；  
数组元素：数组中的变量；元素没有名字，通过数组名字和非负整数下标值引用数组元素。  
数组的创建和使用：  
**数组声明**：数组引用的声明：声明数组时无需指明数组元素的个数，也不为数组元素分配内存空间；不能直接使用，必须经过初始化分配内存后才能使用。

Type[] arrayName;
    	int[] intArray;
    	String[] stringArray;
    Type[] arrayName[];
    	int intArray[];
    	String stringArray[];

**数组创建**：  
用关键字new构成数组的创建表达式，可以指定数组的类型和数组元素的个数。元素个数可以为常量或变量。  
基本类型数组的每个元素都是一个基本类型的变量；引用类型数组的每个元素都是对象的引用。

arryName = new Type[compinets numbers];
     int[] ai; ai = new int[10];
     String[] s ; s= new String[3];
    //或者可以将数组的声明和创建一并执行；
     int ai[] = new int[10];
    //可以在一条声明语句中创建多个数组；
      String[] s1 = new String[3] , s2 = new String[8];

数组初始化：声明数组名时，给出了数组的初始值，程序便会利用数组的初始值创建数组并对它的各个元素进行初始化。`int a[] = {22,22,33};`  
没有指定初始值：基本类型数之默认为0；boolean类默认为false，引用类型元素的默认值为null。程序也可以在构造数组之后改变数组的元素值。

使用数组  
引用数组的一个元素：`arrayName[index]`数组下标必须是int，short，byte,char。下标从零开始计数。  
元素的个数即为数组的长度，可以通过arryName.length得到。  
元素下标的最大值为：length-1，如果超过最大值，将会产生数组越界异常（ArrayIndexOutOfBoundsException)

**数组名是一个引用：**

public class Arrays
    {
    	public static void main (String[] args)
    		{int[] a1 = {1,2,3,4,5};
    		int[] a2;
    		a2=a1;
    		for(int i= 0; i < a2.length; i++) a2[i]++;
    		for(int i = 0; i <a1.length; i ++)
    			System.out.println("a1["+i+"] = " + a1[i]);
    		}
    }

**字符串引用构成的数组——每个元素都是引用**

public class ArrayOfStringDemo
    { public static void main (String[] args)
    	{String[] anArry = 
    		{"String One" , "String Two" , "String Three"};
    	for(int i = 0 ; i < anArry.length() ; i++);
    	{System.out.println(anArray[i].to.LowerCase());
    	}
    }

复制数组或数组的部分元素：

public static void arraycopy(Object source , int srclndex, Object dest, int destlnde, int length)

public class ArrayCopyDemo {
    	public static void main(String[] args) {
    		char[] copyFrom = {'a','b','b','d','e','f','h','i'};
    		char[] copyTo = new char[4];
    		System.arraycopy(copyFrom, 2, copyTo, 0, 4);
    		System.out.println(copyTo);
    	}
    
    }

**多维数组**：

int[][] gradeTable;
    ....

**二维数组的声明和构造方式**：  
int\[\]\[\] myArray ; myArray是指向2维数组的引用。其初始值为null。  
int\[\]\[\] myArray ; new int \[3\]\[5\]; 定义引用是同时构造数组并初始化引用。这个数组所有元素的初始值为零。  
int\[\]\[\] myArray = \{ \{1,3,4,5\},\{1,3,4,5\},\{1,5,3,5\}\};定义引用，构造数组，初始化数组元素。  
二维数组的长度是该数组的行数，每行的长度可以不一致。  
二维数组由多个一维数组构成。

4.算法的流程控制  
**if语句**  
只有if分支，没有else分支`if(boolean-expression) {//statement;}`  
if - else 语句 `if(boolean-expression) { //statement;} else {//statement2;}`  
if - else语句 `if(boolean-expression) {//statement;} else if (boolean-expression){//statement2;}else if (boolean-expression){//statement}...else{//statement;}`  
条件运算符代替简单的if\_else

//if-else
    If(a>b)
    System.out.println("The larger one is : "+a");
    else
    System.out.println("The latger one is : " + b");
    //用条件运算符重写
    System.out.println("The larger one is : " + (a>b)?a:b);

**switch-case 语句**

switch (switch-expression) {
    	case value1: statements for case1; break;
    	case value2: statements for case2; break;
    	...
    	case valueN: statements for caseN; break;
    	default : statements for default case; break;
    }

switch-expression,常量值value1到vauleN必须是整形或字符；  
如果表达式的值和某个case后面的值相同，则从该case之后执行，知道break语句为止。  
default是可有可无的，若没有一个常量与表达式的值相同，则从default之后开始执行。  
**for语句**  
是Java三个循环语句中功能较强，使用较广泛的一个。  
for循环可以嵌套  
语法格式如下：  
`for(start-expression: check-expression; update-expression){//body of the loop;}`  
start-expression 完成循环变量和其他变量的初始化工作  
check-expression是返回布尔值的条件表达式，用于判断循环是否继续  
update-expression用来修整循环变量，改变循环条件  
三个表达式用分号隔开。

增强for循环：用来对数组或集合对象进行遍历；  
语法格式：`for （Type name:数组或集合类型对象）{//循环体；}`

**while语句**：  
语法形式：`while(check-expression){//body of the loop;}`  
解释：条件表达式的返回值为布尔型；  
循环体可以是单个语句，也可以是复合语句块  
执行过程：先判断check-expression的值，为真则执行循环体  
循环体执行完后，在无条件转向条件表达式作计算和判断；当计算出条件表达式的值为假时，就跳过循环体执行while语句后面的语句，为真，则集训执行循环。

**do-while 语句**：  
语法形式：`do {//body of the loop; }while {check-expression};`  
与while语句很类似，不同的是它首先无条件的执行一遍循环体，再来判断条件表达式的值，若表达式的值为真，则再运行循环体，否则跳出do-while循环，执行下面的语句。

**break语句**：  
跳出循化，不再执行剩余部分；  
在switch结构中，用来终止switch语句的执行  
在for循环及while循环中，中止break语句所在的最内层循环；与标号一同使用时，将跳出标号所标识的循环。  
也可用在代码块中，用于跳出它所指定的块。

**continue语句**：  
必须用于循环结构中；  
停止本次迭代，回到循环起始处，开始下一次迭代过程；  
有两种使用格式：  
不带标号的continue语句  
中止当前这一轮循环，跳出本轮循环剩余的语句，直接进入当前循环的下一轮；  
带标号的continue语句  
使程序的流程直接转入标号标明的循环层次。

注：

1.  一个Java源代码文件中可以定义多个类，但只能有一个类被定义为public，并且public类的名称必须与源代码文件的名称一致。
2.  Java整数类型：Java默认整数自变量为int类型，给byte，short赋值实际是将int类型转换为byte，short类型。若超过它们的范围，则会报错（转换失败）-2^7~2 ^7-1 （ -128-127）/ -2 ^15 ~ 2 ^ 15 - 1 （32767）（2147483647） 。给long型自变量赋值时，在数字后+l /L；表示八进制数，在数字前+0,十六进制+0x；二进制+0b；在数字间+\_ ,增强可读性。
3.  Java浮点类型：Java默认浮点自变量为double类型，赋值给float自变量时，在数字后+f。
4.  字符类型自变量：单引号引用的单个字符。是int类型的一个子集。除了可以将一个字符赋值给字符类型自变量外，还可以将一个在0～65535之间的int类型数字赋值给字符类型变量。在unicode字符集编码中，找到编码是该数字的字符，并把该字符赋值给该字符类型变量。
5.  Java强制类型转换精度损失：浮点型转换为int型时，会舍弃小数部分。原始数据类型大于目标类型的范围时，转换的结果是原始数据类型的值取余目标数据类型所能表示数据的个数。
6.  表达式最终结果数据类型为式中范围最大的数据类型。
7.  表达式中如果没有出现double，float，long，那么所有的操作数都会转型为int。再进行运算。
8.  数组是时使用统一名称引用的一组具有相同类型的数据。
9.  Java的数组属于引用类型。
10. 可以声明任意数据类型的数组，如：由若干int值构成的int类型的数组或由若干字符串构成的String类型的数组。
11. 每个构成数组对象的数据值都被称为数组的元素，可以通过索引来访问数组中的某个元素，索引取值一定在0到数组长度减1的范围内。
12. `int[][] arr = new int[2][3];`等号左侧声明一个引用类型的变量arr，在栈空间中开辟区域；等号右侧实例化一个二维数组，该数组由3个一维数组组成，在对空间中开辟出3个一维数组，其容量都是4。再在堆空间中开辟出一个一维的容量为3的数组，该数组分别引用三个int数组的首地址。在将容量为3的数组的首地址传递给arr变量。则arr就引用到了所有的int一维数组。就间接访问到每一个数组中的某个元素了。
13. Java变量：存储数据的基本单元，必须先声明后才能使用。在方法，及其他小语句块中的变量都被称为局部变量。声明在类中即为实例变量。局部变量特点：第一次使用前必须被初始化；变量赋值：直接赋值，表达式赋值，方法调用返回的结果赋值。
14. 基本数据类型变量：存储在虚拟机栈（容量小，速度快）。
15. 变量作用域：当变量被声明后在怎样的范围内是有效的/在什么样的范围内可以被访问到。Java的变量作用域被绑定在声明这个变量的代码块之内。
16. 代码块：大括号之内。
17. 常量：加关键字 final `final int x = 10`

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZJTllJRQ_size_16_color_FFFFFF_t_70]: /images/20220302/fc007ff7de7c45b78a5ace02480718f6.png