黑马程序员——java基础语法

------- android培训 、 java培训 、期待与您交流！ ----------

 

 

引言：要学习java必须先学习java的基础语法。

 

关键字 和标识符

1  什么叫关键字
被Java语言赋予了特殊含义的单词。
就是我们平时说的命令！
例如class就是一个关键字，它的用途是定义（声明、创建）一个类！
特点：都是小写的

 

2　标识符
自己起的一个名字！例如类名字！
标识符的组成：字母、数字、下划线、$。
标识符要求1 ：不能以数字开头。
标识符要求2：不能与关键字相同

Java中的名称规范：

包名：多单词组成时所有字母都小写。
?xxxyyyzzz
类名接口名：多单词组成时，所有单词的首字母大写。
?XxxYyyZzz
变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。
?xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接。
?XXX_YYY_ZZZ

       注释：
用于注解说明解释程序的文字就是注释。
提高了代码的阅读性。
Java中的注释格式：
?单行注释
?格式： //  注释文字
?多行注释
?格式： /*  注释文字  */
?文档注释
?格式：/** 注释文字 */

对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。
对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。

注释是一个程序员必须要具有的良好编程习惯。
初学者编写程序可以养成习惯：先写注释再写代码。
将自己的思想通过注释先整理出来，在用代码去体现。
因为代码仅仅是思想的一种体现形式而已。

常量和变量

 什么是常量？

常量表示不能改变的数值。
Java中常量的分类：

1，整数常量。所有整数

2，小数常量。所有小数

3，布尔(boolean)型常量。较为特有，只有两个数值。true false。

4，字符常量。将一个数字字母或者符号用单引号( ' ' )标识。

5，字符串常量。将一个或者多个字符用双引号(“ ”)标识。

6，null常量。只有一个数值就是:null.

 

       进制 ：
对于整数：有四种表现形式。
?二进制：0,1 ，满2进1.
?八进制：0-7 ，满8进1. 用0开头表示。
?十进制：0-9 ，满10进1.
?十六进制：0-9，A-F，满16进1. 用0x开头表示。

 
进制的基本转换：
?十进制  二进制 互转
?十进制转成二进制  除以2取余数
?二进制转成十进制  乘以2的幂数
?十进制 八进制 互转
?十进制 十六进制 互转
?负数的二进制表现形式
?对应的正数二进制取反加1

 什么是变量？
 
变量的概念：
?内存中的一个存储区域
?该区域有自己的名称（变量名）和类型（数据类型）
?该区域的数据可以在同一类型范围内不断变化
为什么要定义变量：
?用来不断的存放同一类型的常量，并可以重复使用
使用变量注意：
?变量的作用范围（一对{}之间有效） 
?初始化值
定义变量的格式：
?数据类型    变量名  =  初始化值；
?注：格式是固定的，记住格式，以不变应万变。
理解：变量就如同数学中的未知数。

　变量的类型
变量类型：基本类型和引用类型
基本类型：4类8种
? 整型：byte（字节型）、short（短整型）、int（整型）、long（长整型）
? 浮点型：float（浮点型）、double（双精度浮点型）
? 布尔型：boolean
? 字符型：char

  
自动类型转换（也叫隐式类型转换） 
强制类型转换（也叫显式类型转换）
类型转换的原理
什么时候要用强制类型转换?
表达式的数据类型自动提升
?所有的byte型、short型和char的值将被提升到int型。
?如果一个操作数是long型，计算结果就是long型；
?如果一个操作数是float型，计算结果就是float型；
?如果一个操作数是double型，计算结果就是double型。

   自动类型提升的例子：

byte b = 3;

int x = 4;

x = x + b;//b会自动提升为int类型进行运算。

强制类型转换的例子：

byte b = 3;

b = b + 4;  //报错

b = (byte)b+4;  //强制类型转换，强制将b+4的结果转换为byte类型，再赋值给b。

运算符：

 
算术运算符：

 
算术运算符的注意问题
?如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论。
?对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
?例如：int x=3510;x=x/1000*1000;  x的结果是？
?“+”除字符串相加功能外，还能把非字符串转换成字符串 ，
例如：System.out.println("5+5="+5+5);

赋值运算符： 
符号：
 = , +=, -=, *=, /=, %=
示例：

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

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

比较运算符：

 
逻辑运算符：

 
逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
“&”和“&&”的区别：
?单&时，左边无论真假，右边都进行运算；
?双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

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

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

位运算符：

 

 

 
三元运算符：

 
    格式
?(条件表达式)?表达式1：表达式2；
?如果条件为true，运算后的结果是表达式1；
?如果条件为false，运算后的结果是表达式2；
   示例：
?获取两个数中大数。
?int x=3,y=4,z;
?z = (x>y)?x:y;     //z变量存储的就是两个数的大数。

 

 

程序流程结构： 
判断结构：

if语句

三种格式：

1. if(条件表达式)

  {

  执行语句；

  }

2. if(条件表达式)

  {

  执行语句；

  }

  else

  {

  执行语句；

  }

 
3. if(条件表达式)

  {

  执行语句；

  }

  else if (条件表达式)

  {

  执行语句；

  }

  ……

  else

  {

  执行语句；

  }

 

if语句特点：

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

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

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

选择结构：

 

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结尾结束。

循环结构： 

代表语句：while ， do while ， for

 

while语句格式：

while(条件表达式)

{

  执行语句；

}

 

do while语句格式：

do

{

  执行语句；

}while(条件表达式);

do while特点：

是条件无论是否满足，

循环体至少执行一次。

 

for格式：

for(初始化表达式；循环条件表达式；循环后的操作表达式)

{

  执行语句；(循环体)

}

注：

     a,for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。

     b,while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。

     c,最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

 

其他流程控制语句：

break(跳出)，  continue(继续)

break语句：应用范围：选择结构和循环结构。

continue语句：应用于循环结构。

注：

a,这两个语句离开应用范围，存在是没有意义的。

b,这个两个语句单独存在下面都不可以有语句，因为执行不到。

c,continue语句是结束本次循环继续下次循环。

d,标号的出现，可以让这两个语句作用于指定的范围。

 

 

 

函数的定义：

 
什么是函数？
?函数就是定义在类中的具有特定功能的一段独立小程序。
?函数也称为方法。

 

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

  {

  执行语句;

  return 返回值;

  }

  返回值类型：函数运行后的结果的数据类型。

  参数类型：是形式参数的数据类型。

  形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

  实际参数：传递给形式参数的具体数值。

  return：用于结束函数。

  返回值：该函数运算的结果，该结果会返回给调用者。

 

函数的特点： 

定义函数可以将功能代码进行封装，便于对该功能进行复用。
函数只有被调用才会被执行。
函数的出现提高了代码的复用性。
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
注意：
?函数中只能调用函数，不可以在函数内部定义函数。
?定义函数时，函数的结果应该返回给调用者，交由调用者处理。

函数的应用：

两个明确
?明确要定义的功能最后的结果是什么？
?明确在定义该功能的过程中，是否需要未知内容参与运算

如何写函数：
? 确定需求：函数要完成什么功能
? 分析需求：确定函数的原型（返回值类型、函数名、参数列表）
? 思考算法：确定函数的执行逻辑（完成函数体内容）

示例：
?需求：定义一个功能，可以实现两个整数的加法运算。
?分析：
?该功能的运算结果是什么？两个数的和，也是一个整数(int)
?在实现该功能的过程中是否有未知内容参与运算？加数和被加数是不确定的。(两个参数int，int)
?代码：

  int  getSum(int x,int y)

  {

  return x+y;

  }

有参函数

1　 什么是有参函数（不明确的数据）
函数存在不明确的数据，这个数据应该由调用者来传递。
函数一旦指定的参数，那么这也是对调用者的一个要求。
如果调用者不提供参数，那么就无法调用。

2　形式参数的定义（形参列表）
一个函数可以有0 ~ n个参数，这个参数我们叫形式参数。
每个参数需要给出两样东西：参数类型 参数名称。
形参是需要赋值的，只看形参是不知道它的值是什么的。
int sum(int a, int b) – 函数的原型（函数的原型可以理解为函数的说明书）

3　调用有参数的函数
int sum(int a, int b)
? 调用有参数需要给形式参数赋值；
? 调用有参函数时提供的值就是实际参数

sum(100, 200);//其中100和200是分别赋值给a 和b的。100和200是实际参数（实参）

实际参数与形式参数的关系
每次调用都需要传递实际参数给形式参数
每次调用可以传递不同的实际参数给形式参数
同一个方法被多次调用，因为传递的实际参数不同，运算结果也就不同。

问题：是不是有参就必须有返回值呢？

思考：写一个函数，功能是打印指定个数和星星！其中指定个数就是由调用者指定个数（参数）。
　　形式参数 = 实际参数

　代码实现打印r行c列的矩形

 /*
 需求：指定指定行，指定列的一个矩形
 明确参数：int r -- 指定的行数
 明确参数：int c -- 指定的列数
 明确返回值类型：void，我们只是打印没有返回

 分析：

 */
 public static void printRectangle(int r, int c) { 
  for(int i = 0; i < r; i++) {
   for(int j = 0; j < c; j++) {
    System.out.print("*");
   }
   System.out.println();
  }
 }

 

变量名同名问题
? 在一个函数中，形参与局部变量同名是不可以的！
? 在不同函数中，可以定义相同名字的变量。

 

 

     数组的定义

1　什么叫数组
同一种类型数据的集合（容器）。
数组是塑料袋！
数组一旦创建，其长度不能改变！

2　什么叫数组元素
数组有下标（角标），用来访问数组中的元素。
a[0]是一个元素
a[1]是一个元素
数组下标从 0开始，到长度-1结束。

3　定义数组的语法
元素类型[] 数组名 = new 元素类型[长度];
int[] a = new int[10];

4　使用数组（使用数组元素）
　　使用下标来引用数组元素，下标从0开始以，到长度-1结束。

5　数组唯一属性（length）
数组变量.length
注意，后面没有圆括号

6　Java兼容了C++定义数组的语法
int a[] = new int[10];//不建议使用

 

数组最大的好处（与循环配合使用）
　　　　// 赋值操作
  int[] arr = new int[10];
  for(int i = 0; i < arr.length; i++) {
   // i 是长0 ~ 9
   arr[i] = i + 100;
  }
  // 获取操作
for(int i = 0; i < arr.length; i++) {
   System.out.println("arr[" + i + "] = " + arr[i]);
  }

求和（练习）
　　把数组中所有的元素相加！
  /*
  定义一个变量，用来装载和
  */
  int sum = 0;
  for(int i = 0; i < arr.length; i++) {
   sum = sum + arr[i];//arr[0] ~ arr[8];
  }
  System.out.println("sum = " + sum);

　数组其他定义方式
int[] arr = new int[10];
int[] arr = new int[]{1,2,3,4,5,6,7,8,9};
int[] arr = {1,2,3,4,5,6,7,8,9};
其中最后一种，只能定义数组的同时完成初始化！

 

 

 数组操作常见问题：

  数组脚标越界异常(ArrayIndexOutOfBoundsException) ：

int[] arr = new int[2];

System.out.println(arr[3]);

访问到了数组中的不存在的脚标时发生。

  空指针异常： 

int[] arr = null;

System.out.println(arr[0]);

arr引用没有指向实体，却在操作实体中的元素时。

 

数组的常见操作： 
获取最值(最大值，最小值) 
　求数组中的最值:

/*          需求：求指定数组中最大值          明确参数：int[] arr -- 指定的数组          明确返回值：int -- 最大值          分析：以打擂的方式来找到最大值          1 让arr[0]上擂台，即max = arr[0]          2 循环遍历arr[1] ~ arr[length-1]          3 让max上的值与其他元素进行比较          4 如果其它元素大于max上的值，那么让这个值上擂台，即max = arr[x];            */          public static int max(int[] arr) {                    /*                    int max = arr[0];//让max这个擂台上站着下标0的元素.                    让max 与 1 ~ arr.length - 1进行比较，谁胜谁上擂台。即max = 谁                    最后max一定是最大的                    */                      int max = arr[0];//让arr[0]先上擂台                    for(int i = 1; i < arr.length; i++) {                             if(max < arr[i]) {//打擂过程, max上的值是擂主，arr[i]是挑战者，如果挑战者胜，那么max = 挑战者，即新的擂主                                      max = arr[i];                             }                    }          }

排序（选择排序，冒泡排序）:

        冒泡排序

        */

 

        public static void bubbleSort(int[] arr)

        {

               for(int x=0; x<arr.length-1; x++)

               {                                                                   

                       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;

                               }

                       }

               }

        }

折半查找(二分查找)  :不一一写代码了。

二维数组  ： 

格式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的二维数组
二维数组中有3个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;

注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。