Java根蒂根基常识
目次
一 Java概述
1.课程中常见的dos号令行号令
2.Java说话的三种技巧架构
3.Java说话的景象搭建
4.第一个Hello World小法度
二 Java说话根蒂根基
1.关键字
2.标识符
3.注释
4.常量和变量
5.运算符
6.语句（法度流程把握）
7.函数
8.数组

属性景象变量。在体系变量里找到并编辑path景象变量，在变量值开端处加上java对象地点目次（D:    \jdk1.7.0_21\bin），后面用“;”和其他值分隔开即可。
  办法二：姑且设备体式格式
   经由过程dos号令中set号令完成。打开dos号令行属性景象变量。在体系变量选项卡里点击新建，变量名为classpath，变量值为class文件路径
  办法二：姑且设备体式格式
   经由过程dos号令中set号令完成。打开dos号令行—set classpath= class文件路径（如set classpath=D:\myclass）
  重视：
   path和classpath的姑且设备体式格式都是只在当前dos窗口有效。窗口封闭，设备消散。
 （3）path和classpath的差别：
  path变量值是windows法度文件的目次。windows体系先在当前目次下找当前履行的法度，若是没有再去体系中已有的一个名为path的景象变   量指定的路径下找，若是都没有就会呈现错误提示。
  classpath变量值是java类文件的目次。若是没有设备classpath景象变量，JVM只在当前目次下找要运行的类文件；若是设备了classpath环   境变量，JVM会先在classpath路径下找（结尾没有分号，只在classpath路径下找；结尾有分号，先在classpath路径下找，若是没有再去当   前目次下找）。
  建议：
   在设备classpath景象变量时，值的结尾处不要加分号，若是须要接见当前目次可以用“.”默示。
4．第一个Hello World小法度
 步调：
  1．经由过程class关键字定义一个类。将代码都编写到该类中。
  2．为了包管该的自力运行。在类中定义一个主函数。格局 public static void main（String[] args）
  3．保存成一个扩大名为java的文件。
  4．在dos把握台中经由过程javac对象对java文件进行编译。
  5．在经由过程java号令对生成的class文件进行履行。
 代码
  class Demo//定义一个类。
  {
   //主函数。
   public static void main（String[] args）
   {
    //输出语句。
    System.out.println（Hello World）;
   }
  }
  main函数可以包管该类的自力运行。main不是关键字，但它是法度的进口，会被JVM所辨认和调用。
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
二 Java说话根蒂根基
 Java说话根蒂根基构成
  关键字，标识符，注释，常量和变量，运算符，语句，函数和数组。
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，符号_ ￥ 构成
 定义合法标识符规矩：
  1.数字不成以开首。
  2.不成以应用关键字。
 Java中的名称规范：
  包名：  多单词构成时所有字母都小写。xxxyyyzzz
  类名接口名： 多单词构成时，所有单词的首字母大写。XxxYyyZzz
  变量名和函数名： 多单词构成时，第一个单词首字母小写，第二个单词开端每个单词首字母大写。xxxYyyZzz
  常量名：  所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ
3.注释
 定义：
  用于注申明注解明申明法度的文字
 Java中的注释格局：
  单行注释格局： //注释文字
  多行注释格局： /  注释文字  /
  文档注释格局：/ 注释文字 /
  对于单行和多行注释，被注释的文字，不会被JVM履行。对于文档注释，是Java特有的注释，此中注释内容可以被JDK供给的对象javadoc所   解析，生 成一套以网页文件情势表现的该法度的申明文档。
 注释的感化：
  增长浏览性；
  调试法度。
 重视：
  单行注释和多行注释中可以参加单行注释，多行注释中不克不及参加多行注释。 
4.常量和变量
 （1）常量
  定义：
   常量默示不克不及改变的数值
  Java中常量的分类：
   1.整数常量 : 所有整数
   2.小数常量 : 所有小数
   3.布尔型常量 : 较为特有，只有两个数值。true false
   4.字符常量 : 将一个数字字母或者符号用单引号标识
   5.字符串常量 : 将一个或者多个字符用双引号标识
   6.null常量 : 只有一个数值就是:null.
  对于整数：Java有四种发挥解析情势：
   二进制  : 0-1 ，满2进1。
   十进制  : 0-9 ，满10进1。
   八进制  : 0-7 ，满8进1。用0开首默示。三个二进制位代表一个八进制位。
   十六进制 : 0-9，A-F，满16进1. 用0 x开首默示。四个二进制位代表一个十六进制位。
  进制的根蒂根基转换
   十进制和二进制之间的转换
   十进制转成二进制  除以2取余数；二进制转成十进制  乘以2的幂数
   其它进制之间的转换
   给出的进制转换为二进制，再将二进制转换为所需进制
  负数的二进制发挥解析情势
   相反数的二进制取反加1
 （2）变量
  变量的概念：
   变量是内存中的一个存储区域，该区域有本身的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型局限内络续变更
  定义变量的格局：
   数据类型 变量名=初始化值；
  ◆◆【数据类型】◆◆
   Java说话是强类型说话，对于每一种数据都定义了明白的具体数据类型，在内存平分派了不合大小的内存空间。
   数据类型分为根蒂根基数据类型和引用数据类型。根蒂根基数据类型稀有值型，字符型char，布尔型boolean，数值型又分为整数类型（byte，   short，int，long）和浮点类型（float，double）；引用数据类型有类class，借口interface和数组[]。
   此中整数默认：int    小数默认：double 一个8位代表8个二进制位。
   byte : 以一个8位默示，局限-27~27-1即-128~127 
   short : 以两个8位默示，短整型，局限-215~215-1即-32768~32767 
   Int : 以四个8位默示，局限-231~231-1
   long : 以八个8位默示，长整型 用于天文数字
   float : 以四个8位默示，单精度
   double : 以八个8位默示，双精度
   char : 以两个8位默示，取值局限0~6535
   boolean : 取值只有两个。true，false
  ◆◆【主动类型提拔与类型强迫转换】◆◆
   主动类型提拔，也叫主动类型转换或隐式类型转换；强迫类型转换，也叫显式类型转换。
   精度从高到低  double  float  long  int  short（char）  byte
   （1）主动类型转换  将一个低精度变成高精度
   （2）强迫类型转换  将一个高精度变成低精度（精度会降落）
   表达式的数据类型主动提拔
    所有的byte型、short型和char的值将被提拔到int型。
    若是一个操纵数是long型，策画成果就是long型；
    若是一个操纵数是float型，策画成果就是float型；
    若是一个操纵数是double型，策画成果就是double型。
   byte b = 3;b = b + 2;
    报错，因为b是一个字节，占一个8位，2作为整数默认int型，占四个8位，策画机在对b和2进行加法运算时会主动把b提拔     为四个8位（在前面补0）后再进交运算，获得的成果也是四个8位，属于int型，在向b赋值时b只占一个8位，所以会报错。    在这个过程中，b由一个8位变为四个8位称为主动类型提拔。
   byte b = 3;b = （byte）（b+2）;
    不会报错，在这里b进步前辈行主动类型提拔，与2进行加法运算后的数据（b+2）占四个8位，被byte强迫转换为byte类型（即     把前面的三个8位去掉）后赋值给b，这叫做强迫类型转换。
   思虑：
   （1） byte b = 3;int x = 4;x = x + b;
    b会主动提拔为int类型进交运算。
   （2） byte b1=3，b2=4，b;
    b=b1+b2; b=3+4; 哪句是编译失败的？为什么？
    b=3+4 编译经由过程。因为3和4是常量，所以java在编译时代会搜检该常量的和是否超出byte类型的局限。若是没有就赋值。     b=b1+b2编译失败，因为b1和b2是变量，因为变量的值会变更，不断定具体的值，所以默认应用int类型进行存储。
5.运算符 
 （1）算术运算符
  +   加  -   减     乘  /   除
  +   正号  -   负号  ％   取模  +   字符串相加
  ++  自增（前） ++  自增（后）   自减（后）  
 
  ％ 取模，即求余数
   4％2=0，5％2=1，5％4=1，5％1=0，1％5=1，5％5=0，1％-5=1，-1％5=-1
   规律：
    左边小于右边，成果是左边；左边便是右边，成果是0；
    右边是1，成果是0；呈现负数，只看左边（被模数）。
  ◆◆【++，-- 自增，自减】◆◆
   b=a++; a先赋值给b，然掉队行自增运算。
   b=++a; a进步前辈行自增运算，然后赋值给b。
   a=a++; a先赋值给a，然掉队行自增运算（无论运算几许次，a的值不变） 
   a=++a; a进步前辈行自增运算，然后赋值给a（相当于a++）
   a++==b; a先断定与b是否相等，然掉队行自增运算。
   ++a==b; a进步前辈行自增运算，然后断定与b是否相等。
   b==++a; a进步前辈行自增运算，然后断定与b是否相等。
   b==a++; a先断定与b是否相等，然掉队行自增运算。
   a++>b; a先断定是否大于b，然掉队行自增运算。
   ++a>b; a进步前辈行自增运算，然后断定是否大于b。
  + 字符串相加
   字符串数据和任何数据应用+都是相连接，终极都邑变成字符串
   System.out.println（“ab”+5+5）;  打印成果ab55
   System.out.println（“5+5=”+5+5）; 打印成果5+5=55
   System.out.println（“5+5=”+（5+5））; 打印成果5+5=10（进步了优先级）
  转义字符 \
   经由过程“\”来改变后面字母或符号的意义，转义字符要写在被转义字符前面
   \n:换行。
   \b:退格。相当于backspace。
   \r:按下回车键。window体系，回车符是由两个字符来默示\r\n.
   \t:制表符。相当于tab键。
   System.out.println（“\”hello\””）; 打印成果“hello”
   System.out.println（“\\hello\\”）; 打印成果\hello\
 （2）赋值运算符
  =   便是  +=  加便是 -=  减便是
  =  乘便是 /=  除便是 ％=  模便是
  
  += 加便是 
   把阁下两边的和赋值给左边
  思虑：
   short s = 3;
   s=s+2;和s+=2; 有什么差别？    
   s=s+2;编译失败，因为s会被提拔为int类型，运算后的成果还是int类型。无法赋值给short类型。是两次运算，先做加法，再做赋    值，不会做主动转换动作；s+=2;编译经由过程，因为+=运算符在给s赋值时，主动完成了强转操纵。是一次运算。
 （3）斗劲运算符
   == 相便是 != 不便是 < 小于  > 大于
  >= 大于便是 <= 小于便是 instanceof 搜检是否是类的对象
  斗劲运算符的成果都是boolean型，也就是要么是true，要么是false。
 （4）逻辑运算符
  |  或  &  与  !   非
  ^  异或  && 双与  ||  双或
  逻辑运算符用于连接布尔型表达式，
   & : 两边只要有一个为false。成果为false。只有两边都为true，成果为true。
   | : 两边只要有一个为true，成果为true。只有两边都有false，成果为false。
   ^ : 两边雷同成果是false。两边不合成果是true。
  ◆◆【“&”和“&&”的差别：】◆◆
   & 左边无论真假，右边都进交运算；
   && 若是左边为假，那么右边不参与运算。
   “|”和“||”的差别同理，双或时，左边为真，右边不参与运算。
 （5）位运算符
  <<  左移  >>  右移  >>>  无符号右移
  &   与运算 |   或运算 ^    异或运算  ~  反码

  << : 被移除的高位丢弃，空白位补0，相当于乘与2的移动位数次幂。
  >> : 被移位的二进制高位是0，右移后，空白位补0；高位是1，空白位补1。相当于除以2的移动位数次幂。
  >>>: 被移位的二进制位无论是0还是1，空白位补0。
  &  : 二进制位进行&运算，只有1&1时成果是1，不然是0。
  |  : 二进制位进行&运算，只有0|0时成果是0，不然是1。
  ^  : 任何雷同二进制位进行^运算，成果是0；不雷同二进制位进行^运算，成果是1。
 （6）三元运算符
  格局：
   （前提表达式）？表达式1：表达式2；
   若是前提为true，运算后的成果是表达式1；
   若是前提为false，运算后的成果是表达式2；
  益处与弊病：
   益处：可以简化if else代码，写在其他表达式中
   弊病：因为是一个运算符，所以运算完必必要有一个成果
6.语句（法度流程把握）
 （1）断定布局
  if语句格局
   格局一
    if（前提表达式）
    {
     履行语句；
    }
   格局二
    if（前提表达式）
    {
     履行语句；
    }
    else
    {
     履行语句；
    }
   格局三
    if（前提表达式）
    {
     履行语句；
    }
    else if （前提表达式）
    {
     履行语句；
    } 
     ……
    else
    {
     履行语句；
    }
  if语句特点：
   a.每一种格局都是单条语句。
   b.前提表达式无论写成什么样子，只看终极的布局是否是true 或者 false;
   c.若是if把握的只有一条语句，可以不消写{}，反过来说，若是if语句后没有{}，则只把握离它比来的一条语句。
  if else 布局简写格局：
   变量=（前提表达式）？表达式1:表达式2;
 （2）选择布局
  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语句停止。
  if和switch的差别
   若是断定的具体数值不久不多，并且合适byte，short，int，char这四种类型，固然两个语句都可以应用，但建议应用switch语句，因    为效力稍高.其它景象：对区间断定，对成果为boolean类型断定，应用if语句，if的应用局限更广。
 （3）轮回布局
  代表语句：while，do while，for
  while语句格局：
   while（前提表达式）
   {
    履行语句；
   }
   while特点是先断定前提，只有前提满足才履行轮回体。
  do while语句格局：
   do
   {
    履行语句；
   }while（前提表达式）;
   do while特点是先履行轮回体，再断定前提，前提满足，再持续履行轮回体。前提无论是否满足，轮回体至少被履行一次。
  for语句格局：
   for（初始化表达式;轮回前提表达式;轮回后的操纵表达式）
   {
    履行语句；
   }
  for语句特点：
   a.for语句里面的各个表达式运行的次序，初始化表达式只读一次，断定轮回前提，为真就履行轮回体，然后再履行轮回后的操纵表     达式，接着持续断定轮回前提，反复这个过程，直到前提不满足为止。
   b.while与for可以互换，差别在于for为了轮回而定义的变量在for轮回停止后就在内存中开释。而while轮回应用的变量在轮回停止      后还可以持续应用。
   c.最简单无穷轮回格局：while（true） ， for（;;），无穷轮回存在的原因是并不知道轮回几许次，而是按照某些前提，来把握轮回。
  while和for的差别
   for与while可以互换，用for语句能写出的，用while语句必然也能写出。对于变量来说，若是该变量仅仅用于把握轮回的次数，作    为轮回增 量存在的景象下，用for语句更合适，因为内存被及时开释。  
 （4）其他流程把握语句
  break 跳出
  continue持续
  应用局限：
   break 语句：应用于选择布局和轮回布局。
   continue语句：应用于轮回布局。持续轮回
  break和continue语句特点：
   a.这两个语句必须有感化局限。分开应用局限存在是没有意义的。
   b.这个两个语句零丁存在时，下面都不成以有语句，因为履行不到。
   c.continue语句的特点是停止本次轮回持续下次轮回。
  标号：
   只能用于轮回上，给轮回起名字的一种体式格式
   q:for （）
   { 
    w:for （）
    {
    }
   }
   标号的呈现，可以让这两个语句感化于指定的局限。
 ◆◆【累加思惟】◆◆
  道理：经由过程变量记录每次变更的成果，经由过程轮回的情势进行累加的动作。变量+轮回
 ◆◆【计数器思惟】◆◆
  道理：经由过程变量记录住数据的状况变更，经由过程轮回完成遍历的动作，遍历过程中参加把握变量变更的断定
 嵌套
  语句嵌套情势：其实就是语句中还有语句。轮回嵌套，就是轮回中还有轮回。
  对于打印图形来说，外轮回把握的是行数，内轮回把握的是每一行的列数，也就是一行中元素的个数
  嵌套轮回中不是规律的规律：
   图形尖朝上：可以改变前提，让前提跟着外轮回变更
   图形尖朝下：可以改变初始化值，让初始化值跟着外轮回变更
7．函数
 函数的定义：
  函数就是定义在类中的具有特定功能的一段自力小法度。也称为办法。
 函数的格局：
  润饰符 返回值类型 函数名（参数类型 情势参数1，参数类型 情势参数2）
  {
   履行语句;
   return 返回值;
  }
  返回值类型：函数运行后的成果的数据类型。
  参数类型：是情势参数的数据类型。
  情势参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
  实际参数：传递给情势参数的具体数值。
  return：用于停止函数。
  返回值：该值会返回给调用者。
 函数的特点
  定义函数可以将功能代码进行封装，便于对该功能进行复用，函数只有被调用才会被履行，它的呈现进步了代码的复用性。函数中只能调用函   数，不成以在函数内部定义函数。
 重视：
  定义函数时，函数的成果应当返回给调用者，交由调用者处理惩罚。
  对于函数没有具体返回值的景象，返回值类型用关键字void默示，那么该函数中的return语句若是在最后一行可以省略不写。
 如何定义一个函数（两个明白）
  明白要定义的功能最后的运算成果是什么（明白返回值类型）
  明白在定义该功能的过程中，是否须要未知内容参与运算（明白参数列表）
 ◆◆【】◆◆函数的重载（overload）】◆◆
  重载的概念（什么时辰用重载）：
   当函数的功能一样，仅仅是参与运算的未知内容不应时，可以定义一个函数名以默示此功能，如许便利浏览。在调用时，虚拟机经由过程   参数列表的不合来区分多个同名函数。
  重载的特点：
   与返回值类型无关，只看参数列表。
  重载的益处：
   便利于浏览，优化了法度设计。
 主函数
  public static void main（String[] args）
  它是一个特别的函数。作为法度的进口，主函数是固定格局的：可以被JVM辨认和调用。
  主函数的定义：
  public：代表着该函数接见权限是大。
  static：代表主函数跟着类的加载就已经存在了。
  void  ：主函数没有具体的返回值。
  main  ：不是关键字，然则是一个特别的单词，可以被jvm辨认。
  （String[] args）：函数的参数，参数类型是一个数组，该数组中的元素是字符串。即字符串类型的数组。
  JVM在调用主函数时，传入的是new String[0];
8．数组
 数组的定义
  同一种类型数据的凑集。其实数组就是一个容器。
 数组的益处：
  可以主动给数组中的元素从0开端编号，便利操纵这些元素。
 数组的格局
  格局1：
   元素类型[] 数组名= new 元素类型[元素个数或数组长度];
  格局2：
   元素类型[] 数组名= new 元素类型[]{元素，元素，……};
  格局3：
   元素类型[] 数组名= {元素，元素，……};
  new：在内存中产生一个容器实体，用来存储很多半据。
  null：是一个常量，只有引用数据类型才干应用这个常量。数组名就是一个数组类型的数据，数组是一种零丁的数据类型，数组名指向了该   数组，或叫引用了该数组。若是不想再让数组名指向该数组，用null。数组名=null;默示不再指向该数组，而是值为空。
 数组的内存分派及特点
  Java法度在运行时，须要在内存中的分派空间。为了进步运算效力，又对空间进行了不合区域的划分，因为每一片区域都有特定的处理惩罚数据方   式和内存经管体式格式。
  栈内存
   用于存储局部变量，当数据应用完，所占空间会主动开释。凡是局部变量，都在栈内存中。
   局部变量：定义在办法中的变量，办法中参数的变量，for轮回中的变量。
  堆内存
   用于存放数组和对象，经由过程new建树的实体都存放在堆内存中。每一个实体都有内存地址值，实体中的变量都有默认初始化值，当实   体不再被 应用，会在不断定的时候内启动一个垃圾收受接管机制将该数组实体在堆内存中清除.
  办法区，本处所法区，存放器
 数组操纵常见题目
  数组角标越界异常（ArrayIndexOutOfBoundsException
   操纵数组时，接见到了数组中的不存在的角标。
  空指针异常（NullPointerException）
   当引用没有指向实体（值为null），却在操纵实体中的元素时。
 ◆◆【数组常见操纵】◆◆
  （1）打印数组
   打印数组就是打印数组中的每一个元素，相当于将数组元素遍历。用for轮回来实现该功能并封装起来作为一个函数调用，以增长可    用性。length：数组的一个属性，可以直接获取到数组元素个数。应用体式格式：数组名.length
  （2）获取最值（以最大值为例）
   思路：
   1.获取最大值须要进行斗劲。每一次斗劲都邑有一个较大的值。因为该值不断定。经由过程一个变量进行姑且存储。
   2.让数组中的每一个元素都和这个变量中的值进行斗劲。若是大于了变量中的值，就用该该变量记录较大值。
   3.当所有的元素都斗劲完成，那么该变量中存储的就是数组中的最大值了。
   步调：
   1.定义变量。初始化为数组中随便率性一个元素即可（一般初始化为数组中的第一个元素）。
   2.经由过程轮回语句对数组进行遍历。
   3.在遍历过程中定义断定前提，若是遍历到的元素比变量中的元素大，就赋值给该变量。
   获取最值的另一种体式格式。
    可以将姑且变量初始化为0。这种体式格式其实是在初始化为数组中的第一个元素的角标。
  （3）排序（以从小到大为例），选择排序，冒泡排序
   a.选择排序。
    选择排序，就是将数组中第一个元素分别与其它元素作斗劲，若是大于其它元素，则换位，如许，在数组最左端就是最小     的元素；然后将第二个元素分别与除了第一个元素的其它元素斗劲，依次类推，获得终极的排序。内轮回停止一次，最值     呈如今头角标地位上。
   b.冒泡排序
    相邻的两个元素进行斗劲，若是合适前提换位。内轮回停止一次，最值呈如今末角标地位上。
  （4）折半查找（二分查找）
   折半查找可以进步效力，然则必必要包管该数组是有序的数组。
 数组中的数组：二维数组[][]
  格局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是二维数组。