java 复习1

java特点
    简单  面向对象  分布式
    解释  健壮      安全
    高效  结构中立  可移值
    多线程  动态
java一种特殊的高级语言  编译型语言特征和解释型语言特征 先编译 后解释执行
编译型语言：用专门的编译器 针对特点平台[操作系统]将高级言语一次性编译成平台执行的机器码。c c++
解释型语言：用专门的解释器 对源程序逐渐解释成特定平台的机器码立即执行语言
JDK:美国sun公司提供一套开发java应用程序开发包，提供编译和运行java程序所需要的各种工具和资源。
    [包含JRE、java工具、java基础类库]
JDK:Java运行时环境
    Java的工具:
        Javac.exe（java编译器）
|               Java.exe(java解释执行器)
    Java的类库:(3600多个)  常用的150多个
JRE(Java运行时环境)
    JRE:Java程序运行必须条件，只想运行java程序，可以只用安装JRE，不需要安装JDK。但是如果我们要开发Java程序，必须安装JDK。
JVM(Java虚拟机)
    JVM:负责解释执行字节码文件。相同的字节码文件要想在不同的平台[操作系统]上运行是不可能的，通过中间的转换器才可以实现，
    JVM就是充当了这个转换器。Java是通过JVM实现跨平台的，跨平台也是java最大的优势之一。
JRE和JVM的联系与区别:
    JRE包含JVM。JVM是运行java程序的核心虚拟机，他负责解释执行字节码文件，
    但是java程序运行不仅仅需要jvm，还需要其他的资源,
    例如:类，类加载器，字节码校验器….. JRE处理包含JVM外，还拥有Java程序运行所需的所有资源。
Java中的注释:
    注释:说明某段代码的作用，某个类的用途，某个方法的功能
Java中注释分为三类:
    单行注释，多行注释，文本注释。
    单行注释:       //注释内容

    多行注释:    /*
            注释内容
            ……
            注释内容
            */

    文档注释:    /**
              *注释内容
              * ……
              *注释内容
             */
    注释后可以生产API,帮助用户学习和理解改程序
Java的分隔符:
Java语言中 ; {} [] () , . ( )都具有特殊分隔作用，因此他们统称为分隔符。
分号 ;
    用作语句分隔。Java中语句分隔不使用回车，用分号。每个java必须以;结尾。Java代码中允许一行写多条Java语句，但是每条Java语句中必须以;分隔开来。
花括号 {}
    定义一个代码块。
    注意:有一个”{”必须有一个”}”与之对应

方括号 []
    用来访问数组元素。

圆括号 ()
    定义方法时使用();
    表达式中某一部分是一个整体，保证表达式的优先级 (10+3)/2
    强制类型转换

逗号 ,
    变量声明时分隔多个变量  int a,b,c;
    方法定义时分隔多个参数  int max(int a,int b,int c){}
    数组中变量值的风格      int[] a = {1,2,3,4,5};

圆点 .
    类/对象和定义的成员之间的分隔符，表明调用某个类或对象的某个指定成员。eg： System.out.println();        p.age

空格
    分隔一条语句的不同部分。空格几乎可以出现在代码的任何部分，也可以出现任意多个空格。
Java标示符
    标示符:所谓标示符就是给程序中类、方法、变量命令的符号
    public class Demo{
        public static void main(String[] args){
            int a = 10;
        System.out.println(a);
        }
    }
    代码中 Demo类名、main方法名、a变量名
标示符命名规则:
    标示符必须以字母、下划线(_)、美元符号($)开头，后面可以跟上任意数目的字母、数字、下划线(_)、美元符号($)。不仅仅是26个英文字母，还可以是中文字符、日文字符…….
    注意:标示符不能包括空格，不能使用java的关键字和保留字和直接量，标示符的长度不受限制。
         由于Java采用的Unicode编码，因此Java的标示符可以使用Unicode能够表示的任意字符。Java语言严格区分大小写，因此Abc和abc是不用的标示符
Java关键字48个
    abstract  assert       boolean  break       byte     case
    catch      char           vlass    continue    default  do
    double    else         enum     extends     final    finally
    float     for          if       implements  import   int
    interface instanceof   long      native      new      package
    private   protected    public   retum     short    static
    strictfp  super        switch   synchronized  this     throw
    throws    transient    try      void        volatile while
保留字 2个
    goto、const还没有使用它们作为关键字,将来可能使用它们为关键字
直接量 3个
    Java中还有三个直接量也不能作为标示符: true  false  null
    中关键字、保留字、直接量都是小写,If,For都可以用来作为标示符,严格区分大小写
Java数据类型包括
    基本数据类型 和 引用数据类型(复杂数据类型)两大类
基本数据类型(4类8种)
    整数类  1字节：byte
               2字节：short
         4字节：int    整型:没有小数部分的数值，可以是负数
         8字节：long

    字符类     2字节：char    表示单个的字符。字符常量必须使用单引号引起来。Java中是采用Unicode编码。Unicode编码几乎支持世界上的所有书面语言，包括英文字母，中文…….
        
        字符常量三种表现形式:
                a.直接通过单个字符常量来指定字符常量 eg: ‘A’、‘你’
                b.通过转义字符表示特殊字符常量 eg: ‘＼n’、‘＼”’
                c.直接使用Unicode值来表示字符常量,格式是‘＼uXXXX’ 其中XXXX代表一个十六进制的整数。eg： char c = ‘＼u9999’;//表示 ‘香’
    
    浮点类    4字节：float[必须添加一个后缀F或f (eg：float f = 1.2F)，没有添加后缀会默认为double类型的数据]    
         8字节：double[最常用  浮点型常量默认]
        表示有小数部分的数值
    
    布尔类    1字节：boolean    表示逻辑上的真假，布尔类型只有两个值 true，false，主要用来判断逻辑条件。
        布尔类型不能和其他任何类型相互转换。
        案例: boolean a = true;

整型:没有小数部分的数值，可以是负数
Java中整形常量有三种表示方式:十进制、八进制、十六进制
                 默认是十进制，八进制数据以0开头，十六进制数据以0x或0X开头
变量声明
    eg:
        int days;//天数
        int age;//年龄
        int a,b,c;

初始化
    eg：
        days = 25;
        age = 18;
        a = 10;
        b = 10;
        c = 5;

    变量声明和初始化合并成一部完成  注意:声明了一个变量后，一定要初始化才可以使用改变量
        int days = 25;
        int age = 18;
        int a=10,b=10,c=5;
动态初始化
    eg：  
        int a = 10;
        int b = a;
    整型变量b的初始化是将a的值赋给了b，这就是动态初始化。
    注意如果a没有初始化，就不允许用a作为其他变量的初始化值。
    eg：    int a;
            int b = a;//此处报错

常量:不能改变的量，值是固定的。
    public class Test2{
    public static void main(String[] args){
        int a = 10;
        final int MONTHS = 12;//常量 （常量名一般大写，便于和普通变量区分）
        System.out.println("a="+a+", MONTHS ="+ MONTHS);
        a = 20;
        MONTHS = 15;//报错 无法为最终变量 months 指定值(常量的值不可以改变)
        System.out.println("a="+a+", MONTHS ="+ MONTHS);
    }
}

变量作用域
    块是用花括号扩起来的任意数量的Java语句，块可以嵌套在其它的块中
    在Java中块决定了变量的作用域。
    
    eg:
        public class Test2{
            public static void main(String[] args){
                int a;
                ....
                {
                ....
                int b;
                ....
                }//b的作用范围到此为止
            }//a的作用范围到此为止
        }
Java八种基本数据类型有两种转换方式:
            自动类型转换
            强制类型转换
        boolean类型不可以和其他任何类型相互转换。
自动类型转换
        条件:a.类型兼容
             b.目标类型大于源类型
            byte  short
                     int long float  double
                  char
强制类型转换
    有时候需要将大类型的数据转换成小类型使用。
        eg:需要将double类型的数据转换成int类型使用，此时可能损失精度，必须使用强制类型转换。
        注意:强制类型转换不可以乱用
表达式类型提升
    当使用二元运算符对两个值进行运算时，两个操作数会转换成通用类型。
    如果两个操作数中有一个是double类型，则另一个将会转换成double型；
    如果两个操作数中有一个是float类型，则另一个将会转换成float型；
    如果两个操作数中有一个是long类型，则另一个将会转换成long型；
    否则，两个操作数都转换成int型。

字符串和所有基本数据类型，基本数据类型都会转换成字符串。
        eg:
        System.out.println("abc"+1+2);//输出  abc12
        System.out.println("abc"+(1+2));//输出 abc3
算术运算符+   -   *   /    %
      加  减  乘  除   取模(取余)

自增自减运算符 ++  --
           自增 自减
关系运算符>   >=       <      <=        ==      !=                    
     大于 大于等于 小于  小于等于   等于   不等
    关系表达式得到的结果是true或false
逻辑运算符&&  ||   ！  ^    &     |    
     与   或   非  异或    与    或
    && 和 || 是按照短路的方式来求值的。如果第一个操作数已经能够确定表达式的值，则不会计算第二操作数。
    & 和 |   是按照非短路方式来求值的。即使第一个操作数已经能够确定表达式的值，还是要计算第二个操作数。
    ^：两个操作数不同返回true，相同返回false
位运算符&     |         ^
    位运算符用于整数之间的位运算，将两个整数转换成2进制来运算
    & 按位求与 (两个1就为1  ，其他都为0)
    |  按位求或 (有一个1 就为1)
    ^ 异或 (两个相同为0  不同为1)
赋值运算符 =
    注意将 = 和 ==区分开来。= 是赋值    == 是判断是否相等
程序的三种结构
    顺序结构：自上而下的逐行执行代码。
    选择结构：根据逻辑判断，有选择的执行其中某部分代码。
    循环结构：根据逻辑判断，重复执行某个代码块。
顺序结构程序设计
    案例中代码块中没有用if、switch、for、while等的，都是顺序结构
if分支结构
    单分支
    语法:
        if（表达式）{
        代码块；
            }
        说明:
           如果表达式为true，执行if中的代码块，否则不执行

    单分支
    语法:
        if（表达式）{
        代码块；
            }
        说明:
         如果表达式为true，执行if中的代码块，否则不执行
多路分支
    语法:
        if（表达式1）{
        代码块1;
           }else if(表达式2){
            代码块2;
            }
        ……
        ……//中间可以有n个 else if(){}
        ……
        }else{ //最后这个else可有可无
            代码块n；
           }
    说明:
        如果表达式1为true，执行代码块1；如果表达式1为false，则判断表达式2；
        如果表达式2为true，执行代码块2；如果表达式2为false，则判断表达式3；
        ……
        ……
        如果表达式都为false，则执行else中代码块n
嵌套分支结构
    public class Test7{
        public static void main(String[] args){
            int a=10,b=15,c=20;
            if(a>b){
                if(a>c){
                    System.out.println("最大值="+a);
                }else{
                    System.out.println("最大值="+c);
                }
            }else{
                if(b>c){
                    System.out.println("最大值="+b);
                }else{
                    System.out.println("最大值="+c);
                }
            }
        }
    }
switch
    语法:
        switch(表达式){  // JDK6 中表达式类型只能为 byte short int char
        case 值1:        // JDK7中表达式类型只能为 byte short int char String
            语句块1;break;
        czase 值2:
            语句块2;break;
            ……
            ……// 中间可以有n个case
            ……
        default:    //最后这个default可有可无
            语句块n;
            }

    说明:
        根据switch后面括号中表达式的值去依次和case后面的值比较，如果遇到了匹配的就从这个case进入，
        执行后面的代码块，不再判断是否与后面的case，default标签后面的值是否匹配，直到遇到break才停止。
        如果没有遇到匹配的值则执行default中的代码块。
循环结构程序设计
    while
    语法:
        while(表达式){
            循环体
        }
    说明:
    判断表达式的值如果为true，执行循环体，循环体执行完了又回到前面判断表达式的值，如果表达的值为true，
    又执行循环体……依此循环，直到表达式的值为false，循环结束。

    do…while
        语法:
            do{
            循环体
            } while(表达式);

    说明:
    先执行循环体，循环体执行完了判断表达式，如果表达的值为true，又回到前面执行循环体，
    循环体执行完了又判断表达式……依此循环，直到表达式的值为false，循环结束
    for
    语法:
        for(语句1;语句2;语句3){
        循环体；
        }

    语句1:初始化循环变量
    语句2:循环条件
    语句3:循环增量
    说明:
        首先执行语句1，
                再判断语句2，如果2为true，执行循环体。
        循环体执行完了，执行语句3，
        语句3执行完了又判断语句2，如果2为true，又执行循环体。
        依此循环，直到语句2为false，循环结束。
嵌套循环
    打印出九九乘法表
循环控制break、continue
    break:可以在switch中使用，还可以用来结束循环
    continue:结束当前这一次循环
数组是所有编程语言中最常见的一种数据结构，他用于存储多个数据。

Java中数组要求数组中的元素类型要一致。Java中一旦数组初始化完成，数组在内存中所占用的空间被固定下来了，因此数组的长度不可变的
数组的定义、初始化。
数组定义
    语法:
        类型[] 数组名;//常用   int[] a;
        类型 数组名[];//不常用 int a[];
数组初始化
        静态初始化
    初始化数组时由程序员显示的指定每个数组元素的值，不指定数组的长度，长度由系统自己计算。
动态初始化
    初始化数组时程序员只指定数组长度，不指定数组元素的值，系统自动给数组分配初始值
访问数组元素
    数组中每个元素都有一个下标，下标从0开始。
    访问单个元素
    int[] a = {56,78,23,50,95};
    56  --------   a[0]
    78  --------   a[1]
    23  --------   a[2]
    50  --------   a[3]
    95  --------   a[4]
访问所有元素
    要输出数组中所有元素，需要使用循环
数组求和
数组求平均分
数组求最大、最小值
查找某个数据是否在数组中
分段统计
冒泡排序
数组内存分析
    栈:基本数据类型变量值，引用类型变量的地址值
    堆:引用类型的真实值
Java中没有多维数组。
    一维数组中放的是多个普通变量，二维数组中放的是多个一维数组，三维数组中放的是多个二维数组……
二维数组
二维数组定义
    语法:
        类型[][] 数组名;//常用   int[][] a;
        类型 数组名[][];//不常用 int a[][];
数组初始化
    静态初始化
     初始化数组时由程序员显示的指定每个数组元素的值，不指定数组的长度，长度由系统自己计算。
    动态初始化
     初始化数组时程序员只指定数组长度，不指定数组元素的值，系统自动给数组分配初始值。
三维数组