java第二章_Java第二章基本语法

二、基本语法

2.1关键字&标识符

2.1.1关键字的定义和特点

>定义：被java语言赋予了特殊含义，用作专门用途的字符串(单词)

>特点：关键字中所有字母都为小写

<1>用于定义数据类型的关键字

class　　interface　　enum　　byte　　short　　int　　long

float　　 double　　    char　　 boolean   　　　   void

<2>用于定义数据类型值的关键字

true　　false　　null

<3>用于定义流程控制的关键字

if　　else　　switch　　case　　default　　while　　do　　for　　break

continue　　return

<4>用于定义访问权限修饰符的关键字

private　　protected　　public

<5>用于定义类、函数、变量的修饰符关键字

abstract　　final　　static　　synchronized

<6>用于定义类与类之间关系的关键字

extends　　implements

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

new　　this　　super　　instanceof

<8>用于异常处理的关键字

try　　catch　　finally　　throw　　throws

<9>用于包的关键字

package　　import

<10>其他修饰符关键字

native　　strictfp　　transient　　volatile　　assert

保留字

java保留字：现有的Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字

byValue　　cast　　future　　generic　　inner　　operator　　outer　　rest　　var　　goto　　const

2.1.2标识符

>Java对各种变量、方法、类等要素命名时使用的字符序列称为标识符。

>凡是自己可以起名的地方都叫标识符。

2.1.2.1定义合法标识符规则：

>由26个英文字母大小写，0-9，_或$组成

>数字不可以开头

>不可使用关键字和保留字，但能包括关键字和保留字。

>Java中严格区分大小写，长度无限制

>标识符不能包含空格

注意：在起名时，为了提高阅读性，要尽量有意义，“见名知意”。

2.1.2.2Java中的名称命名规范

包名：　　　　　　多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：　　多单词组成，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：　多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

常量名：　　　　　所有字母都大写。多单词时每个单词用下划线连接：xxx_YYY_ZZZ

2.2变量

2.2.1数据类型

数据类型：　　　　基本数据类型：数值型：整数类型(byte,short,int,long)

浮点类型(float,double)

字符型(char)

布尔型(boolean)

引用数据类型：类(class)

接口(interface)

数组([ ])

java的整形变量默认为int，声明long型常量须后加“l”或“L”

java的浮点型常量默认为double型。声明float型常量，须后加“f”或“F”

类型　　　　　　占有存储空间　　　　表数范围

byte　　　　　　1字节 = 8bit　　　　-128~127

short　　　　　  2字节　　　　　　　-2^15~2^15-1

int　　　　　　　4字节　　　　　　　-2^31~2^31-1

long　　　　　　8字节　　　　　　　-2^63~2^63-1

单精度float　　　　4字节　　　　　　　-3.403E38~3.403E38

双精度double　　　8字节　　　　　　　-1.798E308~1.798E308

浮点类型有两种表现形式：

>十进制数形式：如5.12　　512.0f　　.512(必须有小数点)

>科学记数法形式：如：5.12e2　　512E2　　100E-2

转义字符

\b　　退格符

\n　　换行符

\r　　回车符

\t　　制表符

\"　　双引符

\'　　单引号

\\　　反斜线

注意：Boolean类型：只能取值true或false。不能取null

2.2.2类型转换

自动类型转换：

当容量小的数据类型与容量大的数据类型作运算时，容量小的会自动转换为容量大的数据类型：

char、byte、short==>int==>long==>float==>double

注意：当char/byte/short之间作运算时，默认的结果为int类型

强制类型转换：

当容量大的数据类型转换为容量小的数据类型，要使用强制类型转换符:()

int a;

short b = (short)a;

缺点：导致精度的损失

long　　l1 = 12345L;

int　　m1 = (int)l1;//12345

byte　　by1 = (byte)m1;//57

0000　　0000　　0000　　0000　　0011　　0000　|　0011　　1001

string和基本数据类型之间的运算只能通过：+

2.3进制

二进制：0，1，满2进1，以Ob或OB开头。

十进制：0-9，满10进1。

八进制：0-7，满8进1，以数字0开头表示。

十六进制：0-9及A-F，满16进1，以Ox或OX开头表示，此处的A-F不区分大小写。

正数：三码合一

负数：

原码：二进制编码

反码：除符号位外各个位取反

补码：反码+1

在底层是以补码进行存储

/* 符号位

* 0代表正数

* 1代表负数

* 十进制：57

* 二进制：111001(原码)

*

* 57/2=28……1

* 28/2=14……0

* 14/2=7……0

* 7/2=3……1

* 3/2=1……1

* 1/2=0……1

2.4运算符

1.测试运算符：

+　　-　　*　　/　　%　　++　　--

取模：%取余数，结果符号取决于被模数。 int i1 = -12 % 5 //-2

前++： 先自增1，后做运算

后++：先做运算，后自增1

2.赋值运算符

+=　　-=　　*=　　/=　　%=

s+=1 既可以实现运算，也不会改变数据类型

3.比较运算符

==　　！=　　　　<=　　>=

instanceof　　检查是否是类的对象

4.逻辑运算符

&-逻辑与　　&&-短路与　　|-逻辑或　　||-短路或　　！-逻辑非　　^-逻辑异或

5.位运算符

<>　　>>>　　|　　&　　~

<<:>

>>:向右移动(正数用0补位，负数用1补位)

>>>:向右移动(正负数用0补位)

A = 0011 1100

B = 0000 1101

A | B = 0011 1101

A & B = 0000 1100

A ^ B = 0011 0001

~A = 1100 0011

交换两个数：

方式一：提供一个临时变量。

int　temp　=　m;

m = n;

n = temp;

方式二：当m和n较大时，有可能出现精度损失

m = m + n;

n = m - n;

m = m - n;

方式三：

m = m ^ n;

n = m ^ n;

m = m ^ n;

int m =10;

int n= 20;

int z = m^n;//30 二进制运算-异或

int o = z^n;//10

int q = z^o;//20//可用于交换两个数

三目运算符：

定义：　　>(条件表达式)？表达式1：表达式2：

true：运算后的结果是表达式1

false：运算后的结果是表达式2

运算符优先级：

2.5程序流程控制

顺序结构         分支结构　　　　循环结构

顺序结构：

分支结构： if……else　　switch

循环结构：while　　do……while　　for

注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素

2.6数组

一维数组：

初始化：

静态初始化：names = new String[]{"周爽","Guo","Yulong"};

动态初始化：int[] score = new int[3];

score[0] = 87;

score[1] = 89;

score[2] = 98;

基础数据类型的默认值：

byte、short、int、long创建数组后，默认值为0

float、double创建数组后，默认值为0

char创建数组后，默认值为空格

boolean创建数组后，默认值为false

引用类型的变量构成的数组，默认初始化为null，以String为例。

数组一旦初始化，其长度是不可变的(.length)

一维数组在内存中的结构：

二维数组：

初始化：

int[][] res = new int[5][];

int[][] res1 = new int[][]{};

int[] res2[] = new int[5][];

二维数组在内存中的结构：

数组常见的异常：

1.数组下标越界的异常

java.lang.ArrayIndexOutOfBoundsException:int[] a = new int[5];

for(int i=0;i<=a.length;i++){

System.out.println(a[i]);

}

2.空指针异常

java.lang.NullPointerException

int[] a = new int[5];

a = null;

System.out.println(a[1]);

数组的常用算法：

1.最大值，最小值，总值，平均值

1 @Test

2 public void test1(){

3 int[] a = new int[10];

4 Scanner sc = new Scanner(System.in);

5 for(int i=0 ; i < a.length ; i++){

6 a[i] = sc.nextInt();

7 }

8 int max = 0;

9 int min = a[0];

10 int sum = 0;

11 int avg = 0;

12 //最大值

13 for(int i=0 ; i < a.length ; i++){

14 if(a[i] > max){

15 max = a[i];

16 }

17 }

18 System.out.println(max);

19 //最小值

20 for(int i=0 ; i < a.length ; i++){

21 if(a[i] < min){

22 min = a[i];

23 }

24 }

25 System.out.println(min);

26 //总和

27 for(int i=0 ; i < a.length ; i++){

28 sum += a[i];

29 }

30 System.out.println(sum);

31 //平均值

32 System.out.println((sum/a.length));

33 }

2.数组复制

1 int[] arry1 = new int[]{1,2,3,4,5,6,7,8,9};

2 int[] arry2 = new int[arry1.length];

3 for(int i = 0; i

4 arry2[i] = arry1[i];

5 }

6 for(int i = 0;i

7 System.out.println(arry2[i]);

8 }

9

10 //如果直接用arry2 = arry1 即两个栈空间变量名指向一个堆空间地址的数组

11 //若改变一个值两个数组中对应的值都会改变

3.数组元素的反转

1 int[] arry = new int[]{1,2,3,4,5,6,7,8,9};

2 for(int i = 0;i

3 int temp = arry[i];

4 arry[i] = arry[arry.length-i-1];

5 arry[arry.length-i-1] = temp;

6 }

7 for(int i = 0;i

8 System.out.println(arry[i]);

9 }

4.遍历

1 int[] arry = new int[]{1,2,3,4,5,6,7,8,9};

2 for(int i = 0;i

3 System.out.println(arry[i]);

4 }

数组排序：

1.插入序列：

1.1直接插入排序：

个人理解：数组中第一个元素，直接与后面的元素进行比较，将后面比他小的与他交换，这样第一次排序，直接找出最小的插入到第一个位置，后面的排序依照第一个的操作。

从小到大排序

方法：Arrays.sort(res);

1.2折半插入排序：

1.3Shell排序：

2.交换排序

2.1冒泡排序：

个人理解：

第一次排序，每连续两个元素进行比较，将最大的排到最后，

第二次排序，不用运算最后一个位置的操作，把相对大的排到倒数第二个位置。

……

从小到大排序：

2.2快速排序(分区交换排序)

3.选择排序

3.1简单选择排序

3.2堆排序

4.归并排序

5.基数排序

2.7内存的基本结构