黑马程序员_java基础笔记(02)...java语言基础组成

逃离我推掉我的手 2021-12-09 17:07 340阅读 0赞

——————————  ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————

java语法(1：关键字，2：标识符，3：注释，4：常量和变量，5：运算符，6：语句，7：函数，8：数组)

**1:关键字**

定义：被java语言赋予特殊含义的单词

特点：关键字中所有单词都是小写

用于 **定义数据类型**的关键字

class，interface，byte，short，int，long，float，double，char，boolean，void

用于 **定义数据类型值**的关键字

true，false，null

用于 **定义流程控制**的关键字

if，else，switch，case，default，while，do，for，break，continue，return

用于定义 **访问权限修饰符**的关键字

private，protected，public

用于 **定义类，函数，变量修饰符**的关键字

abstract，final，static，synchronized

用于 **定义类与类之间关系**的关键字

extends，implements

用于定义 **建立实例及引用实例，判断实例**的关键字

new，this，super，instanceof

用于 **异常处理**的关键字

try，catch，finally，throw，throws

用于 **包**的关键字

package，import

其他修饰符关键字

native，strictfp，transient，volatile，assert

**2:标识符**

程序中自定义的一些名称，由26个英文大小写字母，数字0~9，符号\_$ 组成。

如： 包名xxxyyyzzz， 类名接口名XxxYyyZzz， 变量名和函数名xxxYyyZzz， 常量名XXX\_YYY\_ZZZ

**　　** 规则：1，数字不可以开 头。2，不可以使用关键字

**java中严重区分大小写**

**3:注释**

单行注释 //注释文字

多行注释 /\* 注释文字\*/

文档注释  /\*\* 注释文字\*/

**4:常量和变量**

**　　常量**：程序中不会变化的数据。

**　　整数常量**，**小数常量**，**布尔型常量**（true,false），**字符常量**（将一个数字，字母或符号用单引号标识），**字符串常量**（将一个或者多个字符用双号标识），**null常量**

**　　变量：**内存中一个储存区域，该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型范围内不断变化

定义变量的格式：**数据类型 变量名 = 初始化值**；

**数据类型**

1：基本数据类型｛ **①**数值型（a：整数类型 byte , short , int , long  b:浮点类型 flort,double）**②**字符型 char **③**布尔型 boolean ｝

2：引用数据类型\{ 类 class ，接口 interface ，数组 \[ \]  \}。**整数默认int，小数默认double**

**类型转换**

byte b = 3 ;

b  =  b + 3 ;??????强制转换   b=(byte)(b+3)

**5:运算符**

**算数运算符**

**% 取模**  A % B  =  A — (A / B) \* B , 注意  (A / B)含义为整除 ； 例  5%5=0；1%5=1；2%5=2；—2%5=—2；2%—5=2；

++自增

例 （前）a=2；b=++a；结果：a=3;b=3;

例 ( 后） a=2；b=a++；结果：a=3;b=2;

**赋值运算符**

= 　　+=　　—=　　\*=　　/=　　%=

思考：例：

int a=3;a+=5; 值等同于a=a+5;

如果是short a = 3；？

a+=5;一次运算a = a + 3；

a=a+5;两次运算a+=3；

**比较运算符**

==　　!=　　>　　<　　>=　　<=　　instanceof

结果都是boolean型的，只有两个值true，false

**逻辑运算符**

&　　 | 　　^　　 !　　&& 　　||

& : 两边的boolean表达式结果，有一个为false。那么结果就是false。 否则为true。

| : 两边有一个为true，结果为true。 否则为false。

^ : 两边相同结果是false。 两边不同结果是true。

&和&&的特点： &:无论左边是true是false。右边都运算。 &&:当左边为false时，右边不运算。 |：两边都参与运算。 ||：当左边为true。右边不运算。

**位运算符**

<<　　 >>　　 >>> 　　&　　 |　　 ^ 　　~

位运算是直接对二进制进行运算。

例

最有效的方式算出3\*8等于几？3<<3;

2<<3相当于3\*（2\*2\*2）；

5<<1相当于5\*2；

5<<3相当于5\*（2\*2\*2）；

**两个数的互换 int = n = 3 ; m = 8 ;**

**1:通过第三变量**

int temp;

temp = n;

n = m;

m = temp;

**2:不用第三变量（有局限性，int的范围）**

n = n + m;

m = n — m;

n = n — m;

**　3:技巧**

n = n ^ m;

m = n ^ m;｛（n ^ m）^ m ｝

n = n ^ m; ｛ n ^（n ^ m ）｝

**三元运算符**

格式：（条件表达式）？表达式1 **:** 表达式2；

如果运算结果为true，运算后的结果是表达式1；如果运算结果为false，运算后的结果是表达式2；

例： int x = 3, y = 4, z;

z = (x>y)?x:y;

**6:语句**

**判断 if语句**

格式：

①**if**(条件表达式)\{执行语句;\}

②**if**(条件表达式)\{执行语句;\} **else**\{执行语句;\} 简写格式:变量 = (条件表达式)**?**表达式1**：**表达式2；

③**if**(条件表达式)\{执行语句;\} **else if**\{执行语句;\}......**else**\{执行语句;\}

**选择switch语句**

格式:

switch(表达式)\{case 取值1:执行语句;break;case取值2:执行语句;break;......default:执行语句;break;\}

特点：

1,选择的类型只有四种：byte,short,int,char

2,case之间与default没有顺序。先执行第一个case,没有匹配的case执行default.

3,结束switch语句的两种情况：遇到break，执行的switch语句结束。

4,如果匹配的case或者default没有对应的break，哪么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

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

int num =4;  
 　　int y = 0;  
 　　switch(num) \{   
 　　　　case 3:  
 　　　　　　y+=3;  
 　　　　　　System.out.println("y3="+y);  
 　　　　case 4:  
 　　　　　　y+=4;  
 　　　　　　System.out.println("y4="+y);//4  
　　　　　　//有break;结束，没有会继续运行下一个。  
　　　　case 5:  
 　　　　　　y+=5;  
 　　　　System.out.println("y5="+y);//y=4+5  
　　\}

**循环语句（while，do while，for）**

格式：

**while**(条件表达式)\{执行语句;\}　　while:先判断条件，只有条件满足才执行循环体。

**do**\{执行语句;\} **while**(条件表达式);　　do while: 先执行循环体，在判断条件，条件满足，再继续执行循环体。

**for**(初始化表达式；循环条件表达式；循环后的操作表达式)\{执行语句；\}

for和while可以进行互换。如果需要定义循环增量，用for更为合适，for语句执行完毕，该变量在内存中被释放。

无限循环的最简单表现形式。 **for( ; ; )\{ \}  　　while( true )\{ \}**

**　　continue**:只能作用于循环结构。继续循环。特点：结束本次循环，继续下一次循环。

**7:函数**

为了提高代码的复用性。对代码进行抽取。将这个部分定义成一个独立的功能。java中对功能的定义是通过函数的形式来体现的。

函数定义的 格式。

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，) \{ 执行语句; return 返回值; \}

当函数运算后，没有具体的返回值时，这是返回值类型用一个特殊的关键字来标识。该 **关键字**是 **void**，void:代表的是函数没有具体返回值的情况。当函数的返回值类型是void时，函数中的return语句可以省略不写。

**如何定义一个函数呢？**

1，既然函数是一个独立的功能，那么该功能的运算结果是什么先明确，因为这是在明确函数的返回值类型。

2，明确在定义该功能的过程中，是否需要未知的内容参与运算。因为是在明确函数的参数列表（参数的类型和参数的个数）。

**函数的作用：**

1,用于定义功能。

2,用于封装代码提高代码的复用性。

注意：函数中只能调用函数，不能定义函数。

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

注意：重载和返回值类型没关系。参数有顺序。

**　　什么时候用重载？**

当定义的功能相同，但参与运算的未知内容不同。

那么，这时就定义一个函数名称以表示起功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

重载示例：打印乘法表

public static void print99**(int num)**\{

for(int x=1; x<=num; x++)\{

for(int y=1; y<=x; y++)\{

System.out.print(y+"\*"+x+"="+y\*x+"\\t");

System.out.println();

//打印99乘法表

public static void print99**()**\{

print99(9);

**8:数组：**用于存储同一类型数据的一个容器。

**　　**格式：

元素类型\[\] 变量名 = new 元素类型\[元素的个数\]；

元素类型\[\] 变量名 = \{元素1，元素2...\}；

元素类型\[\] 变量名 = new 元素类型\[\]\{元素1，元素2...\}；

**　　内存结构**

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放

堆内存：数组和对象，通过new建立的实例都存放在堆内存中

每一个实例都有一个内存地址值，实体中的变量都有默认初始化值，实体不再被使用，会在不确定的时间内被垃圾回收器回收。

方法区，本地方法区，寄存器

**选择排序。**内循环结束一次，最值出现头角标位置上。

public static void selectSort(int\[\] arr)\{

for (int x=0; x<arr.length—1 ; x++)\{

for(int y=x+1; y<arr.length; y++)\{

if(arr\[x\]>arr\[y\])\{

int temp = arr\[x\];

arr\[x\] = arr\[y\];

arr\[y\]= temp;

**冒泡排序**

public static void bubbleSort(int\[\] arr)\{

for(int x=0; x<arr.length—1; x++) \{  //也可以 , 外循环:for(int x=arr.length—1; x>0; x——)。 内循环:for(int y=0; y<x; y++)

for(int y=0; y<arr.length—x—1; y++)\{  //—x:让每一次比较的元素减少，—1：避免角标越界。

if(arr\[y\]<arr\[y+1\])\{

int temp = arr\[y\];

arr\[y\] = arr\[y+1\];

arr\[y+1\] = temp;

**折半查找。**提高效率，但是必须要保证该数组是有序的数组。

public static int halfSearch(int\[\] arr,int key)\{

int min = 0,max = arr.length—1,mid;

while(min<=max)\{

mid = (max+min)>>1; 　　 // (max+min)/2

if(key>arr\[mid\])

min = mid + 1;

else if(key<arr\[mid\])

max = mid — 1;

else

return mid;

return —1;

**进制转换 **查表法

十进制——>二进制

public static void toBinary (int num)\{

trans(num,1,1);

十进制——>八进制

public static void toOctal (int num)\{

trans(num,7,3);

十进制——>十六进制

public static void toHexadecimal (int num)\{

trans(num,15,4);

public static void trans(int num,int base,int offset)\{

if(num==0)\{

System.out.println(0);

return ;

char\[ \] chs = \{'0','1','2','3','4','5','6','7','8','9','A','B' ,'C','D','E','F'\};

char\[ \] arr = new char\[32\];

int pos = arr.length;

while(num!=0)\{

int temp = num & base;

arr\[——pos\] = chs\[temp\];

num = num >>> offset;

for(int x=pos; x<arr.length; x++)\{

System.out.print(arr\[x\]);

return ;

**二维数组**

格式1：int \[ \] \[ \] arr = new int \[3\] \[2\];

定义了名称为arr的二维数组

二维数组中有3个一维数组

每个一维数组中有2个元素

一维数组的名称分别为arr\[0\],arr\[1\],arr\[2\]

给第一个一维数组1角标位赋值为78写法是：arr\[0\]\[1\] = 78;

格式2： int \[ \] \[ \] arr = new int \[3\] \[ \];

二维数组中有3个一维数组

每个一维数组都是默认初始化值null

可以对这三个一维数组分别进行初始化

arr\[0\] = new int \[3\];

arr\[1\] = new int \[1\];

arr\[2\] = new int \[2\];

格式3：int\[\]\[\] arr = \{ \{3,8,2\},\{2,7\},\{9,0,1,6\}\};  
　　　　定义一个名称为arr的二维数组  
　　　　二维数组中的有三个一维数组  
　　　　每一个一维数组中具体元素也都已初始化  
　　　　第一个一维数组 arr\[0\] = \{3,8,2\};  
　　　　第二个一维数组 arr\[1\] = \{2,7\};  
　　　　第三个一维数组 arr\[2\] = \{9,0,1,6\};  
　　　　第三个一维数组的长度表示方式：arr\[2\].length;

特殊：

int\[ \] x,y\[ \]; x是一维数组，y是二维数组

数组脚标越界异常   (ArrayIndexOutOfBoundsException)

空指针异常　　　　(NullPointerException)

——————————  ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————

* 详细请查看：http://edu.csdn.net *

转载于:https://www.cnblogs.com/In-order-to-tomorrow/p/3528478.html