注释

1、单选注释：符号是：//

2、块注释： 符号是： /*  */ 可以跨多行

3、javadoc注释： 符号是： /**  */ 可以跨多行，

生成javadoc时，这样的注释会被生成标准的javaapi注释。

数据类型

┏数值型━┳━整数型：byte short int long

              ┏基本数据类型━━┫              ┗━浮点型：float double

              ┃                            ┣字符型：char                                         

数据类型╋                            ┗布尔型：boolean             

              ┃                            ┏类（class）

              ┗引用数据类型━━╋接口（interface）

                                            ┗数组（array）

java的数据类型分基本数据类型（原始数据类型）和引用数据类型；

1.基本八大类，图中可以很清楚的看到；这种类型的数据变量在声明之后java就会立刻分配给他内存空间。如：short a;  java会在可使用的内存空间寻找一个占两个字节的块给a变量；

2.引用数据类型就那三种，类似C/C++的指针，它以特殊的方式指向对象实体（具体的值），这类变量声明时不会分配内存，只是存储了一个内存地址，想具体知道看看数据结构就好了。

通俗讲，一、上图记住很够用；二、说内存、谈地址基本都是说引用而非基本；三、你可以把内存地址理解是你学号，而对象实体就是你，每次找你通过学号找，这就是引用；

变量

  变量就是一类可以变的量。比如int a;表示整形的a,可以赋值为10或者20等等。

    变量的6个特征：

    名称：就是名字，比如a

    类型：整形、字符型等等，比如上面那个就是整形

    值：变量的值

    地址：在内存中的“位置”

    作用域：变量生效的范围(你再看到后面就大概知道这个了)

生存期：变量存在的时间(也是后面的概念)

运算符

Java的运算符可分为4类：算术运算符、关系运算符、逻辑运算符和位运算符。

1.算术运算符 

    Java的算术运算符分为一元运算符和二元运算符。一元运算符只有一个操作数；二元运算符有两个操作数，运算符位于两个操作数之间。算术运算符的操作数必须是数值类型。

    (1)一元运算符：

    一元运算符有：正（+）、负（－）、加1（++）和减1（－－）4个。

    加1、减1运算符只允许用于数值类型的变量，不允许用于表达式中。加1、减1运算符既可放在变量之前（如＋＋i），也可放在变量之后（如i＋＋），两者的差别是：如果放在变量之前（如＋＋i），则变量值先加1或减1，然后进行其他相应的操作（主要是赋值操作）；如果放在变量之后（如i＋＋），则先进行其他相应的操作，然后再进行变量值加1或减1。

    例如：

    int i=6，j，k，m，n;

    j = +i;    //取原值，即j=6

    k = -i;    //取负值，即k=-6

    m = i++;    //先m=i,再i=i+1，即m=6，i=7

    m = ++i;    //先i=i+1,再m=i，即i=7，m=7

    n = j--;    //先n=j,再j=j-1，即n=6，j=5

    n = --j;    //先j=j-1,再n=j，即j=5，n=5

    在书写时还要注意的是：一元运算符与其前后的操作数之间不允许有空格，否则编译时会出错。

    (2)二元运算符

    二元运算符有：加（+）、减（－）、乘（*）、除（／）、取余（%）。其中+、－、*、／完成加、减、乘、除四则运算，%是求两个操作数相除后的余数。

%求余操作举例：

    a % b = a － (a / b) * b

    取余运算符既可用于两个操作数都是整数的情况，也可用于两个操作数都是浮点数（或一个操作数是浮点数）的情况。当两个操作数都是浮点数时，例如7.6 % 2.9时，计算结果为：7.6 － 2 * 2.9 = 1.8。

    当两个操作数都是int类型数时，a%b的计算公式为：

    a % b = a － （int）(a / b) * b

    当两个操作数都是long类型（或其他整数类型）数时，a%b的计算公式可以类推。

    当参加二元运算的两个操作数的数据类型不同时，所得结果的数据类型与精度较高（或位数更长）的那种数据类型一致。

    例如：

    7 / 3    //整除，运算结果为2

    7.0 / 3  //除法，运算结果为2.33333,即结果与精度较高的类型一致

    7 % 3    //取余，运算结果为1

    7.0 % 3  //取余，运算结果为1.0

    -7 % 3  //取余，运算结果为-1，即运算结果的符号与左操作数相同

    7 % -3  //取余，运算结果为1，即运算结果的符号与左操作数相同

2.关系运算符 

  关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑类型的数值。关系运算符有六个：等于（==）、不等于（!=）、大于（>）、大于等于（>=）、小于（<）、小于等于（<=）。

    例如：

    9 <= 8      //运算结果为false

    9.9 >= 8.8  //运算结果为true

    'A' < 'a'  //运算结果为true，因字符'A'的Unicode编码值小于字符'a'的

    要说明的是，对于大于等于（或小于等于）关系运算符来说，只有大于和等于两种关系运算都不成立时其结果值才为false，只要有一种（大于或等于）关系运算成立其结果值即为true。例如，对于9 <= 8，9既不小于8也不等于8，所以9 <= 8 的运算结果为false。对于9 >= 9，因9等于9，所以9 >= 9的运算结果为true。

3.逻辑运算符

    逻辑运算符要求操作数的数据类型为逻辑型，其运算结果也是逻辑型值。逻辑运算符有：逻辑与（&&）、逻辑或（||）、逻辑非（!）、逻辑与或（^）、逻辑与（&）、逻辑或（|）。

    真值表是表示逻辑运算功能的一种直观方法，其具体方法是把逻辑运算的所有可能值用表格形式全部罗列出来。Java语言逻辑运算符的真值表如下：

    逻辑运算符的真值表

    A      B      A&&B  A||B  !A    A^B    A&B    A|B

    false false false false true  false false false

    true  false false true false true  false true

    false true  false true true  true  false true

    true  true  true  true false false true  true

    前两列是参与逻辑运算的两个逻辑变量，共有4种可能，所以表2.5共有4行。后6列分别是6个逻辑运算符在逻辑变量A和逻辑变量B取不同数值时的运算结果值。

    要说明的是，两种逻辑与（&&和&）的运算规则基本相同，两种逻辑或（||和|）的运算规则也基本相同。其区别是：&和|运算是把逻辑表达式全部计算完，而&&和||运算具有短路计算功能。所谓短路计算，是指系统从左至右进行逻辑表达式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。对于&&运算来说，只要运算符左端的值为false，则因无论运算符右端的值为true或为false，其最终结果都为false。所以，系统一旦判断出&&运算符左端的值为false，则系统将终止其后的计算过程；对于 || 运算来说，只要运算符左端的值为true，则因无论运算符右端的值为true或为false，其最终结果都为true。所以，系统一旦判断出|| 运算符左端的值为true，则系统将终止其后的计算过程。

    例如，有如下逻辑表达式：

    (i>=1) && (i<=100)

    此时，若i等于0，则系统判断出i>=1的计算结果为false后，系统马上得出该逻辑表达式的最终计算结果为false，因此，系统不继续判断i<=100的值。短路计算功能可以提高程序的运行速度。

    作者建议读者：在程序设计时使用&&和||运算符，不使用&和|运算符。

    用逻辑与（&&）、逻辑或（||）和逻辑非（!）可以组合出各种可能的逻辑表达式。逻辑表达式主要用在 if、while等语句的条件组合上。

    例如：

    int i = 1;

    while(i>=1) && (i<=100) i++;    //循环过程

    上述程序段的循环过程将i++语句循环执行100次。

4.位运算符 

    位运算是以二进制位为单位进行的运算，其操作数和运算结果都是整型值。

   位运算符共有7个，分别是：位与（&）、位或（|）、位非（~）、位异或（^）、右移（>>）、左移（<<）、0填充的右移（>>>）。

    位运算的位与（&）、位或（|）、位非（~）、位异或（^）与逻辑运算的相应操作的真值表完全相同，其差别只是位运算操作的操作数和运算结果都是二进制整数，而逻辑运算相应操作的操作数和运算结果都是逻辑值。

    位运算示例

  运算符  名称  示例    说明

    &      位与    x&y    把x和y按位求与

    |      位或    x|y    把x和y按位求或

    ~      位非    ~x      把x按位求非

    ^      位异或 x^y    把x和y按位求异或

    >>      右移    x>>y    把x的各位右移y位

    <<      左移    x<<y    把x的各位左移y位

    >>>    右移    x>>>y  把x的各位右移y位，左边填0

    举例说明：

    （1）有如下程序段：

    int x = 64;  //x等于二进制数的01000000

    int y = 70;  //y等于二进制数的01000110

    int z = x&y  //z等于二进制数的01000000

    即运算结果为z等于二进制数01000000。位或、位非、位异或的运算方法类同。

    （2）右移是将一个二进制数按指定移动的位数向右移位，移掉的被丢弃，左边移进的部分或者补0（当该数为正时），或者补1（当该数为负时）。这是因为整数在机器内部采用补码表示法，正数的符号位为0，负数的符号位为1。例如，对于如下程序段：

    int x = 70;  //x等于二进制数的01000110

    int y = 2;

    int z = x>>y  //z等于二进制数的00010001

    即运算结果为z等于二进制数00010001，即z等于十进制数17。

    对于如下程序段：

    int x = -70;  //x等于二进制数的11000110

    int y = 2;

    int z = x>>y  //z等于二进制数的11101110

    即运算结果为z等于二进制数11101110，即z等于十进制数-18。要透彻理解右移和左移操作，读者需要掌握整数机器数的补码表示法。

    （3）0填充的右移（>>>）是不论被移动数是正数还是负数，左边移进的部分一律补0。

5.其他运算符

    （1）赋值运算符与其他运算符的简捷使用方式

    赋值运算符可以与二元算术运算符、逻辑运算符和位运算符组合成简捷运算符，从而可以简化一些常用表达式的书写。

    赋值运算符与其他运算符的简捷使用方式

  运算符 用法  等价于    说明

    +=    s+=i    s=s+i    s，i是数值型

    -=    s-=i    s=s-i    s，i是数值型

    *=    s*=i    s=s*i    s，i是数值型

    /=    s/=i    s=s/i    s，i是数值型

    %=    s%=i    s=s%i    s，i是数值型

    &=    a&=b    a=a&b    a，b是逻辑型或整型

    |=    a|=b    a=a|b    a，b是逻辑型或整型

    ^=    A^=b    a=a^b    a，b是逻辑型或整型

    <<=    s<<=i  s=s<<i    s，i是整型

    >>=    s>>=i  s=s>>i    s，i是整型

    >>>=  s>>>=i s=s>>>i  s，i是整型

    （2）方括号[]和圆括号（）运算符

    方括号[]是数组运算符，方括号[]中的数值是数组的下标，整个表达式就代表数组中该下标所在位置的元素值。

    圆括号（）运算符用于改变表达式中运算符的优先级。

（3）字符串加（+）运算符

    当操作数是字符串时，加（+）运算符用来合并两个字符串；当加（+）运算符的一边是字符串，另一边是数值时，机器将自动将数值转换为字符串，这种情况在输出语句中很常见。如对于如下程序段：

    int max = 100;

    System.out.println（"max = "+max）;

    计算机屏幕的输出结果为：max = 100，即此时是把变量max中的整数值100转换成字符串100输出的。

（4）条件运算符（？：）

    条件运算符（？：）的语法形式为：

    <表达式1> ？<表达式2> : <表达式3>

    条件运算符的运算方法是：先计算<表达式1>的值，当<表达式1>的值为true时，则将<表达式2>的值作为整个表达式的值；当<表达式1>的值为false时，则将<表达式3>的值作为整个表达式的值。如：

    int a=1，b=2，max;

    max = a>b？a：b;  //max等于2

（5）强制类型转换符

    强制类型转换符能将一个表达式的类型强制转换为某一指定数据类型，其语法形式为：

    (<类型>)<表达式>

（6）对象运算符instanceof

    对象运算符instanceof用来测试一个指定对象是否是指定类（或它的子类）的实例，若是则返回true，否则返回false。

（7）点运算符

    点运算符“.”的功能有两个：一是引用类中成员，二是指示包的层次等级。

6.运算符的优先级

    以下按优先级从高到低的次序列出Java语言中的所有运算符，表中结合性一列中的“左右”表示其运算次序为从左向右，“右左”表示其运算次序为从右向左。

    优先级 运算符                                        结合性

    1      .  []  ()  ;  ,

    2      ++  ――  +=  !  ~  +(一元) -(一元)                  右左

    3      *  /  %                                              左右

    4      +(二元)  -(二元)                                      左右

    5      <<  >>  >>>                                          左右

    6      <  >  <=  >=  instanceof                            左右

    7      = =  !=                                              左右

    8      &                                                    左右

    9      ^                                                    左右

    10      |                                                    左右

    11      &&                                                  左右

    12      ||                                                  左右

    13      ?：                                                  右左

    14      =  *=  /=  %=  +=  －=  <<=  >>=  >>>=  &=  ^=  |=  右左

字符串

1、length() 字符串的长度

　　例：char chars[]={'a','b'.'c'};

　　　　String s=new String(chars);

　　　　int len=s.length();

2、charAt() 截取一个字符

　　例：char ch;

　　　　ch="abc".charAt(1); 返回'b'

3、 getChars() 截取多个字符

　　void getChars(int sourceStart,int sourceEnd,char target[],int targetStart)

　　sourceStart指定了子串开始字符的下标，sourceEnd指定了子串结束后的下一个字符的下标。因此， 子串包含从sourceStart到sourceEnd-1的字符。接收字符的数组由target指定，target中开始复制子串的下标值是targetStart。

　　例：String s="this is a demo of the getChars method.";

　　　　char buf[]=new char[20];

　　　　s.getChars(10,14,buf,0);

4、getBytes()

　　替代getChars()的一种方法是将字符存储在字节数组中，该方法即getBytes()。

5、toCharArray()

6、equals()和equalsIgnoreCase() 比较两个字符串

7、regionMatches() 用于比较一个字符串中特定区域与另一特定区域，它有一个重载的形式允许在比较中忽略大小写。

　　boolean regionMatches(int startIndex,String str2,int str2StartIndex,int numChars)

　　boolean regionMatches(boolean ignoreCase,int startIndex,String str2,int str2StartIndex,int numChars)

8、startsWith()和endsWith()

　　startsWith()方法决定是否以特定字符串开始，endWith()方法决定是否以特定字符串结束，以空格区分这些字符串。

9、equals()和==

　　equals()方法比较字符串对象中的字符，==运算符比较两个对象是否引用同一实例。

　　例：String s1="Hello";

　　　　String s2=new String(s1);

　　　　s1.eauals(s2); //true

---

　　　　s1==s2;//false

---

10、compareTo()和compareToIgnoreCase() 比较字符串

11、indexOf()和lastIndexOf()

　　indexOf() 查找字符或者子串第一次出现的地方。

　　lastIndexOf() 查找字符或者子串是后一次出现的地方。

12、substring()

　　它有两种形式，第一种是：String substring(int startIndex)

　　　　　　　　 第二种是：String substring(int startIndex,int endIndex)

13、concat() 连接两个字符串

14 、replace() 替换

　　它有两种形式，第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换，形式如下：

　　String replace(char original,char replacement)

　　例如：String s="Hello".replace('l','w');

　　第二种形式是用一个字符序列替换另一个字符序列，形式如下：

　　String replace(CharSequence original,CharSequence replacement)

15、trim() 去掉起始和结尾的空格

16、valueOf() 转换为字符串

17、toLowerCase() 转换为小写

18、toUpperCase() 转换为大写

19、StringBuffer构造函数

　　StringBuffer定义了三个构造函数：

　　StringBuffer()

　　StringBuffer(int size)

　　StringBuffer(String str)

　　StringBuffer(CharSequence chars)

　　(1)、length()和capacity()

　　　　一个StringBuffer当前长度可通过length()方法得到,而整个可分配空间通过capacity()方法得到。

　　(2)、ensureCapacity() 设置缓冲区的大小

　　　　void ensureCapacity(int capacity)

　　(3)、setLength() 设置缓冲区的长度

　　　　void setLength(int len)

　　(4)、charAt()和setCharAt()

　　　　char charAt(int where)

　　　　void setCharAt(int where,char ch)

　　(5)、getChars()

　　　　void getChars(int sourceStart,int sourceEnd,char target[],int targetStart)

　　(6)、append() 可把任何类型数据的字符串表示连接到调用的StringBuffer对象的末尾。

　　　　例：int a=42;

　　　　　　StringBuffer sb=new StringBuffer(40);

　　　　　　String s=sb.append("a=").append(a).append("!").toString();

输出：a=42!

　　(7)、insert() 插入字符串

　　　　StringBuffer insert(int index,String str)

　　　　StringBuffer insert(int index,char ch)

　　　　StringBuffer insert(int index,Object obj)

　　　　index指定将字符串插入到StringBuffer对象中的位置的下标。

　　(8)、reverse() 颠倒StringBuffer对象中的字符

　　　　StringBuffer reverse()

　　(9)、delete()和deleteCharAt() 删除字符

　　　　StringBuffer delete(int startIndex,int endIndex)

　　　　StringBuffer deleteCharAt(int loc)

　　(10)、replace() 替换

　　　　StringBuffer replace(int startIndex,int endIndex,String str)

　　(11)、substring() 截取子串

　　　　String substring(int startIndex)

　　　　String substring(int startIndex,int endIndex)

输入输出

1、输入：

从键盘输入需要用到java的Scanner这个util包下的工具类

Scanner中输入是需要对输入的字符进行分类，int类型为nextint()方法，double类型为nextDouble()方法，字符串类型为next()方法。

#code：

#out:

2、输出：

java常用的输出为println

#code:

#out:

除了println()方法之外，java还有print()和printf()两种输出方法，

print、println、printf的区别：

print--是函数，可以返回一个值，只能有一个参数。

println 将它的参数显示在命令窗口，并在结尾加上换行符，将输出光标定位在下一行的开始。

printf--函数，把文字格式化以后输出，直接调用系统用进行IO的，他是非缓冲的

控制流程

Java流程控制包括顺序控制，条件控制，循环控制。

  顺序控制，就是从头到尾依次执行每条语句操作。条件控制，基于条件选择执行语句，比方说，如果条件成立，则执行操作A，或者如果条件成立，则执行操作A，反之则执行操作B。循环控制，又称为回路控制，根据循环初始条件和终结要求，执行循环体内的操作。

  顺序结构只能顺序执行，不能进行判断和选择，因此需要分支结构。

  Java有两种分支结构：

if语句

switch语句

  Java中有三种主要的循环结构：

while循环

do…while循环

for循环

数组

1、数组的定义

语法有两种：

type arrayName[];

type[] arrayName;

type 为Java中的任意数据类型，包括基本类型和组合类型，arrayName为数组名，必须是一个合法的标识符，[ ] 指明该变量是一个数组类型变量。

例如：

int demoArray[];

int[] demoArray;

这两种形式没有区别，使用效果完全一样，读者可根据自己的编程习惯选择。

注意：Java在定义数组时并不为数据元素分配内存，因此[ ]中无需指定数组元素的个数，即数组长度。而且对于如上定义的一个数组是不能访问它的任何元素的，开发者必须要为它分配内存空间，这时要用到运算符new，其格式如下：

    arrayName=new type[arraySize];

其中，arraySize 为数组的长度，type 为数组的类型。如：

demoArray=new int[3];//为一个整型数组分配3个int 型整数所占据的内存空间。

2、数组的初始化

可以在声明数组的同时进行初始化（静态初始化），也可以在声明以后进行初始化（动态初始化）。例如：

// 静态初始化

// 静态初始化的同时就为数组元素分配空间并赋值

int intArray[] = {1,2,3,4};

String stringArray[] = {"zhidao", "baidu", "百度知道"};

// 动态初始化

float floatArray[] = new float[3];

floatArray[0] = 1.0f;

floatArray[1] = 132.63f;

floatArray[2] = 100F;

3、数组的使用：

每个数组都有一个length属性来指明它的长度，例如 intArray.length 指明数组 intArray 的长度。

【示例】写一段代码，要求输入任意5个整数，输出它们的和。

import java.util.*;

public class Demo {

    public static void main(String[] args){

        int intArray[] = new int[5];

        long total = 0;

        int len = intArray.length;

        // 给数组元素赋值

        System.out.print("请输入" + len + "个整数，以空格为分隔：");

        Scanner sc = new Scanner(System.in);

        for(int i=0; i<len; i++){

            intArray[i] = sc.nextInt();

        }

        // 计算数组元素的和

        for(int i=0; i<len; i++){

            total += intArray[i];

        }

        System.out.println("所有数组元素的和为：" + total);

    }

}

运行结果：

请输入5个整数，以空格为分隔：10 20 15 25 50

所有数组元素的和为：120