1.1 Java语言概述
1.1.1
Java名称来历：（从最初的Oak（橡树）到工程师们边喝咖啡边讨论着，看看手上的咖啡，联想到印度尼西亚有一个盛产咖啡的岛屿Java（中文名叫爪哇），于是将其更名Java。）

1.1.2
Java语言的现状：为了满足不同人员的开发需求，Java开发分成了以下三个方向：
Java SE：主要用于桌面程序的开发。是学习Java EE和Java ME的基础。
Java EE:主要用于网页程序的开发。
Java ME：主要用于嵌入式系统程序的开发。

1.1.3
Java语言的面向对象特性：
1、简单
2、面向对象
3、分布性
4、可移植性
5、解释性
6、安全性
7、健壮性
8、多线程
9、高性能
10、多态

1.2 JDK环境配置（从略）

1.3 第一个Java程序
1.编写源代码
用文本编辑器(记事本)编写一个最基本的Java程序

public class MyApp{
       public static void main(String[] args){
             System.out.println("我能学好Java语言！"); 
       }
}

将源代码保存到D盘，文件名需要与源代码中的公共类相同，这里是MyApp.java（Java语言是区分大小写的，因此这里不能写成myapp类似的，只能是MyApp），如图

2、编译源代码
win+R运行，打开命令提示符（cmd）窗口将路径切换到D盘，并运行dir命令查看D盘中的文件，运行结果如图

接着运行javac MyApp.java命令，然后使用dir命令查看D盘中的文件，其运行结果如图

然后回头去查看D盘，出现了一个名为MyApp类型为class的文件（编译好的文件）

3、运行class文件
在命令提示符窗口继续输入 java MyApp 来运行class文件，运行结果如图所示：

可以看到，在DOS控制台上出现了“我能学好Java语言！”。

注：使用java命令时，不需要输入文件的扩展名，而使用javac命令时，需要输入文件的扩展名。

1.4 本章小结
本章学了Java语言的历史、现状及各种特性，接着配置了JDK环境，最后介绍了第一个Java应用程序，Java开发的一般流程是编写源代码、编译源代码和运行class文件。

2.1 熟悉Eclipse

2.1.1 Eclipse简介
它是由IBM公司投资4000万刀开发的IDE集成开发工具。是目前最流行的Java集成开发工具之一，基于Java语言编写，并且是开放源代码的、可扩展的开发工具。插件是Eclipse平台最具特色的特征之一，也是区别于其他开发工具的特征之一。

2.1.2 Eclipse的下载与安装（从略）

2.1.3 Eclipse工作台
运行eclipse.exe文件，如图出现工作台

2.2 使用Eclipse

2.2.1 创建Java项目

2.2.2 创建Java类文件

2.2.3 使用编辑器编写程序代码

2.2.4 运行Java程序

2.3 程序调试

2.4 本章小结
学习了Eclipse开发工具，包括它的配置与启动，菜单栏，工具栏，以及常用的“包资源管理器”和“控制台”视图；学了创建Java项目，创建Java类，编写程序代码和运行程序；Java程序调试器的简单使用。学会灵活运用Eclipse的代码辅助功能（使用Ctrl+Alt+/、Alt+/和Ctrl+1快捷键）快速编写程序代码。

3.1 Java程序的基本结构
一个Java程序的基本结构大体可以分为包、类、main()主方法、标识符、关键字、语句和注释等。

package Mr;                                   //定义包
public class Example{                         //创建类
    static int ONE=1;                         //定义类的成员变量
    public static void main(string[] args){   //定义主方法
         String var="Hello";                  //定义局部变量
         System.out.println(ONE);             //输出成员变量的值
         System.out.println(var);             //输出局部变量的值
    }
} 

注：
每条语句必须以分号结尾；
在Java语言中，主方法的写法是固定的，既“public static void main(string[] args)”；
在Java程序中，所有标点符号必须是半角的；
“System.out.println(ONE)”是输出语句的固定写法，其中System是一个系统类的名称，其第一个字母必须大写。

3.2 标识符和关键字

3.2.1 标识符

1、标识符：
标识符可以简单理解为一个名字，用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。

2、标识符的命名规则：
Java语言的标识符由字母、数字、下划线和美元符号组成，第一个字符不能为数字；
Java语言使用Unicode标准字符集，最多可以识别65535个字符；
标识符不能是Java的关键字和保留字。非法的标识符如this、goto；
在Java语言中标识符是区分大小写的，good和Good就是两个不同的标识符。

3.2.2 关键字
关键字是Java语言中已经被赋予特定意义的一些单词，不可以把这些字作为标识符来使用。

Java中的关键字有：

int、public、this、finally、boolean、abstract、continue、float、long、short、throw、throws、return、break、for、static、new、interface、if、double、default、byte、do、case、strictfp、package、super、void、try、switch、else、catch、implements、private、final、class、extends、volatile、while、synchronized、instanceof、char、protecte、imported、transient、implements、defaule (47个)

说明：在命名标识符时，虽然const和goto不是Java的关键字，但也不可以使用。

3.3 基本数据类型
在Java中有8种数据类型，其中6种是数值类型，另外两种分别是字符类型和布尔类型，而6种数值类型有4种是整数类型，另外两种是浮点类型。如图：

3.3.1 整数类型
数据类型内存空间（8位=1字节）取值范围
byte8位（1个字节） -128~127
short16位（2个字节） -32768~32767
int32位（4个字节） -2147483648~2147483647
long64位（8个字节） -9223372036854775808~9223372036854775807

【例】：
在项目中创建类Number，在主方法中创建不同的整数类型变量，并将这些变量相加输出。

public class Number {                                //创建类
	public static void main(String[] args)           //主方法
		byte mybyte=124;                             //声明byte型变量并赋值
		short myshort=32564;                         //声明short型变量并赋值
		int myint=45784612;                          //声明int型变量并赋值
		long mylong=46789451L;                       //声明long型变量并赋值
		long result=mybyte+myshort+myint+mylong;     //获得各数相加后的结果
		System.out.println("四种类型相加的结果为： "+result);    //将结果输出
	}
}

3.3.2 浮点类型
数据类型内存空间（8位=1字节）取值范围
float32位1.4E-45~3.4028235E38
double64位4.9E-324~1.7976931348623157E308

3.3.3 字符类型

char x='a';     or     char x=97;

在字符类型中有一种特殊的字符，以反斜线“”开头，后跟一个或多个字符，具有特定的含义不同于字符原有的意义，叫做转义字符。如下表

转义字符本身也是字符，所以将转义字符赋值给字符变量时，与其他字符常量一样需要使用单引号。

3.3.4 布尔类型
布尔类型又称逻辑类型，只有true和false两个值，分别代表布尔逻辑中的“真”和“假”。使用boolean关键字声明布尔类型变量，通常被用在流程控制中作为判断条件。

【例】：声明boolean型变量

boolean b1=true,b2=false,b3;    //定义布尔型变量b1、b2、b3并对b1、b2赋值

3.4 变量与常量
在程序执行过程中，其值不能改变的量称为常量，其值能被改变的量称为变量。变量与常量的声明都必须使用合法的标识符，所有变量和常量只有在声明之后才能使用。
3.4.1 声明变量

int age;             //声明int型变量
char char1='r';      //声明char型变量并赋值

3.4.2 声明常量
在程序运行过程中一直不会改变的量称为常量（constant），通常也称为“final变量”。常量在整个程序中只能被赋值一次。在为所有对象共享值时，常量时非常有用的。
在Java语言中声明一个常量，除了要制定数据类型外，还需要通过final关键字进行限定。声明常量的标准语法格式如下：

final 数据类型 常量名称[=值]

常量名通常使用大写字母，但这并不是必须的，很多Java程序猿使用大写字母表示常量，常常是为了清除地表明正在使用常量。
【例】：声明常量

final double PI=3。1415926F； //声明double型常量PI并赋值
final boolean BOOL=true；     //声明boolean型常量BOOL并赋值

说明：如果定义的常量属于“成员变量”，则必须在定义时就赋给初值，否则将会在编译时出现错误。
【例】：
在项目中创建类Part，在类体中创建age与常量PI。在主方法种分别给变量与常量赋值，通过输出信息科测试变量与常量的有效范围。

public class Part {                                         //新建类Part
    static final double PI=3.14;                            //声明常量PI
    static int age=23;                                      //声明int型变量age并赋值
	public static void main(String[] args) {                //主方法
	     final int number;                                  //声明int型常量并赋值
         number=1235;                                       //对常量进行赋值
         age=22;                                            //再次对变量进行赋值
         System.out.println("常量PI的值为："+PI);              //将PI的值输出
         System.out.println("赋值后number的值为："+number);     //将number的值输出
         System.out.println("int型变量age的值为："+age);        //将age的值输出
	}
}

运行结果如下：

3.4.3 变量的有效范围
变量的有效范围是指程序代码能够访问该变量的区域，若超出变量所在区域访问变量，则编译时会出现错误。在程序中，一般会根据变量能够访问的区域将变量分为“成员变量”和“局部变量”。
1、成员变量
在类体重定义的变量被称为成员变量，成员变量在整个类中都有效。类的成员变量又可分为静态变量和实例变量两种。
【例】声明静态变量和实例变量。

class var{
     int x=45;              //定义实例变量
     static int y=90;       //定义静态变量
}

2、局部变量
在类的方法体中定义的变量（方法内部定义，“{”和“}”之间的代码中声明的变量）称之为局部变量。局部变量只在当前代码块中有效，通俗地理解就是在其所定义的大括号内有效，出了这个大括号就无效了，在其他类体中不能调用该变量。
局部变量的声明周期取决于方法，当方法被调用时，Java虚拟机为方法中的局部变量分配内存空间，当该方法的调用结束后，则会释放方法中局部变量所占用的内存空间，局部变量也随即销毁。
【例】在项目中创建类Val，分别定义名称相同的局部变量与成员变量，最后在控制台输出变量，观察输出的结果。

public class Val{                                   //新建类
     static int times=3;                            //定义成员变量times
     public static void main(String[] args){        //主方法
           int times=4;                             //定义局部变量times
           system.out.println("times的值为："+times);//将times的值输出
           system.out.println("times的值为："+Val.times);//输出静态变量
     }
}

运行结果如图：

说明：局部变量可与成员变量的名字相同，此时成员变量将被隐藏。即这个成员变量在此方法中暂时失效。如果想要调用成员变量，需要使用“类名.静态变量”调用。

3.5 运算符

3.5.1赋值运算符(二元，从右向左)
变量类型 变量名 = 所赋的值；

int a=10;
int b=5;
int c=a+b+2;            //变量类型 变量名 = 所赋的值；

int a,b,c;                            //声明int型变量a,b,c
a=15;                                 //将15赋值给a
c=b=a+4;                              //将a+4的值赋值给变量b，c
System.out.println("c的值为："+c);     //将变量c的值输出
System.out.println("b的值为："+b);     //将变量b的值输出

说明：在Java中，可以把赋值运算符连载一起使用，不过，在程序开发中不建议使用这种赋值语法。
3.5.2算术运算符
Java中的算术运算符主要有加（+）、减（-）、乘（*）、除（/）、求余（%），它们都是二元运算符，其中“+”和“-”还可以作为数据的正负符号，如+3，-6。
【例】在项目中创建Airth类，在类的主方法种定义变量，使用算术运算符对变量进行计算并在控制台将计算结果输出。

public class Airth{                               //创建类
     public static void main(String[] args){      //主方法
     float n1=45.56f;                             //声明float型变量并赋值
     int n2=152;                                  //声明int型变量并赋值
     System.out.println("45.56f和152的和为"+n1+n2);//将变量相加输出
     System.out.println("45.56f和152的差为"+n1-n2);//将变量相减输出
     System.out.println("45.56f和152的积为"+n1*n2);//将变量相乘输出
     System.out.println("45.56f和152的商为"+n1/n2);//将变量相除输出
     }
}

运行结果如图

3.5.3自增和自减运算符（单目）

++a(--a)          //先自增（自减），再参与运算
a++(a--)          //先参与运算，再自增（自减）

3.5.4比较运算符（二元）
比较运算符属于二元运算符，用于程序中的变量和变量之间，变量和常量之间以及其他类型的信息之间的比较。比较运算符的运算结果是boolean型，当成立时，运算结果是true，反之则是false。
3.5.5逻辑运算符
逻辑运算符包括&&（&）逻辑与、||（|）逻辑或、和!（逻辑非），返回值为布尔类型的表达式，操作元也必须是boolean型数据。与比较运算符相比，逻辑运算符可以表示更加复杂的条件，如连接几个关系表达式进行判断。在逻辑运算符中，出来“!”是一元运算符之外，其余的都是二元运算符。

说明：在Java中，逻辑运算符“&&”与“&”都表示“逻辑与”，使用逻辑运算符“&”会判断两个表达式;而逻辑运算符“&&”则是针对boolean类型进行判断，当第一个表达式为false 时则不去判断第二个表达式，直接输出结果。使用“&&” 可节省计算机判断的次数。通常将这种在逻辑表达式中从左端的表达式可推断出整个表达式的值称为“短路”，而那些始终执行逻辑运算符两边的表达式称为“非短路”。“&&” 属于“短路”运算符，而“&”则属于“非短路”运算符。 “||”和“|”也是如此。
3.5.6位运算符
位运算符用于处理整型和字符型的操作数，对其内存进行操作，数据在内存中以二进制的形式表示。
1、“按位与”运算
&是双目运算符，如果两个操作数对应位都是1，则结果位才是1，否则为0。如果两个操作数的精度不同，则结果的精度与精度高的操作数相同。
2、“按位或”运算
|是双目运算符，如果两个操作数对应位都是0，则结果位才是0，否则为1。如果两个操作数的精度不同，则结果的精度与精度高的操作数相同。
3、“按位非”运算
~是单目运算符，将操作数二进制中的1全部修改为0，0全部修改为1。
4、“按位异或”运算
^是双目运算符，当两个操作数的二进制表示相同（同时为0或同时为1）时，结果为0，否则为1。如果两个操作数的精度不同，则结果的精度与精度高的操作数相同。
5、移位运算符
Java语言中的移位运算符有3种，其操作数的数据类型只有byte、short、char、int和long5种。技巧：移位能让用户实现整数乘或除以2的n次方的效果。例如，y<<2与y*4的效果相同；y>>1与y/2的结果相同。总之，一个数左移n位，就是将这个数乘2的n次方；一个数右移n位，就是将这个数除以2的n次方。
3.5.7三元运算符
三元运算符（ ? : ）是Java中唯一一个三目运算符，其操作元有3个，第一个是条件表达式，其余的是两个值，条件表达式成立时运算取第一个值，不成立时取第二个值。

3.5.8运算符优先级

3.5.9
范例1：不用其他变量实现两变量互换
①不用中间变量直接“做差”实现两个变量互换；
②使用“异或运算符”实现两变量互换。
这里以第二种为例，在项目中创建VariableExchange类，在类中创建扫描器对象接收用户输入的两个变量值，然后通过位运算符中的异或运算符“^”实现两个变量的互换，代码如下：

import java.util.Scanner;
public class VariableExchange {                              //声明类
	public static void main(String[] args) {                 //主方法
		 Scanner scan=new Scanner(System.in);                //创建扫描器
		 System.out.println("请输入变量A的值：");                
		 long A=scan.nextLong();                             //接收第一个变量值
		 System.out.println("请输入变量B的值：");
		 long B=scan.nextLong();                             //接收第二个变量值
		 System.out.println("A="+A+"tB="+B);
		 System.out.println("执行变量互换…");
		 A=A^B;
		 B=B^A;                                              //执行变量互换
		 A=A^B;
		 System.out.println("A="+A+"tB="+B);                //输出交换后的结果
	}
}

运行结果如图：

3.5.10
范例2：判断数字的奇偶性
根据数字2被2除的余数来判断一个数的奇偶性，如果余数是0该数是偶数，否则为奇数。本范例使用三元运算符进行判断。
在项目中创建ParityCheck类，在该类的主方法中创建扫描器对象接受用户输入的数字，通过三元运算符判断该数的奇偶性，并在控制台输出。代码如下：

import java.util.Scanner;
public class ParityCheck {                              //声明类
	public static void main(String[] args) {            //主方法
		 Scanner scan = new Scanner(System.in);         //创建输入流扫描器      
		 System.out.println("请输入一个整数：");                
		 long number=scan.nextLong();                   //获取用户输入的整数
		 String check=(number%2==0)?"这个数字是：偶数":"这个数字是：奇数";

		 System.out.println(check);                
	}
}

运行结果如下：

3.6类型转换
Java对数据类型的转换有严格的规定，数据从占用存储空间较小的类型转换为占用存储空间较大的数据类型时，则做自动类型转换（隐式类型转换）；反之则必须做强制类型转换（显式类型转换）。
3.6.1自动类型转换
Java中8种基本类型可以进行混合运算，不同类型的数据在运算过程中首先会自动转换为同一类型，再进行运算。数据类型根据占用存储空间的大小分为高低不同的级别，占用空间小的级别低，占用空间大的级别高，自动类型转换遵循低级到高级转换的规则。
【例】在项目中创建Conver类，在类的方法中创建不同数值型的变量进行运算，在控制台上将运行结果输出。

public class Conver {                        //创建类
	public static void main(String[] args) { //主方法
		byte mybyte=127;                     //定义byte型变量mybyte，并赋值127
		int myint=150;                       //定义int型变量myint，并赋值150
		float myfloat=452.52f;               //定义float型变量myfloat，并赋值
		char mychar=10;                      //定义char型变量mychar，并赋值
		double mydouble=45.46546;            //定义double型变量mydouble，并赋值
		//将运算结果输出
		System.out.println("127与452.12相加的和是："+(mybyte+myfloat));
		System.out.println("127与150相乘的积是："+mybyte*myint);
		System.out.println("127被10除的商是："+mybyte/mychar);
		System.out.println("45.46546和10相加的和是："+(mydouble+mychar));
	}
}

运行结果如下：

3.6.2强制类型转换
当把高精度的变量的值赋给低精度的变量时，必须使用显示类型转换运算（又称强制类型转换）。
语法格式如下：

(类型名)要转换的值

将不同的数据类型进行显式类型转换。

int a=(int)45.23;         //此时输出a的值是45
long y=(long)456.6F;      //此时输出y的值为456
int b=(int)'d';           //此时输出b的值是100

当把整数赋值给一个byte、short、int、long型变量时，不可超出这些变量的取值范围，否则就会发生数据溢出。示例如下：

Short s=516;
byte b=(byte)s;       /*由于byte型变量的最大值是127，516已经超出了
                      其取值范围，因此发生数据溢出，造成数据丢失，
                      所以在使用强制类型转换时，不要超出变量的取值范围，
                      否则就得不到想要的结果。*/

注意：boolean型的值不能被转换为其它数据类型，反之亦然。

3.6.3类型转换实战
在项目中创建TypeConvertion类，在类的方法中定义不同数据类型的变量，然后在不同数据类型之间进行转换，并在控制台输出。代码如下：

public class Typeconvertion{               //声明类
        public static void main(String[] args){//主方法
        int intNum=4;                      //定义变量
        float floatNum=9.5F;
        
        floatNum/=intNum;                  //自动类型转换成float型
        System.out.println("9.5F除以4的商是："+floatNum);
        
        double numX=4.88;
        double numY=78.83;
        int numZ=(int)numX+(int)numY;      //将double型强制转换出int型
        System.out.println("4.88和78.83转换成int型相加的和是："+numZ);

        char charVar='T';
        int intVar=(int)charVar;           //将char型强制转换成int型
        System.out.prinln("将字符T转换成int型变量是："+intVar);

        int num1=34;
        double num2=(double)num1/3;        //将int型强制转换成double型
        System.out.println("34的三分之一是：  "+num2);
         }
}

3.7代码注释和编程规范
3.7.1代码注释
1、单行注释用//
2、多行注释用

/*            */

3、文档注释用

/**           */

3.8经典范例
3.8.1判断某一年是否是闰年
闰年的判定条件是：如果该年能被4整除且不能被100整除或者能被400整除，则该年为闰年，否则不是。
在项目中创建LeapYear类，在类的主方法中创建扫描器对象接收输入的年份，然后判断该年份是否是闰年，最后在控制台输出。代码如下：

import java.util.Scanner;                                         //声明包
public class LeapYear{                                            //声明类
       public static void main(String[] args){                    //主方法
              Scanner scan=new Scanner(System.in);                //扫描器
              System.out.println("请输入一个年份:");        
              long year =scan.nextLong();                         //接收用户输入
              if(year%4==0&&year%100!=0||year%400==0){            //判断是否是闰年
                     System.out.print(year+"年是闰年！");
              }else{                                              //输出结果
                     System.out.print(year+"年不是闰年！");
              }
       }
}

3.8.2求球形的体积
在项目中创建Volume类，在类的主方法中创建扫描器对象接受输入的半径，然后根据球形体积的计算公式计算体积，并在控制台上输出。代码如下：