Java教程代码示例 java代码基础

Java基础语法

1. Java代码的基本格式：Java程序中代码分为结构定义语句和功能执行语句，结构定义语句用于声明一个类或方法，后面带{}，功能执行语句后面一般需要加上冒号；Java中严格区分大小写；为了便于阅读，使用良好的格式进行编程排版；代码中一个连续字符串不能够分为两行进行书写；
2. 标识符的规则和规范：
   规则：Java中包名、类名、接口名、常量名、变量名、方法名和参数名都称之为标识符，标识符有任意顺序的大小写字母、数字、下划线和美元符号组成。不能以数字开头，不能使用关键字；
   规范：包名所有字母使用小写，和域名倒转去掉WWW一样，使用点来进行分级；类名和接口名每个单词的首字母大写；常量名所有字母大写，单词之间使用下划线进行分隔；变量名和方法名第一个单词首字母小写，其余单词首字母大写；命名要有意义，为了便于阅读，定义名称要见名知意；
3. 注释的分类：注释包括单行注释、多行注释和文档注释；
4. 常量的分类：常量包括整数常量、浮点数常量、字符常量、字符串常量、布尔常量、null

注释

在程序开发工程中，用于解释和说明程序的文字我们称之为注释，Java中的注释分为以下几种：单行注释、多行注释、文档注释。

单行注释

// ... 注释一行

//这是一条单行注释复制代码

多行注释解

/ ... / 注释若干行

/* 这是一段注释，
它跨越了多个行 */复制代码

文档注释

/* ... / 注释若干行，并写入 javadoc 文档

/**
 * ========================================
 * <p/>
 * 版 权：dou361.com 版权所有 （C） 2015
 * <p/>
 * 作 者：jjdxmashl
 * <p/>
 * 个人网站：http://www.dou361.com
 * <p/>
 * 版 本：1.0
 * <p/>
 * 创建日期：2017/2/13 16:25
 * <p/>
 * 描 述：
 * <p/>
 * <p/>
 * 修订历史：
 * <p/>
 * ========================================
 */复制代码

关键字

了解Java关键字的含义及特点，掌握关键字使用的注意事项。

关键字的定义和特点

定义：被Java语言赋予了特殊含义的单词

特点：关键字中所有字母都为小写

关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。
Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。
Java语言规定关键字不能作为标识符。目前共有50个Java关键字，其中，"const"和"goto"这两个关键字在Java语言中并没有具体含义。Java语言把它们列为关键字，只是因为"const"和"goto"是其他某些计算机语言的关键字。复制代码

Java中所有的关键字

Abstract        抽象的，用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现
assert            用来进行程序调试
boolean            基本数据类型之一，布尔类型
break            用来改变程序执行流程，立刻从当前语句的下一句开始执行从。如果后面跟有一个标签，则从标签对应的地方开始执行
byte            基本数据类型之一，字节类型
case            用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。
catch            用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。
char             用来定义一个字符类型 
catch            用在异常处理中，用来捕捉异常
char            基本数据类型之一，字符类型
class            类
const            保留关键字，没有具体含义
continue        用来打断当前循环过程，从当前循环的最后重新开始执行，如果后面跟有一个标签，则从标签对应的地方开始执行。
default            默认，例如，用在switch语句中，表明一个默认的分支
do                用来声明一个循环，这个循环的结束条件可以通过while            关键字设置
double            用来定义一个double类型的变量
else            如果if语句的条件不满足就会执行该语句。
enum            枚举
extends            表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final            你只能定义一个实体一次，以后不能改变它或继承它。更严格的讲：一个final修饰的类不能被子类化，一个final修饰的方法不能被重写，一个final修饰的变量不能改变其初始值。
finally            用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。
float            用来定义一个浮点数变量
for                用来声明一个循环。程序员可以指定要循环的语句，推出条件和初始化变量。
goto            保留关键字，没有具体含义
if                用来生成一个条件测试，如果条件为真，就执行if下的语句。
implements        在类的声明中是可选的，用来指明当前类实现的接口。
import            在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字。
instanceof        用来测试第一个参数的运行时类型是否和第二个参数兼容。
int                用来定义一个整形变量
interface        用来定义一系列的方法和常量。它可以被类实现，通过
long            用来定义一个long类型的变量。
native            用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new                用来创建新实例对象
null            空
private            用在方法或变量的声中。它表示这个方法或变量只能被这个类的其它元素所访问。
protected        在方法和变量的声明中使用，它表示这个方法或变量只能被同一个类中的，子类中的或者同一个包中的类中的元素所访问
public            在方法和变量的声明中使用，它表示这个方法或变量能够被其它类中的元素访问。
return            用来结束一个方法的执行。它后面可以跟一个方法声明中要求的值。
short            用来定义一个short类型的变量。
static            用来定义一个变量为类变量。类只维护一个类变量的拷贝，不管该类当前有多少个实例。"static" 同样能够用来定义一个方法为类方法。类方法通过类名调用而不是特定的实例，并且只能操作类变量。 
strictfp        用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super            表明当前对象的父类型的引用或者父类型的构造方法
switch            分支语句结构的引导词
synchronized    表明一段代码需要同步执行
this            用来代表它出现的类的一个实例。this可以用来访问类变量和类方法。
throw            允许用户抛出一个exception对象或者任何实现throwable的对象
throws            用在方法的声明中来说明哪些异常这个方法是不处理的，而是提交到程序的更高一层。 
transient        用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
try                用来定义一个可能抛出异常语句块。如果一个异常被抛出，一个可选的catch语句块会处理try语句块中抛出的异常。同时，一个finally语句块会被执行，无论一个异常是否被抛出。 
void            用在Java语言的方法声明中说明这个方法没有任何返回值。"void"也可以用来表示一句没有任何功能的语句。
volatile        用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。 
while            用来定义一段反复执行的循环语句。循环的退出条件是while语句的一部分。 复制代码

关于break和continue

continue 语句与break语句相关，但较少用到。continue语句用于使其所在的for、while或do-while语句开始下一次循环。在while与 do-while语句中，continue语句的执行意味着立即执行测试部分；在for循环语句中，continue语句的执行则意味着使控制传递到增量 部分。

标识符

了解什么是标识符，标识符的组成规则，以及标识符使用时的注意事项。

标识符特征

1.标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符，不能以数字开头。譬如：123name 则是不合法的
2.标识符不能是 Java 关键字和保留字（ Java 预留的关键字，以后的升级版本中有可能作为关键字），但可以包含关键字和保留字。如：不可以使用 void 作为标识符，但是 Myvoid 可以
3.标识符是严格区分大小写的。 一定要分清楚 imooc 和 IMooc 是两个不同的标识符哦！
4.标识符的命名最好能反映出其作用，做到见名知意。复制代码

Java中的名称规范：

包名：多单词组成时所有字母都小写。

xxx.yyy.zzz  www.dou361.com
com
dou361
student
com.dou361.student复制代码

类名接口名：多单词组成时，所有单词的首字母大写。

XxxYyyZzz 复制代码

变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。

xxxYyyZzz  复制代码

常量名：所有字母都大写。多单词时每个单词用下划线连接。

XXX_YYY_ZZZ 复制代码

常量与变量

理解常量与变量的含义，并掌握常量与变量的区别、变量的定义格式以及变量的赋值。

在程序中存在大量的数据来代表程序的状态，其中有些数据在程序的运行过程中值会发生改变，有些数据在程序运行过程中值不能发生改变，这些数据在程序中分别被叫做变量和常量。

常量

1. 由于在生活中，一些事物常常会发生改变，使用常量不足以满足对事物的描述，因此需要使用到变量。Java语言是一种强类型语言，在使用变量时，必须有明确的数据类型，变量只有有了数据类型才有实际意义；
2. 数据类型分为基本数据类型和引用数据类型：
   基本数据类型：数值型：整数型：byte、short、int、long 浮点型：double float；字符型：char；布尔型：Boolean；
   引用数据类型：类、接口、数组、枚举、注解、String；

常量代表程序运行过程中不能改变的值。
常量在程序运行过程中主要有2个作用：

1. 代表常数，便于程序的修改（例如：圆周率的值）
 2. 增强程序的可读性（例如：常量UP、DOWN、LEFT和RIGHT分辨代表上下左右，其数值分别是1、2、3和4）复制代码

常量的语法格式和变量类型，只需要在变量的语法格式前面添加关键字final即可。在Java编码规范中，要求常量名必须大写。
则常量的语法格式如下：

final 数据类型 常量名称 = 值；
final 数据类型 常量名称1 = 值1， 常量名称2 = 值2，……常量名称n = 值n；
例如：
final double PI = 3.14；
final char MALE=‘M’，FEMALE=‘F’；复制代码

在Java语法中，常量也可以首先声明，然后再进行赋值，但是只能赋值一次。

变量

用来不断的存放同一类型的常量，并可以重复使用成为变量。为了方便的引用变量的值，在程序中需要为变量设定一个名称，这就是变量名。例如在一个求和方法中，需要2个变量，一个是a参数，一个是b参数，在执行不同求和计算过程中，这两个变量的值会改变。

由于Java语言是一种强类型的语言，所以变量在使用以前必须首先声明，在程序中声明变量的语法格式如下：

数据类型 变量名称；
例如：int x；复制代码

从本质上讲，变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每一个变量使用前必须要先申请（声明），然后必须进行赋值（填充内容），才能使用。
语法格式如下：

数据类型 变量名称 = 值；
例如：int x = 10；复制代码

final、static修饰

1.被final修饰而没有被static修饰的类的属性变量只能在两种情况下初始化:(必须初始化）

在它被声明的时候赋值 
在构造函数里初始化复制代码

2.被static修饰而没有被final修饰的类的属性变量只能在两种情况下初始化:(可以不初始化）

在它被声明的时候赋值
在静态或非静态快里初始化复制代码

3.同时被final和static修饰的类的属性变量只能在两种情况下初始化:（必须初始化）

在它被定义的时候
在类的静态块里初始化 
特别对于初始化时候调用抛出异常的构造函数，初始时候注意，特别是在实现单例模式时(只能这么初始化）复制代码

数据类型

掌握Java语言的数据类型，如基本数据类型：byte、short、int、long、float、double、char、boolean，以及引用类型：类、接口、数组。

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间
Java四类八种数据类型

类型            占用存储空间            表数范围
byte        1字节                -128~127
short        2字节                -2^15~2^15-1
int            4字节                -2^31~2^31-1
float        4字节                -3.403E38~3.403E38
long        8字节                -2^63~2^63-1
double        8字节                -1.798E38~1.798E38复制代码

整形，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：

1：容量小的类型默认转换为容量大的数据类型；数据类型按容量大小排序为：

byte,short,char->int->long->float->double复制代码

byte,short,char之间不会互相转换，他们三者在计算时首先会转换为int类型

2：容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度降低或溢出；使用时要格外注意。

3：有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那一种数据类型，然后再进行计算。

Java 各整数类型有固定的表数范围和字段长度，其不受具体操作系统的影响，以保证Java程序的可移植性。Java语言的整型常量默认为int型，声明long型常量可以后加‘ l ’或‘ L ’ ，如：

int i1 = 600; //正确     
long l1 = 88888888888L; //必须加l否则会出错复制代码

与整数类型类似，Java浮点类型有固定的表数范围和字段长度，不受平台影响。
Java 浮点类型常量有两种表示形式,

十进制数形式，如:

3.14
314.0复制代码

科学记数法形式，如:

3.14e2
3.14*10^2复制代码

Java 浮点型常量默认为 double 型，如要声明一个常量为 float 型，则需在数字后面加 f 或 F ，如：

double d = 12345.6; //正确   
float f = 12.3f; //必须加f否则会出错复制代码

运算符

熟练掌握Java中的运算符：

算术运算符

赋值运算符

符号：

= , +=, -=, *=, /=, %=复制代码

示例：

int a,b,c;  a=b=c =3;
int a = 3;   a+=5;等同运算a=a+5;复制代码

比较运算符

符号：

== , ！=, <, >, <=, >=, instanceof复制代码

示例：

4 == 3  false
4 != 3  true
"hello" instanceof String  true

注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false。
注2：比较运算符“==”不能误写成“=” 。复制代码

逻辑运算符

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
    “|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。复制代码

位运算符

符号：

<< , >>, >>>, &, |, ^, ~复制代码

示例：

3 << 2 = 12 --> 3*2*2=12
3 >> 1 = 1  --> 3/2=1
3 >>> 1 = 1 --> 3/2=1
6 & 3 = 2
6 | 3 = 7
6 ^ 3 = 5
~6 = -7

<<：就是将左边的操作数在内存中的二进制数据左移右边操作数指定的位数，右边被移空的部分补0。相当于乘与2的倍数
>>：右移稍微复杂一点，如果最高位是0，左边被移空的位就填入0；如果最高位是1，左边被移空的位就填入1。相当于除以2的倍数
>>>：无论最高位是1还是0，左边被移空的高位都填入0。讲一个应用。复制代码

三目运算符。

格式

(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；复制代码

示例：

获取两个数中大数。
int x=3,y=4,z;
z = (x>y)?x:y;//z变量存储的就是两个数的大数。复制代码

1. 算术运算符：+ 、-、 *、 \ 、% 、+、 -、 +、 ++、 --
2. 赋值运算符：+= 、-= 、*=、\= 、%= 、=
3. 比较运算符：== 、!= 、< 、>、 <= 、>=
4. 逻辑运算符：&、 |、 ^、 ! 、&& 、||
5. 位运算符：&、 |、 ~ 、^ 、<<、 >> 、>>>
6. 优先级：

流程控制语句

1. 循序语句：执行语句都是顺序语句，由上到下，由左到右；
2. 选择语句：if if…else if…else if…else switch…case switch…case…defualt
3. 循环语句：do…while while for foreach
4. 判断语句：try…catch try…catch…defualt
5. 跳转语句：goto continus break

了解什么是流程控制语句，掌握以下流程控制语句：顺序结构、选择结构、循环结构，并能够通过流程控制语句实现特定的功能。

顺序结构

if(条件表达式)
{
    执行语句；
}

if(条件表达式)
{
    执行语句；
}
else
{
    执行语句；
}


if(条件表达式)
{
    执行语句；
}
else if (条件表达式)
{
    执行语句；
}
……
else
{
    执行语句；
}复制代码

选择结构

switch(表达式)
{
    case 取值1:
        执行语句；
        break；
    case 取值2:
        执行语句；
        break；
    …...
    default:
        执行语句；
        break；
}复制代码

switch语句特点：

a,switch语句选择的类型只有四种：byte，short，int ， char。
 b,case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
 c,结束switch语句的两种情况：遇到break，执行到switch语句结束。
 d,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。复制代码

循环结构

代表语句：while ， do while ， for

for语句格式：：

for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
    执行语句；
}复制代码

注意：

a,for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
b,while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
c,最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。复制代码

while语句格式：

while(条件表达式)
{
    执行语句；
}复制代码

先判断逻辑表达式的值。若=true.则执行其后面的语句,然后再次判断条件并反复执行，直到条件不成立为止

do while语句格式：

do
{
    执行语句；
}while(条件表达式);复制代码

先执行语句,再判断逻辑表达式的值,若为true,再执行语句,否则结束循环。

方法

掌握方法的定义及格式，并能正确的调用方法，理解方法的调用过程，同时清楚方法的注意事项；掌握方法重载及其特点。

1. 什么是方法：完成一些事情的时候，通常需要使用到不同的功能，如果所有功能都写到一起，不利于代码的维护和阅读。因此我们可以对完成特定功能的代码进行封装，封装好的不同功能的代码就称为方法或函数；
2. 什么是方法重载：在同一个类中，方法名相同，参数列表不同的方法称为方法重载。
3. 成员变量与局部变量的区别：初始化值：成员变量都有默认初始化值，局部变量没有默认初始化值，使用之前必须先赋值；定义位置：成员变量定义在类中方法外，局部变量定义在方法中；存储位置：成员变量存储在堆中，局部变量存储在栈中；生命周期：成员变量随着对象的创建而存在，随着对象的消失而消失，局部变量随着方法的调用而存在，随着方法调用完毕而消失；

函数的格式：

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…)

{
        执行语句;
        return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该函数运算的结果，该结果会返回给调用者。复制代码

函数的特点

定义函数可以将功能代码进行封装
便于对该功能进行复用
函数只有被调用才会被执行
函数的出现提高了代码的复用性
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。复制代码

函数的重载

在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。与返回值类型无关，只看参数列表。重载示例如下：

//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}复制代码

数组

了解数组的概念，掌握数组的定义格式、静态初始化、动态初始化，并能够理解Java中数组的内存图解。熟练掌握数组的遍历、获取最值、数组元素逆序、数组元素查找、数组排序和二分查找，以及二维数组的定义格式及初始化。

有时候需要定义多个变量时，而这些变量又具有一定的共性时就可以定义成数组，数组是用来存储一组相同数据类型数据的，数组可以存储基本数据类型和引用数据类型。

同一种类型数据的集合。其实数组就是一个容器。可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式1：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];复制代码

格式2：

元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};复制代码

二维数组

格式1：int[][] arr = new int[3][2];

定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;复制代码

格式2：int[][] arr = new int[3][];

二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化
  arr[0] = new int[3];
  arr[1] = new int[1];
  arr[2] = new int[2];复制代码

数组内存结构

内存结构

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存

用于存储局部变量，当数据使用完，所占空间会自动释放。复制代码

堆内存

数组和对象，通过new建立的实例都存放在堆内存中。
每一个实体都有内存地址值
实体中的变量都有默认初始化值
实体不在被使用，会在不确定的时间内被垃圾回收器回收复制代码