JAVA零基础入门

JAVA入门知识点总结

1．JAVA的特点：

1简单易用、完全面向对象；

2与平台无关性、可扩展性强；

3可移植性高、支持分布式编程；

4健壮、安全可靠并性能优异；

5支持多线程开发技术；

6支持动态开发。

2.JVM：Java虚拟机（JVM是Java实现跨平台的基础）。

Java的源程序（*.java）                                 编译（命令：java+文件名.java）                        Java字节码（*.class  编译时自动形成，与源程序名一致)             运行（命令：java+源程序的文件名）          JVM（Windows、Linux)

        开发工具，Javac及基础核心类

JDK

        运行环境，Java及基础核心类

3.编写第一个Java程序：

Java源文件扩展名为：”.java”

一个源文件中最好只有一个java类，但是可以包含多个类

public修饰的类，文件名与类名必须一致(包括大小写)

被运行的类中需要有一个方法：                              

public static void main(String[ ] args){}

一个源文件中最多有一个public修饰的类

例如：public class  Test{

    public  static void  main(String  args[]){

         System.out.println(“这个编写的第一个java程序！！！”);
}

}

在运行程序之前先配置环境变量：

path变量值为：JDK安装目录下\bin;

classpath变量值为：JDK安装目录下\lib; 或  .;JDK安装目录下\lib\tools.jar

在dos命令窗口中输入以下命令进行运行：

编译命令：javac Test.java

运行命令：java Test

生成文档命令：javadoc Test.java

4.Java编程规范

A、命名规定

包 ：包名应该是小写的名词。

如：package shipping.objects

类：类名应该是名词，大小写混合，每个单词的首字母大写。

如：class AccountBook

接口：接口名的大小写应该与类名一样。

如：interface Account

方法：方法名应该动词，大小写混合，首字母小写。每个方法名中，以大写字母区分单词。限制使用下划线。

如：balanceAccount( )

变量：所有的变量应该是大小写混合，首字母小写。由大写字母区分单词。限制下划线的使用。

如：currentCustomer

常数：基本类型常数应该是全部大写的由下划线区分的单词。

如：HEAD_COUNT、MAXIMUM_SIZE、MIN_VALUE

B、程序主体结构规定

控制结构：所有语句，即使是一条语句，如果是某控制结构的一部分，都要使用大括号（{ }）括起来。

空格：在任意行上只放置一条语句，并且使用2或4个空格缩进使代码更易读。

Java代码的位置：所有代码都存在于一个类里

例如：修饰符 class 类名

              {

程序代码

              }

注意：

Java是严格区分大小写的；

功能执行语句以(;)结束，这个分号必须是英文输入法中的(;)；

连续的字符串不能换行，可使用(+)连接。

5、Java代码的注释

作用：

1)、解释程序中某些部分的作用和功能，提高程序的可读性。

2)、可以使用注释暂时屏蔽某些语句，在程序调试时使用。

注释的形式：

1)、单行注释

int c = 10; // 定义一个整型

2)、多行注释

/*

int c = 10; // 定义一个整型

int x = 5;

*/

 注意：/*…*/中可以嵌套”//”注释，但不能嵌套”/*…*/”。

3)、文档注释

“/** ...............*/”。

6、Java中的标识符

1)、变量，方法，类和对象的名称都是标识符，程序员需要标识和使用的东西都需要标识符。

2)、在Java语言里标识符以字母或下划线、$符号开头，后面字符可以是字母、数字、下划线、$符号。（其他符号都不能用来命名标识符）

3)、标识符对字母大小写非常敏感，必须区分大小写，但是没有长度限制。

4)、关键字不能用作标识符命名。

5)、标识符中不能包含空格。

6)、标识符是由Unicode字符组成的，因此可以使用汉字作为标识符(不推荐，尽量不用)；7、关键字

Java中一些赋以特定的含义、并用做专门用途的单词称为关键字，也可叫保留字。关键字不能作为普通的标识符使用。

所有Java关键字都是小写的，IF、THIS、NEW等都不是Java关键字；

goto和const虽然从未使用，但也作被为Java保留关键字；

关键字含义说明：

                boolean:布尔值

                 byte:字节                           false：布尔值假

                  char:字符类型                 字面值   null:空

                  int:整型                            true:布尔值真

基本数据类型

                  long:长整型

                 short:短整型                           const

                  float:单精度型            保留字

                  double:双精度型                         goto

                  void:无类型

                                                 

           abstract:抽象                             

            private:私有                                 

            public:公有

            static:静态

  修饰符    final:定义常量

            native:Java调用别的语言（C++）程序时使用

            volatile:短暂

            transient:短暂

            synchronized:处理线程是使用

              try:异常处理                                    break:退出循环

                catch:捉异常                                   case:流程控制语句

   异常处理    finally:无论有没有                               continue:循环继续

              throw:抛出异常                                 default:缺省

               throws:抛出异常                                 do:循环语句

                                              控制语句        while:循环语句

            class:类                                          if:条件语句

              extends:继承                                     else:条件语句

              implements:实现接口                              for:for循环语句

             instanceof:引入包                                 return:返回

             interface:判断一个对象是否属于某个类              switch:条件判断

面向对象      new:创建新对象

               package:包

               super:超类

               this:自己

 

8、java基本数据类型

                                    整数类型(byte,short, int, long)

 

 

                           数值型     浮点类型(float, double)

 

 

            基本数据类型       字符型(char)

          

                           布尔型（boolean）

 

数据类型                      类(class)

 

                             接口(interface)               

         引用(复合)数据类型

                                 数组

                                               

                                 字符串（String）

 

基本数据类型包括：整型、浮点型、字符型、逻辑型（布尔型）。

数据类型

名称

位长

默认值

取值范围

布尔型

boolean

1

false

true,false

字节型

byte

8

0

-128~127

字符型

char

16

‘\u0000’

‘\u0000’~‘\uffff’

短整型

short

16

0

-32768~32767

整型

int

32

0

-2147483648~2147483647

长整型

long

64

0

-9223372036854775808~9223372036854775807

浮点型

float

32

0.0

±1.4E-45~±3.4028235E+38

双精度型

double

64

0.0

±4.9E-324~±1.7976931348623157E+308

注意：

整数类型数据用于描述一个一定大小范围内的整数。

浮点类型数据用于描述一个范围很大的实数；

浮点类型数据有一定的精度限制。

字符类型为char，它用于表示一个字符,使用单引号’在 Java中char类型为16字节，采用Unicode表示。

逻辑类型为boolean，它用于表示真和假；boolean类型只有两个值真(true), 假(false)；

boolean类型有自己的运算，不能参与其他数据类型之间的运算。

9、常量

常量就是程序里持续不变的值，是不能改变的数据。

声明常量的格式如下：

final 类型 常量名[，常量名]=值；

Java中的常量包括整型常量、浮点型常量、布尔常量、字符常量等。

整型常量：

十进制：不能以0开头，多个0～9之间的数字

十六进制: 以0x或0X开头  0x8a   0X56d

八进制：必须以0开头   034    0376

长整型：必须以L结尾  87L   345L

浮点数常量：

float型：2e3f   0.6f  

double型：4.1d   1.23d

布尔常量：true 和 false

字符常量： ‘a’   ‘5’  

字符串常量：“hello”    “8698”    “\nmain”  转义字符\n表示换行

null常量：null，表示对象的引用为空。

10、变量

在java语言中存储一个数据信息，必须将它保存到一个变量中。变量在使用前必须有定义，即有确定的类型和名称。

声明变量的语法：

类型  变量名[, 变量名][=初值];

例如：int  i； char  c;  float a,  b,  c;

变量的声明有三种形式：

1、声明变量。

例如: int i;

2、变量赋值。在变量赋值之前要先声明变量。

例如：int i;

      i=5;

3、变量的初始化。

例如：int i = 8;

11、基本数据类型之间的兼容性

基本数据类型之间的转换：“小”的数据类型可以直接赋给“大”的数据类型。“大”的不能赋值给“小”的数据类型（会出现编译错误）。

数据类型大小关系如下：

整数类：long >int > short > byte  

浮点型：double >float

整型数据类型可以赋给浮点数据类型比如：

float      short       float     int   float      long    double   long   

注意：

char 可以赋给long和int ，但是不能赋给short 和byte（编译错误） 。

char 可以赋给float和double。

当整数型常量被声明为long类型时，只能赋值给long型变量。

当整数型常量在0~65535之间时，可以被赋值给char型变量。

char型常量可以被赋值给整数类变量，只要整数变量的类型可以容纳char型文字常量所表示的数值。

浮点型常量默认为double型，而double型常量不能赋值给float型变量。

boolean与其他数据类型没有兼容性。

12、数据类型转换

1、自动类型转换（隐式类型转换）

需要同时满足两个条件：

1)、两种类型彼此兼容

2)、目标类型的取值范围要大于源类型

2、强制类型转换（显示类型转换）

当两种类型不兼容，或目标取值类型范围小于源类型时，自动类型转换无法进行，需要进行强制类型转换。

数据类型强制转换的格式为：

（数据类型）数据表达式；

例如：int i = 5;  byte b = (byte)i;

13、变量的作用域

变量的作用域指一个变量起作用的范围，它决定了一个变量何时可以访问、何时不可以访问。Java中任何变量的作用域都从该变量声明之后开始，并且只在该声明的语句块中使用，也就是该变量只能在声明它的那个花括号{}中使用。

变量有分为成员变量和局部变量。

成员变量：在类中声明的变量称为成员变量，又叫全局变量。

使用范围：通常在类开始处声明，可在整个类中使用。

局部变量：在方法或块（块由两个花括号）中声明的变量称为局部变量。

使用范围：从声明处开始到它所在方法或块的结束处。

例：

{
int x = 4;
//这之间只有x可以访问
int y = 1;
//x和y可以访问
{
int z = 2;
//x、y、z都可以访问
z = 5;
}
x = 4；
//只有x和y可以访问，不可以访问z

} 

14、Java中的运算符

算术运算符、关系运算符、赋值运算符、逻辑运算符、位运算符、条件运算符

1)、算术运算符

运算符

运算

范例

结果

+

正号

+3

3

-

负号

b=4;-b;

-4

+

加

5+5

10

-

减

6-4

2

*

乘

3*4

12

/

除

5/5

1

%

取模（求余）

5%5

0

++

自增（前）

a=2;b=++a;

a=3;b=3;

++

自增（后）

a=2;b=a++;

a=3;b=2;

--

自减（前）

 a=2;b=--a;

a=1;b=1;

--

自减（后）

a=2;b=a--;

a=1;b=2;

+

字符串相加

“he”+“llo”

 “hello”

两个整数之间的相除（/）运算结果还是整数，其结果是除的结果的整数部分。

例如：5/2结果为2

要获得实数结果，运算中至少一个浮点数。

例如：5/2.0结果为2.5

2)、关系运算符

运算符

运算

范例

结果

==

相等于

4==3

false

!=

不等于

4!=3

true

< 

小于

4<3

false

> 

大于

4>3

true

<=

小于等于

4<=3

false

>=

大于等于

4>=3

true

3)、赋值运算符

运算符

运算

范例

结果

=

赋值

a=3;b=2;

a=3;b=2;

+=

加等于

a=3;b=2;a+=b;

a=5;b=2;

－=

减等于

a=3;b=2;a－=b;

a=1;b=2;

*=

乘等于

a=3;b=2;a*=b;

a=6;b=2;

/=

除等于

a=3;b=2;a/=b;

a=1;b=2;

%=

模等于

a=3;b=2;a%=b;

a=1;b=2;

4)、逻辑运算符

运算符

运算

范例

结果

&

AND(与)

false & true

false

|

 OR(或)

false | true

true

^

XOR(异或)

false ^ true

true

!

NOT(非)

!true

false

&&

AND(短路与)

false && true

false

||

OR(短路或)

false || true

true

在使用短路与（&&）时，如果第一个操作数（或表达式）为“假”，则不再计算第二个操作数（或表达式），直接返回“假”。

在使用短路或（||）时，如果第一个操作数（或表达式）为“真”，则不再计算第二个操作数（或表达式），直接返回“真”。

逻辑运算符只能用于布尔（boolean）类型之间；其结果值为布尔（boolean）类型。

5)、位运算符

运算符

运算

计算规则

&

按位与

只有参加运算的两位都为1，‘&’运算的结果才为1，否则为0。

|

按位或

只有参加运算的两位都为0，‘|’运算的结果才为0，否则为1。

^

按位异或

只有参加运算的两位不同，‘^’运算的结果才为1，否则为0。

<< 

左移位

左移指定位数，右边补0。

>> 

右移位

右移高位是0，左边补0；高位是1，左边补1。

>>> 

无符号右移位

左边补0。

～

按位取反

1取反是0,0取反是1。

位运算符只可用于整数类型、char类型，不可应用于浮点类型。

6)、条件运算符

条件运算符是一个三目运算符，也是唯一的一个三元运算符，符号为“? :”,在程序中能实现简单的判断功能。

语法格式：

表达式1?表达式2:表达式3

其中表示1是一个布尔表达式，如果表达式1结果为true，则执行表达式2，否则执行表达式3。

举例说明：求a，b的最大值。

int a=4,b=6,max;

max=a>b?a:b;//将a和b中的较大值赋给max

15、Java中的控制语句

（1）、if(表达式)......else.......条件语句；

（2）、for（表达式）.......       循环语句；

（3）、while（表达式）.......     循环语句；

（4）、do.....while(表达式）......循环语句；

（5）、switch                多分支选择结构；

（6）、continue              结束本次循环语句；

（7）、break                终止执行switch或循环语句；

（8）、return               从方法返回语句。

1、条件语句

分为四种：

  单分支条件语句

语法格式为：if(条件表达式){

                语句或语句块；

}

  二分支条件语句

语法格式为：if(条件表达式){

                语句或语句块1；

}else{

   语句或语句块2；

}

  嵌套条件语句

语法格式为：if(条件表达式){

                if(条件表达式){

                  语句或语句块；

}

}else{

   语句或语句块2；

}

  多分支条件语句

语法格式为：if(条件表达式1){

                语句或语句块1；

}else if(条件表达式2){

   语句或语句块2；

} ……

   ……

} else if(条件表达式n){

   语句或语句块n；

}else{

   语句0；

}

2、for循环语句

语法格式为：for(变量初始化表达式；循环条件表达式；迭代部分)

｛

语句或语句块；//循环体

                  ｝

for循环有一个特殊的循环，叫死循环。表现形式为：

boolean  isOk = true;       或    for(;;){}

for(;isOk;){} 

for循环可以再嵌套for循环。

注意：在for循环的初始化或迭代部分，可以有多个表达式，表达式之间用逗号隔开。例如：   int count =0;

for(int a= 1,b=10;a<b;a++,b－－){

   count++;

      }  共循环多少次？

3、while循环语句

语法格式为：while(循环条件表达式)｛

                      语句或语句块；

              ｝

4、do-----while循环语句

语法格式为：do{

               语句或语句块；

｝while(表达式)；（注意分号绝对不能省略）

 

5、switch-----case多分支选择语句

语法格式为：switch(条件表达式)｛

                    case 常量1:

                      语句1；

break;

case 常量2:

                      语句2；

break;

……

                    case常量N:

                      语句N;

                     break;

[default:语句;break;]

}

注意：

  条件表达式的返回值类型必须是以下类型之一：int、byte、char、short。

  case子句中的值常量N必须是常量，而且所有case子句中的值应是不同的。

  default子句是可选的。

  break语句用来在执行完一个case分支后，是程序跳出switch语句，即终止switch语句的执行。

  在一些特殊情况下，多个不同的case值要执行一组相同的操作，这时可以不用break。

6、continue结束本次循环语句

使用continue语句可以立刻重新开始下一轮的循环，而不再执行循环后面的语句。

7、break终止执行switch和循环语句

使用break语句可以立刻终止循环，开始执行循环后面的语句。

8、return从方法返回语句

return语句主要作用是退出当前方法，将程序控制转移到方法的调用者。

一般格式为： return [值或表达式]；

16、方法调用语句

方法调用语句是执行对象的某个方法。

一个完整的方法调用语句由某个方法调用加上一个分号构成。

调用语法格式为：类对象名称.方法名（参数）;

例如：

     System.out.println(“This is astatement call a method!”);

     调用对象System.out的println方法。

17、表达式语句

表达式语句就是由一个表达式加一个分号构成的语句。

例如常见的赋值语句：i=i+1;而i=i+1只是一个表达式。

18、空语句

空语句就是只有一个分号构成的语句。例如：  ;

19、复合语句

复合语句又叫块，由{}将一些语句括起来就构成一个复合语句。

例如：{

          a=b+c;

          t=a*100;

}

20、数组

（1）定义：是用来存储一组或多组相同类型数据的数据类型。

（2）数据类型：可以是基本数据类型（例如：数字型、字符型、布尔型），也可以是复合数据类型（例如：数组、类、字符串和接口）。

 ※数组本身就是一种复合数据类型，因此，数组的元素也可以是数组，这样就构成了二维数组和多维数组。

（3）数组作为复合数据类型，与基本数据类型最大的区别：

数组是通过引用来控制的，而基本数据类型是通过值来控制的。

1、一维数组的声明：

   格式： 类型 数组名[];   或  类型[ ] 数组名;

   举例：int a[];  String[ ] b;

数组的初始化有两种方法：一种是直接初始化，另一种是动态初始化。

  直接初始化

格式： 类型  数组名[ ] = { 值1，值2，…，值n};

举例：int a[ ] ={1,2,3};      

             int b[];   b = {1,2,3};

  动态初始化：

格式：

（1）声明时初始化：

    类型 数组名[ ] = new 类型[ 数组长度];

（2）声明后初始化：

类型  数组名[ ];  

            数组名 = new 类型[数组长度];

2、访问数组元素

数组元素是通过数组名和下标来访问。未被初始化的数组，不能进行访问。

格式：数组名[下标]

Java中，数组的下标从0开始，直到 <数组长度-1>结束。

获得数组的长度，通过length属性来获得。

3、数组的复制

   方法：

      System.arraycopy(源数组,源数组起始位置,目标数组,目标数组起始位置,长度)；

     ★注：不管是要复制的数组，还是被复制的数组，都必须先初始化。

举例：

     int a[ ] = {1,2,3},b[ ] = new int[3];

    System.arraycopy(a,0,b,0,3); //将数组a复制到b

4、对象数组：

 举例：

//定义一个对象数组，StringBuffer是一个字符串缓存类

StringBuffer a[ ] =new StringBuffer[2];

//给对象赋值

a[0] = newStringBuffer(“Array[0]”);

a[1] = newStringBuffer(“Array[1]”);

System.out.println(“a[0]=” + a[0] + “ a[1]=” + a[1] );

a[0].append(“ is Modified”); //追加字符串

System.out.println(“a[0]=” + a[0]);

5、二维数组和多维数组

前面提到过，数组的元素也可以是数组，如果一个数组的每一个元素都是一个一维数组，这样就构成一个二维数组。

    定义格式：类型  数组名[ ][ ];  或  类型[ ][ ] 数组名;

    举例： int a[ ][];            double[ ][ ] b;

这几种定义不合法：inta[2][ ];     int b[ ][2];    int c[2][2];

二维数组的初始化：二维数组的初始化也有直接和动态初始化两种方式。

  直接初始化格式：  类型  数组名[][]= {{ 值1，值2，…，值n} ,{ 值1，值2，…，值n}....}; 

          举例：int a[ ][] = {{1,2,3},{4,5,6},{7,8,9}};

  动态初始化格式

1类型 数组名=new 类型[长度1][长度2]；   长度1表示行，长度2表示列。

        举例：inta[][]=new[3][5];

2类型 数组名=new 类型[长度1][]；

数组名[0]=new 类型[长度20];

数组名[1]=new 类型[长度21];

……

数组名[长度1-1]=new 类型[长度2n];

举例：int a[][];

      a=new int[3][];

a[0]=new int[5];

      a[1]=new int[8];

      a[2]=new int[6];

6、二维数组的应用

举例：两个矩阵相乘的例子。

//声明并初始化数组

       int a[ ][ ] = {{8,13},{4,7},{5,2}};

       int b[ ][ ] = {{3,4,11},{6,1,10}};

       int result[ ][ ] = new int[3][3];

       int i,j,k;

       //通过嵌套循环实现矩阵相乘的运算

       for(i=0;i<a.length;i++){

            for(j=0;j<b[0].length;j++){

                     result[i][j] = 0;

                    for(k=0;k<b.length;k++){

                           result[i][j] +=a[i][k] * b[k][j];

                     }

               }

         }

       //打印结果

       System.out.println(“The resultof a * b is : ”);

       for(i=0;i<result.length;i++){

            for(j=0;j<result [i].length;j++){

                   System.out.print(result[i][j]+ “   ”);

             }

             System.out.println( ); //换行 }

7、一维数组的应用

例1：将整数序列{3,15,28,11,34,78,95,27,18}首末颠倒过来。

int a[ ] ={3,15,28,11,34,78,95,27,18};

      int i, length, temp;

      length = a.length;

      for(i=0;i<(length/2);i++){

        //以下将数组元素a[i]和a[length-1 - i]的值互换

        temp= a[i];

             a[i] = a[length -1 –i];

             a[length -1 –i] = temp;

      }

      for(i=0;i<length;i++){

        System.out.print(a[i]+ “   ”);

     }

例2：从数据：32  25  78 69  13  97  86 38  62  9 中找到数据97所在的位置。

『用顺序查找（线性查找）方法编写程序』。

//声明并初始化数组

int  a[ ] = {32,25,78,69,13,97,86,38,62,9}; 

int index = -1,i;

//逐个元素与97相比较，找到则退出循环，否则继续

for(i=0;i<a.length;i++){

  if(a[i] == 97){

           index = i;

       break;

  }

}   

if(index == -1){ //表示该数不存在

  System.out.println(“ 97这个数不存在！”);

}else{

  System.out.println(“97这个数的下标是: ” + index);

}

例3：将数据：37   28   51  13   64为例，用『冒泡法』进行升序排列。 

下面编写程序代码：(冒泡法)

     int a[ ] = {37,28,51,13,64};

     int i, j, n, temp;

     n = a.length;

     for(j=1;j < n ;j++ ){ //共执行 n－1 轮

          for(i=0;i< n – j; i++){ //第j轮

               if (a[i] > a[i+1]){

                     //交换a[i]与a[i+1]的值

                     temp = a[i];

                     a[i] = a[i+1];

                     a[i+1] = temp;

               }

          }

     }

     //打印排序后的结果

     for(i=0;i < n;i++){

          System.out.print(a[i] + “    ”);

     }