java语言基础组成

自闭症网瘾萝莉.ら 提交于 2020-03-23 10:33:09
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)


出处:http://www.cnblogs.com/In-order-to-tomorrow/p/3528478.html

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!