JAVA基础复习day-01

1、基础语法

1.1、基础语法规则

1.1.1、Java代码实现

代码示例：

public class Hello{

public static void main(String[] args){

   System.out.println("hello man!");

}

}

Java源代码中的所有标点符号使用英文输入法状态输入；语法规则：

• Java源代码是区分大小写；
• 类名默认都使用大写；
• 一个.java源文件中可以声明多个类，但是只能有一个public修饰的类；
• 当声明的类使用public关键字修饰时，源文件名必须和类名保持一致；
• 类中可以继续声明类，称为内部类；

1.1.2、变量

代码示例：

public static void main(String[] args){

int a;

a = 1;

System.out.println(a/b);

}

声明语法：语法规则：

数据类型  变量名 ;

• 赋值：

变量名 = 值；

1.1.3、常量

常量在程序运行时是不能被修改的。

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

字面量可以赋给任何内置类型的变量。例如：

byte a = 68;

char a = 'A';

byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用常量的时候，前缀0表示8进制，而前缀0x代表16进制, 例如：

int decimal = 100;

int octal = 0144;

int hexa =  0x64;

和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：

"Hello World"

"two\nlines"

"\"This is in quotes\""

字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';

String a = "\u0001";

Java语言支持一些特殊的转义字符序列：

符号	字符含义
\n	换行 (0x0a)
\r	回车 (0x0d)
\f	换页符(0x0c)
\b	退格 (0x08)
\0	空字符 (0x20)
\s	字符串
\t	制表符
\"	双引号
\'	单引号
\\	反斜杠
\ddd	八进制字符 (ddd)
\uxxxx	16进制Unicode字符 (xxxx)

1.1.4、标识符

语法规则：

• 标识符是用于类名、变量名、方法名、对象名、数组名等的命名；
• 可以使用英文、数字、下划线_、$符号；
• 不能以数字开头；
• 不能使用Java关键字或保留字；
• 区分大小写；

1.1.5、注释

单行注释：

//这一行是注释

多行注释：

/*

* 多行注释

* 多行注释

*/

文档注释：

/**

* 这是一个文档注释

*/

说明：

• Java 支持三种注释方式。前两种分别是 // 和 /* */，第三种被称作说明注释，它以 /** 开始，以 */结束。
• 说明注释允许你在程序中嵌入关于程序的信息。你可以使用 javadoc 工具软件来生成信息，并输出到HTML文件中。
• 说明注释，使你更加方便的记录你的程序信息。

在开始的 /** 之后，第一行或几行是关于类、变量和方法的主要描述。

之后，你可以包含一个或多个各种各样的 @ 标签。每一个 @ 标签必须在一个新行的开始或者在一行的开始紧跟星号(*).

多个相同类型的标签应该放成一组。例如，如果你有三个 @see 标签，可以将它们一个接一个的放在一起。

下面是一个类的说明注释的实例：

/*** 这个类绘制一个条形图

* @author verycode

* @version 1.2

*/

javadoc 工具软件识别以下标签：

标签	描述	示例
@author	标识一个类的作者	@author description
@deprecated	指名一个过期的类或成员	@deprecated description
{@docRoot}	指明当前文档根目录的路径	Directory Path
@exception	标志一个类抛出的异常	@exception exception-name explanation
{@inheritDoc}	从直接父类继承的注释	Inherits a comment from the immediate surperclass.
{@link}	插入一个到另一个主题的链接	{@link name text}
{@linkplain}	插入一个到另一个主题的链接，但是该链接显示纯文本字体	Inserts an in-line link to another topic.
@param	说明一个方法的参数	@param parameter-name explanation
@return	说明返回值类型	@return explanation
@see	指定一个到另一个主题的链接	@see anchor
@serial	说明一个序列化属性	@serial description
@serialData	说明通过writeObject( ) 和 writeExternal( )方法写的数据	@serialData description
@serialField	说明一个ObjectStreamField组件	@serialField name type description
@since	标记当引入一个特定的变化时	@since release
@throws	和 @exception标签一样.	The @throws tag has the same meaning as the @exception tag.
{@value}	显示常量的值，该常量必须是static属性。	Displays the value of a constant, which must be a static field.
@version	指定类的版本	@version info

1.1.6、运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

• 算术运算符
• 关系运算符
• 位运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

1.1.7、修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。

Java语言提供了很多修饰符，主要分为以下两类：

• 访问修饰符
• 非访问修饰符

（1）访问修饰符

• Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
• default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

我们可以通过以下表来说明访问权限：

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

规则：

• Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。
• protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。
• 父类中声明为 public 的方法在子类中也必须为 public。
• 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
• 父类中声明为 private 的方法，不能够被继承。

（2）非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符：

• static 修饰符，用来修饰类方法和类变量。
• final 修饰符：

n  当final修饰类时，当前类不能被继承；

n  当final修饰方法时，该方法不能被重写；

n  当final修饰变量时，变量的值不能被修改，即为常量；

• abstract 修饰符，用来创建抽象类和抽象方法。
• synchronized 和 volatile 修饰符，主要用于线程的编程。

1.1.8、方法的定义

（1）什么是方法

• Java方法是语句的集合，它们在一起执行一个功能。
• 方法是解决一类问题的步骤的有序组合。
• 方法包含于类或对象中。
• 方法在程序中被创建，在其他地方被引用。

（2）方法的优点

• 使程序变得更简短而清晰。
• 有利于程序维护。
• 可以提高程序开发的效率。
• 提高了代码的重用性。

（3）方法的命名规则

• 方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。
• 下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test<MethodUnderTest>_<state>，例如 testPop_emptyStack。

（4）方法的定义

语法：

修饰符 返回值类型 方法名(参数类型 参数名){

...

方法体

...

return 返回值;

}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

• 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
• 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
• 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
• 方法体：方法体包含具体的语句，定义该方法的功能。

示例：

public static int age(int birthday){...}

参数可以有多个：

static float interest(float principal, int year){...}

注意： 在一些其它语言中方法指过程和函数。一个返回非void类型返回值的方法称为函数；一个返回void类型返回值的方法叫做过程。

代码示例：

下面的方法包含 2 个参数 num1 和 num2，它返回这两个参数的最大值。

/** 返回两个整型变量数据的较大值 */

public static int max(int num1, int num2) {

int result;

if (num1 > num2)

result = num1;

else

result = num2;

return result;

}

（5）方法调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30, 40);

如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句：

System.out.println("Very Code！");

代码示例：

public class TestMax {

/** 主方法 */

public static void main(String[] args) {

int i = 5;

int j = 2;

int k = max(i, j);

System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);

}

/** 返回两个整数变量较大的值 */

public static int max(int num1, int num2) {

int result;

if (num1 > num2)

result = num1;

else

result = num2;

return result;

}

}

编译运行结果如下：

5 和 2 比较，最大值是：5

1.1.9、static关键字

用法：

• 当使用static关键字修饰方法时，该方法称为静态方法，即类的方法；
• 如果没有使用static关键字修饰，该方法为普通方法(实例方法)，即对象的方法；
• 静态方法中，只能直接调用静态方法；
• 实例方法中，可以直接调用静态方法，也可以直接调用实例方法；
• 静态方法中如果要调用实例方法，必须先实例化对象，使用对象名调用；

1.1.10、void关键字

用法：

• 当方法没有任何返回值时，方法声明语句中使用void关键字；
• 当方法有返回值时，返回值是什么数据类型，就声明为什么类型；

1.1.11、参数

语法：

• 在方法名后面的括号中声明；
• 参数的个数为大于等于0；
• 写法：方法名(类型  变量名,类型 变量名,……){}
• 参数是当前方法的局部变量，是一种特殊的局部变量；
• 参数的赋值过程，是在调用该方法时完成的；
• 当有多个参数，调用该方法时，依次按照括号中的顺序为参数赋值；
• 参数的类型可以为Java的任何数据类型；

1.1.12、方法重载

概念：重载(overloading) 是在一个类里面，方法名字相同，而参数不同。与返回值类型、访问修饰符无关。

规则：

• 参数的类型不同；
• 参数个数不同；
• 参数的顺序不同；

1.1.13、变量作用域

规则：

• 变量的范围是程序中该变量可以被引用的部分。
• 方法内定义的变量被称为局部变量。
• 局部变量的作用范围从声明开始，直到包含它的块结束。
• 局部变量必须声明才可以使用。
• 方法的参数范围涵盖整个方法。参数实际上是一个局部变量。
• for循环的初始化部分声明的变量，其作用范围在整个循环。
• 但循环体内声明的变量其适用范围是从它声明到循环体结束。
• 可以在一个方法里，不同的非嵌套块中多次声明一个具有相同的名称局部变量，但不能在嵌套块内两次声明局部变量。

1.1.14、源文件声明规则

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意以下规则：

• 一个源文件中只能有一个public类。
• 一个源文件可以有多个非public类。
• 源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
• 如果一个类定义在某个包中，那么package语句应该在源文件的首行。
• 如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
• import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

1.1.15、Java包

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用：

• 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
• 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
• 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

包语句的语法格式为：

package pkg1[．pkg2[．pkg3…]];

例如,一个Something.java 文件它的内容

package net.java.util;

public class Something{

...

}

那么它的路径应该是 net/java/util/Something.java 这样保存的。

Package关键字：

• package(包) 的作用是把不同的 java 程序分类保存，更方便的被其他 java 程序调用。
• 一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。
• Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

例如，下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类

import java.io.*;

1.2、数据类型

1.2.1、基本数据类型

Java的基本数据类型有4类8种，

类型分别为：整数型、浮点型、字符型、布尔型；

其中整数型有4种，字节型byte、短整型short、整数型int、长整型long；

浮点型有2种：单精度float、双精度double；

字符型char；

布尔型boolean

1.2.2、引用数类型

• 在Java中，引用类型的变量非常类似于C/C++的指针。
• 引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
• 对象、数组都是引用数据类型。
• 所有引用类型的默认值都是null。
• 一个引用变量可以用来引用任何与之兼容的类型。
• 例子：Site site = new Site("Runoob")。

1.2.3、数据类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级：

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

• 不能对boolean类型进行类型转换；
• 不能把对象类型转换成不相关类的对象；
• 在把容量大的类型转换为容量小的类型时必须使用强制类型转换；
• 转换过程中可能导致溢出或损失精度；

int i =128;

byte b = (byte)i;

因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte    类型时，值 128 时候就会导致溢出。

• 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入；

(int)23.7 == 23;

(int)-45.89f == -45;

1.2.4、自动类型转换

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

public class ZiDongLeiZhuan{

public static void main(String[] args){

char c1='a';//定义一个char类型

int i1 = c1;//char自动类型转换为int

System.out.println("char自动类型转换为int后的值等于"+i1);

char c2 = 'A';//定义一个char类型

int i2 = c2+1;//char 类型和 int 类型计算

System.out.println("char类型和int计算后的值等于"+i2);

}

}

运行结果：

char自动类型转换为int后的值等于97

char类型和int计算后的值等于66

解析：c1 的值为字符 a ,查 ASCII 码表可知对应的 int 类型值为 97， A 对应值为 65，所以 i2=65+1=66。

1.2.5、强制类型转换

条件是转换的数据类型必须是兼容的。

格式：(type)value type是要强制类型转换后的数据类型

实例：

public class QiangZhiZhuanHuan{

public static void main(String[] args){

int i1 = 123;

byte b = (byte)i1;//强制类型转换为byte

System.out.println("int强制类型转换为byte后的值等于"+b);

}

}

运行结果：

int强制类型转换为byte后的值等于123

1.2.6、隐式类型转换

• 整数的默认类型是 int。
• 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。

1.3、流程控制

1.3.1、分支语句

（1）if-else-if语句

语法：

if(条件){

//当条件为true时，执行大括号内的代码

}else if(条件){

}

（2）switch-case语句

概念：

switch 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

语法：

switch( 变量 ){

case 值1：

break;

case 值2：

break;

default:

}

当程序执行到break关键字时，跳出当前的switch语句；

语法规则：

• switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串类型了，同时 case 标签必须为字符串常量或字面量。
• switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
• case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
• 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
• 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
• switch 语句可以包含一个 default 分支，该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

1.3.2、循环语句

（1）while循环

语法：

while(条件){

//当条件为true时，执行循环体内的代码；

}

备注：

满足循环的三个条件：初始化变量、关系运算、迭代

（2）do-while循环

语法：

do{

}while(条件);

备注：与while循环的区别是，当条件为false时，也会被执行一次。

（3）for循环

语法：

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

}

说明：

• 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
• 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
• 执行一次循环后，更新循环控制变量。
• 再次检测布尔表达式。循环执行上面的过程。

（4）foreach循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式) {

//代码句子

}

声明语句：

声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：

表达式是要访问的数组名，或者是返回值为数组的方法。

1.3.3、循环控制

（1）break关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

代码示例：

public class Test {

public static void main(String args[]) {

int [] numbers = {10, 20, 30, 40, 50};

for(int x : numbers ) {

// x 等于 30 时跳出循环

if( x == 30 ) {

break;

}

System.out.print( x );

System.out.print("\n");

}

}

}

编译运行结果如下：

1020

（2）continue关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

示例：

public class Test {

public static void main(String args[]) {

int [] numbers = {10, 20, 30, 40, 50};

for(int x : numbers ) {

if( x == 30 ) {

continue;

}

System.out.print( x );

System.out.print("\n");

}

}

}

编译运行结果如下：

10

20

40

50

1.3.4、循环标签

语法：

标签名 ：

使用：

break 标签名;  或 continue 标签名;

示例：

a: for (int i = 1; i <= 10; i++) {

System.out.println("i="+i);

b: for (int j = 1; j <= 10; j++) {

if(j==5){

//continue a;

break a;

}

System.out.println("j="+j);

}

}

规则：

• 标签名的语法规则要遵循标识符的语法要求；
• break 标签名 ： 跳出该标签名后面的循环；
• continue 标签名： 跳过该标签名的本次循环，继续进行下次迭代；

1.4、数组

1.4.1、数组声明

（1）语法：

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

示例：

int[] array = new int[10];

（2）语法：

类型[] 数组名 = {值,值,……};

示例：

int[] array2 = {1,2,3,4,5,6,7,8,9,10};

（3）语法：

类型[] 数组名 = new  类型[]{值,值……};

示例：

int[] array3 = new int[]{1,2,3,4,5,6,7,8};

数组通过下标来赋值和取值，例如：

array[0] = 1;

System.out.println(array[0]);

下标的范围是从0开始，到数组的长度-1；

1.4.2、数组遍历

示例：

int[] array = {10,12,32,45,57,68,79,80,90,100,200,300};

//数组的遍历

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

System.out.println(array[i]);

}

增强for循环：

语法：

for(数组类型  变量名 : 数组名){

System.out.println(变量名);

}

示例：

int[] a = {1,2,3,4,5,6};

//增强for循环

for(int i : a){

System.out.println(i);

}

1.4.3、数组排序

（1）冒泡排序

从后往前依次确定元素，相邻的两个元素比较，互换位置；

示例：

int[] a = {3,7,9,1,5};

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

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

if(a[j] < a[j+1]){

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

（2）选择排序

从前往后确定元素，让未确定的第一个数依次和后面的比较，互换位置；

示例：

int[] a = { 3, 7, 9, 1, 5 };

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

for (int j = i + 1; j < a.length ; j++) {

if (a[i] < a[j]) {

int temp = a[i];

a[i] = a[j];

a[j] = temp;

}

}

}

1.4.4、多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：

String str[][] = new String[3][4];

多维数组的动态初始化（以二维数组为例）

（1）直接为每一维分配空间

格式如下：

type[][] typeName = new type[typeLength1][typeLength2];

type 可以为基本数据类型和复合数据类型，arraylenght1 和 arraylenght2 必须为正整数，arraylenght1 为行数，arraylenght2 为列数。

例如：

int a[][] = new int[2][3];

解析：

二维数组 a 可以看成一个两行三列的数组。

（2）从最高维开始，分别为每一维分配空间

例如：

String s[][] = new String[2][];

s[0] = new String[2];

s[1] = new String[3];

s[0][0] = new String("Good");

s[0][1] = new String("Luck");

s[1][0] = new String("to");

s[1][1] = new String("you");

s[1][2] = new String("!");

解析：

s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间 s0=new String("Good") 等操作。

1.1.5、多维数组的引用（以二维数组为例）

对二维数组中的每个元素，引用方式为 arrayName[index1][index2]，例如：

num[1][0];

二维数组完整示例：

int[] a = {1,2,3,4,5,20};

int[] b = {6,7,8,9,10};

int[] c = {11,12,13,14,15,16,17,18};

//二维数组

int[][] array = {a,b,c};

//遍历array

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

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

System.out.print(array[i][j]+" ");

}

System.out.println();

}