1.语句与语句块
语句：java以;为分隔符，每个带有分隔符的句子为一个语句。
语句块：为｛｝里面的语句的集合。

2.注释
a.   //单行注释
  
b  ./*多行注释 */ 

c./**文档注释 */
表示在/**和*/之间的文本，将自动包含在用javadoc命令生成的HTML格式的文档中。
javadoc是JDK中API文档生成器。该工具解析一组Java源文件中的声明与文档注释，生成一组
HTML页面描述这些源程序中定义的类，内部类，接口，构造方法，方法与属性。JDK的API文档
就是用javadoc工具生成的。

3.标识符及字符集

a.Java标识符总结：

1）.由字母、数字、_或$组成，不能以数字开头；

2）.严格区分大小写；

3）.长度不限

4）.关键字（即我们在jc中打字会出现蓝色的那些词）不能作为标识符。

b.为增强程序可读性，Java作如下的约定：
1）.类、接口：通常使用名词，且每个单词的首字母要大写

2）.方法：通常使用动词，首字母小写，其后用大写字母分隔每个单词

3）.常量：全部大写，单词之间用下划线分隔

4）.变量：通常使用名词，首字母小写，其后大写字母分隔每个单词，避免使用$符号。

c.字符集

 1）Java语言使用国际字符集（Unicode）

 2）Unicode特点：

①Unicode字符集中的每个字符占16位（通常的ASCII码是8位的），即2个字节，整个字符集共包括65336个字符。
②其兼容ASCII，且排在Unicode字符集最前面的256个字符就是ASCII码。
③Unicode除了可以表示256个ASCII码外，还可以表示汉字、拉丁语、希腊字母、朝鲜语等。

5.基本数据类型
①java定义了四类共8种基本类型：
逻辑性：boolean
文本型：char
整型：byte，short，int，long
浮点型：double和float

②对基本数据类型的深入理解：
1）.char是文字型的基本数据类型（‘‘)，而String是类不是基本类型。
2）.字符串在java中是对象，在java中有两个类可以表示字符串：String和StringBuffer。
String对象表示的字符串是不能修改的。如果需要对字符串修改应该使用StringBuffer.
3）.整型类型之所以分为四种，是因为其代表的整数范围不同，最左边的范围最小，最右边的范围最大。
如果一个数超过了计算机的表达范围，称为溢出；如果超出最大值，称为上溢；如果超过最小值，称为
下溢。将一个整型类型数的最大值加一，产生上溢其会变成同类型的最小值，最小值减1，溢出其会变成
同类型的最大值。
4）.“整型常量”可以有三种形式，十进制，八进制和十六进制。一般先写十进制再进而转换。其实八进制整数以0为前导，
十六进制整数以0X或ox为前导。整型常量的默认状态是int，对于long型常量，则要在数值后加L或l，因为小写l看起来像1，
为了避免误会，一般采用大写。
5）.双精度类型double比单精度类型float具有更高的精度和更大的表示范围，但float类型具有速度快，占用内存小的优点。
浮点型变量的默认初值是0.0（默认double类型）.当出现下溢，则返回0.0。出现上溢，，则结果为正或负无穷大。
6）char和String都表示常量。

③各种表格总集

④简单类型对应的封装器类

注意：Java基本类型存储在栈中，因此他们的存储速度要快于存储在堆中的对应包装类的实例对象。JVM可以完成基本类型和它们对应包装类之间

           的自动转换。因此我们在赋值，参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类，但基本类型不可调用他们的包装类才            具有的方法。另外，所有基本类型（包括void）的包装类都是用了final修饰，因此我们无法继承它们扩展新的类，也无法重写他们的任何方              法。

⑤简单数据类型之间的转换

a.方式有自动转换和强制转换

（说明：小?大  byte，short，char，int，long，float，double）

 b.自动转换

(1)类型（四种类型）：

i.当一个较“小”数据与一个较“大”的数据一起运算时，系统将自动将“小”数据转换成“大”数据，再进行运算。

 （注意：int到float，long到float，long到double是不会自动转换的，不然将会丢失精度）

ii.在方法调用时，实际参数较“小”，而被调用的方法的形式参数数据又较“大”时（若有匹配的，当然会直接调用匹配的方法），系统也将

自动将“小”数据转换成“大”数据，再进行方法的调用。

iii.对于多个同名的重载方法，会转换成最“接近”的“大”数据并进行调用。

iiii.引用类型能够自动转换为父类的。

注意：这边的大小为值的范围大小。

（对上述的总结进行特别说明：

1）下面的语句可以在Java中直接通过：

byte b;int i=b; long l=b; float f=b; double d=b;

2）如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如

char c=‘c‘; int i=c;

System.out.println("output:"+i);输出：output:99;

3）对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。

short i=99 ; char c=(char)i; System.out.println("output:"+c);输出：output:c;

）

c.强制转换（用圆括号括起来目标类型，置于变量前）

将"大"数据转换为"小"数据时，你可以使用强制类型转换。即你必须采用下面这种语句格式： int n=(int)3.14159/2;可以想象，这种转换肯定可能会导致溢出或精度的下降。

补充（可进行简单了解）

1)包装类过渡类型转换

一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了。例如：

①当希望把float型转换为double型时：

float f1=100.00f;

Float F1=new Float(f1);

double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法

②当希望把double型转换为int型时：

double d1=100.00;

Double D1=new Double(d1);

int i1=D1.intValue();
方法的说明：
（1. 在进行简单类型的变量转换为相应的包装类，利用了包装类的构造函数（不单单只可以这一种，还有其他，不过这边不说）
即：Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)

2.各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。
利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。
）

2)字符串与其它类型间的转换

其它类型向字符串的转换

①调用类的串转换方法:X.toString();

②自动转换:X+"";

③使用String的方法:String.volueOf(X);

字符串作为值,向其它类型的转换

①先转换成相应的封装器实例,再调用对应的方法转换成其它类型

例如，字符中"32.1"转换double型的值的格式为:new Float("32.1").doubleValue()。也可以用:Double.valueOf("32.1").doubleValue()

②静态parseXXX方法

String s = "1";

byte b = Byte.parseByte( s );

short t = Short.parseShort( s );

int i = Integer.parseInt( s );

long l = Long.parseLong( s );

Float f = Float.parseFloat( s );

Double d = Double.parseDouble( s );

③Character的getNumericValue(char ch)方法

3）Date类与其它数据类型的相互转换

整型和Date类之间并不存在直接的对应关系，只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，在作这种转换时，你可以使用Date类构造函数的三种形式：

①Date(int year, int month, int date)：以int型表示年、月、日

②Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分

③Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、分、秒

在长整型和Date类之间有一个很有趣的对应关系，就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。对于这种对应关系，Date类也有其相应的构造函数：Date(long date)。

获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以将其理解为将Date类转换成int。

而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，与包装类一样，Date类也有一个toString()方法可以将其转换为String类。

有时我们希望得到Date的特定格式，例如20020324，我们可以使用以下方法，首先在文件开始引入，

import java.text.SimpleDateFormat;

import java.util.*;

java.util.Date date = new java.util.Date();

//如果希望得到YYYYMMDD的格式

SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMDD");

String dateFormat=sy1.format(date);

//如果希望分开得到年，月，日

SimpleDateFormat sy=new SimpleDateFormat("yyyy");

SimpleDateFormat sm=new SimpleDateFormat("MM");

SimpleDateFormat sd=new SimpleDateFormat("dd");

String syear=sy.format(date);

String smon=sm.format(date);

String sday=sd.format(date);

总结：只有boolean不参与数据类型的转换

6.符合数据类型—类和接口

概念：可以通过一个载体去引用和设置数值的这个载体为符合数据类型。

7.基本类型变量与引用类型变量。
a.引言：基本数据类型分为两大类：基本数据类与复合数据类型。而变量也有两种类型：基本类型与引用类型。
b.概念：
1）基本类型：使用了基本数据类定义的变量为基本类型。
2）引用类型：使用了复合数据类型定义的变量为引用类型。该变量为指向内存空间的引用地址（其他语言中说指针或内存地址），所指向
的内存中保存者变量所表示的一个值或一组值。

c.两种类型变量的处理方式
基本类型变量：系统直接給该变量分配空间，因此程序中可以直接操作。
（eg：int a;//分配了空间
a=3; //直接操作
）
引用类型变量：只是給该变量分配了引用空间，数据空间未分配，不能直接操作。
（eg：Mydata a；
a.day=14; //错误，因为其只是分配了引用空间，数据空间未分配
）

d.引用型变量的赋值
Mydata a，b； //定义了两个引用空间
a=new Mydata（）；
b=a； //使用了同个数据空间。

8.成员变量和局部变量

1）.概念：
成员变量：作为类的成员而存在，直接存在于类中。所有类的成员变 量可以通过this来引用。
局部变量：作为方法或语句块的成员而存在，存在于方法的参数列表和方法定义中。

2）.区别：
a..成员变量可以被 public，protect，private，static等修饰符修饰，而局部变量不能被控制修饰符及 static修饰；两者都可以定义成final型。
注意：局部变量，方法中定义，在方法中都可以使用，for循环中的局部变量，只能在for循环中利用。
b.成员变量存储在堆，局部变量存储在栈。局部变量的作用域仅限于定义它的方法，在该方法的外部无法访问它。成员变量的作用域在整个类内部都是可见的，所有成员方法都可以使用它。如果访问权限允许， 还可以在类的外部使用成员变量。

c.局部变量的生存周期与方法的执行期相同。 当方法执行到定义局部变量的语句时，局部变量被创建；执行到它所在的作用域的最后一条语句时，局部变量被销毁。类的成员变量，如果是实例成员变量，它和对 象的生存期相同。而静态成员变量的生存期是整个程序运行期。

d.成员变量有默认值，基本类型的默认值为 0，复合类型的默认值为null。（被final修饰且没有static的必须显式赋值），局部变量不会自动赋值，所以局 部变量在定义后先要赋初值，然后才能使用。

e.局部变量可以和成员变量 同名，且在使用时，局部变量具有更高的优先级。

注意：成员变量和成员静态变量的区别
创造多个相同的对象，有多个成员变量，但是只有一个成员静态变量，这个成员静态变量被多个对象应用。

9.运算符

10.流程控制语句

1）.循环语句
a.

while(条件判断语句）｛｝
只有false时，其才会跳出循环。

b.

do｛
}while(条件判断语句);
至少执行一次代码块，只有false时，其才会跳出循环。

c.for语句
for(初始语句；逻辑语句；迭代语句）｛
语句或语句块
｝

2.分支语句
a.

if（）｛｝
else{}

b.

if(){}
else if(){}
...
else{}

c.swich语句
swich(ch){

case c1:
语句块1；
break;

case c2;
语句块2；
break；
...

default:语句块
｝

/*说明：
1.swich中的数一定要和case之后的值相匹配
2.swich语句中各case分支即可以是单条语句，也可以多条语句。
3.当多个case表现同个语句块时，模式如下：
case c1:
case c2: 语句块
break;

4.当前面都没有执行到时，才会执行default或者之前没有使用break语句跳出语句。
5.无论执行哪一个分支，程序流都会顺序执行下来，直至遇到break语句为止。

3.循环跳转语句
（1）break语句
作用：

a.停止swich程序流
b.跳出循环

（2）continue语句
作用：跳过continue之后的语句块，执行下一次循环。

11.数组

引言：1.数组中的元素都是同一种类型。      

           2.数组的长度在创建时确定，且不可以更改。

       (如果想要动态变化，可以使用java.util包中的各种集合）

1.数组的声明方式

（1）int s[]

（2）Int[] s

（3）Int[] s,m,n     //声明多个变量

注意：声明方式只是給数组变量分配了一个可以引用该数组的引用空间。数据空间由后面的决定。

2.数组的创建与初始化

（1）.用new创建数组

初始化方式：直接一个一个初始化

（2）直接初始化创建数组：

               Int[] a=｛1，2，3，...，n};

3.数组的长度

   数组名.length

4.对象数组(数组不单单可以基本类型数组，还可以是对象数组）

  Eg：

  Point[] p=new Point[2];

   Int i=0;

  While(i<2){

      P[i]=new Point(i,i+1);

      i++;

}

5.多维数组

a.多维数组的声明：

   （1） int a[][]

     (2)   int[][] a

b.多维数组实例化(注意：在为每一个位置的数分配数时，把握住括号顺序一点一点画出来赋值就好，不要乱）

   （1）直接为每一维分配内存，创建规则数组。Eg：int a[][]=new int[4][4];

(2)从最高维起，分别为每一维分配空间，这种方式可以构造不规则数组。

   Eg: int[][] a=new int[2][];

      a[0]=new int[2] ; a[1]=new int[3];a[2]=new int[4];

例子：利用二维int型数组表达一个矩阵，创建该数组并将其元素打印输出。

6.增强的for循环

a.高级for循环格式：for（类型名 变量名 ： 被遍历的集合（Collection）或数组）

eg：

int[] arr = {1，2，3，4}；

for（int i ：arr）

{

       System.out.out(i);

}

B.传统for循环和高级for循环的区别 ：

高级for循环有一个局限性，必须有一个被遍历的目标

 （注意：建议在遍历数组的时候，还是希望用传统for，因为传统for有角标，可以有其他操作，但高级没有）

7.数组的复制

   使用java语言在java.lang.System类中提供的数组复制方法。

   该方法为：

public static void arraycopy(Object source,int srcIndex,Object dest, int destIndex,int length)

source:源数组

srcIndex:源数组开始复制的位置

dest:目的数组

destIndex:目的数组开始存放复制数组的位置

length:复制元素的个数

Java语言基础