Java 语法基础

 黑马程序员

---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ ----------------------

 

一.   函数

1.      函数的定义

函数就是一段有名字的代码，可以完成某一特定功能。

如果有一段代码要使用多次，我们可以给它起个名字，每次使用时通过名字调用，这样就不用每次都写一大段代码了。

如果某个函数在执行的时候需要调用者传入数据，那么可以定义参数列表，用于接收数据。

如果函数运行之后需要返回给调用者数据，那么需要指定返回值类型，并且用关键字return返回。

定义函数的3个必要条件：函数名、参数列表、返回值类型。如果不需要参数也要写小括号，如果没有返回值类型要写void。

函数就是定义在类中的具有特定功能的一段独立小程序。

函数也称为方法。

2.      函数的格式：

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…)

{

执行语句;

return 返回值;

}

 

 

3.   名词解释

形参：在定义函数时小括号中的参数，用来接收数据的参数。

实参：在调用函数时真正传入的参数，传递给函数的数据。

参数类型：函数的参数的类型，一旦定义传入时必须匹配。

返回值：函数运行结束后返回的值，使用return关键字返回。

返回值类型：函数运行结束后返回的值的类型，在类型非void情况下必须返回，而且必须类型匹配。

return：用于结束函数。

4。函数的特点

定义函数可以将功能代码进行封装

便于对该功能进行复用

函数只有被调用才会被执行

函数的出现提高了代码的复用性

对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

注意：

•函数中只能调用函数，不可以在函数内部定义函数。

•定义函数时，函数的结果应该返回给调用者，交由调用者处理。

 

5.函数的应用

两个明确

•明确要定义的功能最后的结果是什么？

•明确在定义该功能的过程中，是否需要未知内容参与运算

示例：

•需求：定义一个功能，可以实现两个整数的加法运算。

•分析：

•该功能的运算结果是什么？两个数的和，也是一个整数(int)

•在实现该功能的过程中是否有未知内容参与运算？加数和被加数是不确定的。(两个参数int，int)

•代码：

int  getSum(int x,int y)

{

return x+y;

}

 

6.   函数的重载

重载的概念

多个函数的函数名相同，参数列表不同（个数、顺序、类型），这就是函数的重载。在调用函数的时候通过传入的实参找到匹配的函数调用。

重载的特点：

函数的重载和返回值类型无关，只看参数列表。

重载的好处：

方便于阅读，优化了程序设计。

 

重载示例：

//返回两个整数的和

  int add(int x,int y){return x+y;}

//返回三个整数的和

  int add(int x,int y,int z){return x+y+z;}

//返回两个小数的和

  double add(double x,double y){return x+y;}

 

 

二.   运算符

 1.  算数运算符

 

加号：在操作数字、字符、字符串时是不同的，两个字符相加得到的是码表值，两个字符串相加是将字符串连接在一起。

除号：整数在使用除号操作时，得到的结果仍为整数（小数部分忽略）。

取模：模数的符号忽略不计，结果的正负取决于被模数。

自增：符号在前就是先运算后取值，符号在后则是先取值后运算。

 

算术运算符的注意问题

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论。

对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。

例如：int x=3510;x=x/1000*1000;  x的结果是？

“+”除字符串相加功能外，还能把非字符串转换成字符串 ，

例如：System.out.println("5+5="+5+5);//打印结果是？

5+5=55

例如：System.out.println(3500 / 1000 * 1000);

输出结果是  3000

 

2. 赋值运算符

符号：

= , +=, -=, *=, /=, %=

 

等于：可以多个连用，例如：x = y = z = 5;

面试题：

       以下代码正确的是? (多选) a  c   d

a.       byte b = 1 + 1;

b.       byte b = 1;    b = b + 1;

c.       byte b = 1;    b += 1;

d.       byte b = 1;    b = ++b;

 

示例：

int a,b,c;  a=b=c =3;

int a = 3;   a+=5;等同运算a=a+5;

思考：

short s = 3;

s=s+2;

s+=2;    

有什么区别？     
s  =  s +2；   

 编译失败，因为s会被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。

 

s +=2 ；

编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。

 

 

3： 比较运算符

 

 

注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false。

注2：比较运算符“==”不能误写成“=” 。

 

4.    逻辑运算符

逻辑运算符运行结束之后返回的也是boolean值

&           两边都为true结果才为true，只要有一边是false，结果就是false

|             两边都为false结果才为false，只要有一边是true，结果就是true

^             判断两边是否不同，不同则为true，相同则为false

!             取反，!true结果是false，!fasle结果是true

&&         和&结果相同，具有短路效果，如果前半是false，表达式结果一定为false，不运行后一半

||             和||结果相同，具有短路效果，如果前半是true，表达式结果一定为true，不运行后一半

分析以下程序运行结果：

int x = 1;

int y = 2;

System.out.println(x++ == y & ++x > y++);

false

System.out.println(x);

x = 3

System.out.println(y);

y  = 3  

 

 

int x = 1;

int y = 2;

System.out.println(x++ == y && ++x > y++);

false

System.out.println(x);

x = 2

System.out.println(y);

 y =2

 

 

int x = 1;

int y = 2;

System.out.println(x++ == y | ++x > y++);

true

System.out.println(x);

x = 3

System.out.println(y);

 y = 3

 

 

int x = 1;

int y = 2;

System.out.println(x++ == y || ++x > y++);

true

System.out.println(x);

x = 3

System.out.println(y);

 y = 3

 

&& 在前半是false的时候短路

|| 在前半是true的时候短路

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

“&”和“&&”的区别：

单&时，左边无论真假，右边都进行运算；

双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。

异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。

 

 

5.  位运算符

 

任何信息在计算机中都是以二进制的形式保存的，&、|、^除了可以作为逻辑运算符，也可以做为位算符。

它们对两个操作数中的每一个二进制位都进行运算，0当做false，1当做true。

 

&    将两个二进制数每一位进行&运算，两边都为1结果才为1，只要有一边是0，结果就为0。

|      将两个二进制数每一位进行|运算，两边都为0结果才为0，只要有一边是1，结果就为1。

^      将两个二进制数每一位进行^运算，只要两边不同结果就为1，相同则为0。

 

我们可以对数据按二进制位进行移位操作，java的移位运算符有三种：

<<          左移                     将二进制的每一位向左移，低位补0。左移几位就相当于乘以2的几次方。

>>          右移                     将二进制的每一位向右移，原来高位是0就补0，原来高位是1就补1。右移几位就相当于除以2的几次方。

>>>        无无符号右移       将二进制的每一位向右移，高位补0。正数移动没区别，负数移动后变为正数。

 

练习：

a.       用&和>>来做十进制转十六进制

class OperateDemo3
{
 public static void main(String[] args)
 {

  //System.out.println(Integer.toBinaryString(60));
  //System.out.println(Integer.toHexString(60));
  
  int num = 26;

  //获取60的最低4位，通过&15;
  int n1 = num & 15;

  System.out.println(n1>9?(char)(n1-10+'A'):n1);

  //要获取下一组四位，将60右移4位。
  int temp = num >>> 4;

  //对temp的值进行最低四位的获取。
  int n2 = temp & 15;
  System.out.println(n2>9?(char)(n2-10+'A'):n2);

  /*
  0-9 'A' 'B' 'C' 'D' 'E' 'F'
   65   66  67
   10   11  12  13  14  15

   12 - 10 = 2 + 'A' = (char)67;
  */

  int x = 1,y;

  y = (x>1)?'a':200;
  System.out.println("y="+y);
 }
}

 

b.       有两个int型变量a和b，在不使用第三个变量的情况下交换两个变量中的值

public class Demo {

 public static void main(String[] args) {
  int a = 6;
  int b = 8;
  b =a^b;
  a =a^b;
  b =a^b;
 System.out.println( a );
 System.out.println(b);
 }
}

 

思考一下代码运行结果：

 System.out.println(1 + 2 * 3);               

 

System.out.println(false &&true ||true);      

System.out.println(true ||true &&false);

int a = 2;

int b = a + 3 * a++;

System.out.println(b);

int a = 2;

int b = a++ + 3 * a;

System.out.println(b);

int a = 1;

int b = 2;

System.out.println(a+++b);

尽量写简单的表达式，遇到运算符优先级的问题使用括号解决。

 

 

6.   语句

  顺序结构

顾名思义，就是程序从上到下一行一行执行的结构，中间没有判断和跳转，直到程序结束。

 选择结构

程序具备多个分支，通过条件判断决定程序选择那一条分支执行

 

a．  if语句：

通过if...else if...else决定程序流程。

如果if中的条件满足则执行其中语句，if未满足则继续判断else if，如果满足则执行，不满足继续判断下一个else if，如果所有都不满足，则执行else。

if语句特点：

a,每一种格式都是单条语句。

b,第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是：可以写在其他表达式中。

c,条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false;

 

练习：

需求1：根据用户定义的数值不同。打印对应的星期英文。

class IfTest
{
 public static void main(String[] args) {
  int num = 1;

  if(num==1)
   System.out.println("monday");
  else if(num==2)
   System.out.println("tsd");
  else
   System.out.println("nono");

   }

}

需求2：根据用于指定月份，打印该月份所属的季节。
  //3,4,5 春季 6,7,8 夏季  9,10,11 秋季 12, 1, 2 冬季

class IfTest
{
 public static void main(String[] args) {

   int x = 4;

  if(x==3 || x==4 || x==5)
   System.out.println(x+"春季");
  else if(x==6 || x==7 || x==8)
   System.out.println(x+"夏季");
  else if(x==9 || x==10 || x==11)
   System.out.println(x+"秋季");
  else if(x==12 || x==1 || x==2)
   System.out.println(x+"冬季");
  else
   System.out.println(x+"月份不存在");

  if(x>12 || x<1)
   System.out.println(x+"月份不存在");
  else if(x>=3 && x<=5)
   System.out.println(x+"春季");
  else if(x>=6 && x<=8)
   System.out.println(x+"夏季");
  else if(x>=9 && x<=11)
   System.out.println(x+"秋季");
  else
   System.out.println(x+"冬季");

  }
}

 

 

b．  switch语句：

格式：

switch(表达式)

{

case 取值1:

执行语句；

break；

case 取值2:

执行语句；

break；

…...

default:

执行语句；

break；

}

switch语句特点：

a,switch语句选择的类型只有四种：byte，short，int ， char。

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

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

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

 

 //需求2：根据用于指定月份，打印该月份所属的季节。
  //3,4,5 春季 6,7,8 夏季  9,10,11 秋季 12, 1, 2 冬季

class  SwitchTest
{
 public static void main(String[] args)
 {

  int x = 4;

  switch(x)
  {
   case 3:
   case 4:
   case 5:
    System.out.println(x+"春季");
    break;
   
   case 6:
   case 7:
   case 8:
    System.out.println(x+"夏季");
    break;
   case 9:
   case 10:
   case 11:
    System.out.println(x+"秋季");
    break;
   case 12:
   case 1:
   case 2:
    System.out.println(x+"冬季");
    break;
   default:
    System.out.println("nono");

  }

  /*
  if和switch语句很像。
  具体什么场景下，应用哪个语句呢？
  如果判断的具体数值不多，而是符合byte short int char这四种类型。
  虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。

  其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

  */
  System.out.println("Hello World!");
 }
}

 

c．  三元运算符

语法：表达式 ? 结果1 : 结果2

如果表达式结尾为true取结果1，为false则取结果2。

注意三元运算符也是有短路的效果，根据表达式的结果，只运行冒号一边的，另外一边的不参与运行。

 

示例：

获取两个数中大数。

int x=3,y=4,z;

z = (x>y)?x:y;//z变量存储的就是两个数的大数。

 

 循环结构

通过循环语句让同一段代码反复执行多次，执行完毕程序才会继续往后运行

 

 

a．  while

先判断while中的表达式结果是否为true，true则执行循环体，执行结束之后再次判断，如果表达式结果为false则跳出循环。

练习：

        打印出0-9

  int i = 0;
  while(true){
   System.out.println(i);
   if(i==9){
    break;
    }
    i=i+1;
  }

 

 b．  do...while

先执行一次循环体，然后判断while中的表达式，如果是true继续执行，如果是false则跳出循环。

do while语句格式：

do

{

执行语句；

}while(条件表达式);

 

练习：

public class WhileTest2 {
 public static void main(String[] args){
  int i = 2;
  do {
   System.out.println(i);
   i=i+2;
  }while(i<=100);
  
  int a = 10;
  while(a>100){
   System.out.println("while do : a大于100");
  }
  do{
   System.out.println("do while : a大于100");
  }while(a>100);
  
  while(a>5);//{
   System.out.println("ok");
  //}
   System.out.println("ok2");
 } 
}

do while特点是条件无论是否满足，

循环体至少被执行一次。

 

 

 

c．  for

for循环的括号中有三条语句，都是可选项。

语句1：这条语句会在整个循环开始之前执行，且仅运行一次，不参与循环。

语句2：必须是一个返回boolean值的表达式，如果写了这个语句那么每次循环开始之前会判断，true则执行循环，false则不执行。没写则直接执行。

语句3：这条语句在每次循环体运行结束之后执行。

练习：

       使用星号打印如下图案

 

*****

*****

*****

*****

 

public class test1 {

 public static void main(String[] args) {
  for (int x = 0; x < 5; x++) {

   for (int y = 0; y < 5; y++)

   {

    System.out.print( "*" );

   }
   System.out.println();
  }

 }

}

 

 

                     i             *

*                   0            1

**                  1            2

***                2            3

****              3            4

*****            4            5

 

public class test2{

 public static void main(String[] args) {
  for (int x = 0; x < 6; x++) {

   for (int y = 0; y < x; y++)

   {

    System.out.print( "*" );

   }
   System.out.println();
  }

 }

}

 

 

d．  continue、break、return

continue：跳过一次循环，继续执行下一次

break：结束循环

return：结束方法

 

 

 

7: 数组

 

 

   什么是数组

数组是一个类型一致，长度不可变的容器。可以通过索引操作容器中的每一个元素。

如果有多个类型相同的数据需要存储，我们就可以将其定义为一个数组，这样做省去了创建多个变量的麻烦。

   如何定义数组

int[] arr = {1,2,3};

定义int数组arr，长度为3，其中3个元素分别为1、2、3。这种方式只能在定义数组的时候使用。

 

int[] arr = new int[]{1,2,3};

定义int数组arr，长度为3，其中3个元素分别为1、2、3。可以再任何情况使用。

 

int[] arr = new int[3];

定义int数组arr，长度为3。其中所有元素都为默认值0。

  访问数组元素、遍历数组

存在数组中的数据是有索引的，从0开始递增，我们通过数组名和索引就可以操作其中每一个元素。例如：

       System.out.println(arr[0]);           // 打印数组中索引为0的元素

       arr[1] = 100;          // 给数组中索引为1的元素赋值为100

 

数组的长度

       数组可以使用length属性获取其长度。

 

遍历数组

       由于数组可以通过索引获取每一个元素，又可以通过length获取长度，那么我们就可以定义循环来遍历数组中的每一个元素了。

    使用数组时的异常

如果访问数组时索引越界（小于0或者大于length-1），会抛出异常：ArrayIndexOutOfBoundsExcepion

如果访问数组的引用为空(null)，会抛出空指针异常：NullPointerException

 

数组练习

class ArrayDemo1 {
 
 public static void main(String[] args){
  int[] arr = {200, 500, 10, 20}; 
  
  // System.out.println(arr.length);  // 数组的长度
  
  // 遍历数组中的所有元素
  for(int i = 0; i < arr.length; i++)
   System.out.println(arr[i]);
   
  // 数组的索引值是从0到length-1, 访问其他索引会抛出ArrayIndexOutputBoundsException
  // System.out.println(arr[-1]);
  
  // 当数组为null的时候, 访问其元素时会抛出NullPointerException
  // arr = null;
  // System.out.println(arr[0]);
  
  System.out.println(arr[0]);
  
  arr[0] = 1;
 }
}

 

class ArrayTest2 {
 
 public static void main(String[] args){
  int[] arr = {200, 500, 10, 20}; 
  
  swap(arr, 0, 1);  // 交换该数组中的0号和1号
  
  ArrayTest1.print(arr); // 调用ArrayTest1中的方法, 打印当前数组中的内容
 }
 
 // 该方法可以交换数组中的两个元素
 // arr 要交换的数组
 // pos1 要交换的元素的位置
 // pos2 要交换的元素的另一个位置
 static void swap(int[] arr, int pos1, int pos2){
  int temp = arr[pos1];  // 记住其中1个位置上的值
  arr[pos1] = arr[pos2];  // 被记住的位置赋值为另一个
  arr[pos2] = temp;   // 另一个位置赋值为被记住的值
  
  // arr[pos1] = arr[pos2] + (arr[pos2] = arr[pos1]) - arr[pos1];  // 可读性不高. 效率
 }
}

 

 

    与数组操作相关函数

Arrays.toString() 查找帮助文档Arrays类，学习使用此方法将字符串转为字符串形式。

       将一个数组转为字符串表示形式

System.arraycopy() 查找帮助文档System类，学习使用此方法拷贝数组中元素。

       将一个数组中的某些元素拷贝到另一个数组的指定位置

     多维数组

数组中的每一个元素都是数组，这样的数组就是多维数组。

 

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

定义二维数组arr, 其中有三个元素都是数组, 第一个数组3个元素, 第二个2个元素, 第三个4个元素.

 

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

定义二维数组arr, 其中有三个元素都是数组, 第一个数组3个元素, 第二个2个元素, 第三个4个元素.

 

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

定义二维数组arr, 其中有三个元素都是数组, 每个小数组都是3个元素.

 

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

定义二维数组arr, 其中有三个元素都是数组, 每个小数组元素个数不确定.

 

 

class ArrayTest3 {
 
 public static void main(String[] args){
  int[] arr1 = {-20, 200, 500, 10, 20, 600, -800}; 
  int[] arr2 = {-20, 200, 500, 10, 20, 600, 800}; 
  
  int max1 = findMax(arr1);
  int max2 = findMax(arr2);
  
  // 2个数组最大数的和
  System.out.println("最大数的和为: " + (max1 + max2));
 }
 
 // 找到数组中的最大数返回
 static int findMax(int[] arr){
  // 先定义一个变量, 用来记住最大数, 开始时记住第一个
  int max = arr[0];
  // 循环遍历数组, 用max记住的值和数组中的元素逐一比较, 如果数组中的值大于max, max就记住这个值
  for(int i = 1; i < arr.length; i++)
   if(arr[i] > max)
    max = arr[i];
  // 循环结束之后, max记住的就是最大数
  return max;
 }
 
}

 

class ArrayTest4 {
 
 public static void main(String[] args){
  int[] arr = {-20, 200, 500, 10, 20, 600, -800};  //  -800, 600, 20 .....
  reverse1(arr);
  ArrayTest1.print(arr);  // 调用之前写好的打印方法
  
 }
 
 // 将第一个和最后一个交换, 第二个和倒数第二个交换, 依此类推. 
 static void reverse(int[] arr){
  for(int i = 0; i < arr.length / 2; i++)
   ArrayTest2.swap(arr, i, arr.length - 1 - i);  // 调用之前写好的交换方法
 }
 
 // 0  6
 // 1  5
 // 2  4
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

------------ <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ -----------