一、Java语言发展简史

二、Java语言特性

    1、简单性

     Java语法是C++语法的一个“纯净版本”，相当于对C++做了一个减法。这里没有头文件、指针运算（甚至指针语法）、结构、联合、操作符重载、虚基类等等。不仅如此，Java开发环境远远超出大多数其他编程语言的开发环境。

      Java有丰富的例程库，用于处理像 HTTP 和 FTP 之类的 TCP/IP 协议。 Java 应用程序能够通过 URL 打开和访问网络上的对象，其便捷程度就好像访问本地文件一样。

    4、健壮性

      Java 与 C++ 最大的不同在于 Java采用的指针模型可以消除重写内存和损坏数据的可能性。不仅如此， Java 编译器能够检测许多在其他语言中仅在运行时才能够检测出来的问题。

    5、安全性

      Java 适用于网络 / 分布式环境。为了达到这个目标，在安全性方面投入了大量的精力。使用 Java 可以构建防病毒、防篡改的系统

    6、体系结构中立

      编译器生成一个体系结构中立的目标文件格式，按照该规范生成的文件，只要有 Java 运行时系统，这些编译 后的代码就可以在许多处理器上运行。Java 编译器通过生成与特定计算机体系结构无关的字节码指令来实现 这一特性 。精心设计的字节码不仅可以很容易的在任何机器上解释执行，而且还可以动态地翻译成本地机器 代码。这就是为什么可以： “Wrice once ， Run anywhere”。而且其他语言编写的程序，在编译后如果能够严格按照字节码文件的规范生成.class 文件，也可以在 JVM 上运行。

    7、可移植性

       例如， Java 中的 int 永远是 32 位的整数，而在 C/C++ 中， int 可能是 16 位整数、 32 位整数，也可能是编译器 提供商指定的其他大小。在Java 中，数据类型具有固定的大小，这消除了代码移植时令人头疼的主要问题。

    8、解释性

       Java 为了实现与平台无关，自己维护了一套基于栈架构的指令集， Java 源代码经过编译之后，字节码文件中的 指令就是按照自己的指令集来组织的，但是在具体硬件环境中运行时，系统并不能识别，因为Java 程序在执行时，Java 解释器会逐条的将字节码文件中的指令翻译成 CPU 的指令集。

    9、高性能

       近年来 JVM 也在不断的优化，比如： JIT( 即时编译 器) ，热点代码探测，让 Java 程序的执行效率大幅提高，在有些场合不亚于 C/C++ 。

    10、多线程

      Java 在当时很超前。它是第一个支持并发程序设计的主流语言。多线程可以带来更好的交互响应和实时行为。并发程序设计绝非易事，但是Java 在这方面表现出色，可以很好的管理这个工作。

    11、动态性

      Java 与 C/C++ 相比更加具有动态性。它能够适应不断发展的环境。库中可以自由的添加新方法和实例变量，而 对客户端没有任何影响。在Java 中找出运行时类型信息十分简单。

因此： Java 不仅仅是一门编程语言，也是一个由一些列计算机软件和规范组成的技术体系 。

三、初认Java

    3.1 Java结构

      Java 程序的结构由如下三个部分组成：

1. 源文件（扩展名为*.java)：源文件带有类的定义。类用来表示程序的一个组件，小程序或许只会有一个 类。类的内容必须包含在花括号里面。
2. 类：类中带有一个或多个方法。方法必须在类的内部声明。
3. 方法：在方法的花括号中编写方法应该执行的语句。

  总结一下：类存在于源文件里面；方法存在于类中；语句存在于方法中。

注意：在一个源文件中只能有一个 public 修饰的类，而且源文件名字必须与 public 修饰的类名字相同 。

    3.2  运行java程序

       Java 是一门半编译型、半解释型语言。先通过 javac 编译程序把源文件进行编译，编译后生成的 .class 文件是由字节 码组成的平台无关、面向JVM 的文件。最后启动 java 虚拟机来运行 .class 文件，此时 JVM 会将字节码转换成平台能够理解的形式来运行。

注： JDK、JRE、JVM之间的关系？

• JDK(Java Development Kit):Java开发工具包，提供给Java程序员使用，包含了JRE，同时还包含了编译器javac与自带的调试工具Jconsole、jstack等。
• JRE(Java Runtime Environment):Java运行时环境，包含了JVM，Java基础类库。是使用Java语言编写程序运行的所需环境。
• JVM：Java虚拟机，运行Java代码

    3.3 注释

     Java 中的注释主要分为以下三种

• 单行注释：// 注释内容（用的最多）
• 多行注释：/* 注释内容*/
• 文档注释： /** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可以被javadoc工具解析，生成一套以网页文件形式体现的程序说明文档

注意：

1.  多行注释不能嵌套使用
2. 不论是单行还是多行注释，都不参与编译，即编译之后生成的.class文件中不包含注释信息。

    3.4 标识符

      在程序中由用户给类名、方法名或 者变量所取的名字 。

 【 规则 】

      标识符中可以包含：字母、数字以及 下划线和 $ 符号等等。

 注意：标识符不能以数字开头，也不能是关键字，且严格区分大小写

 推荐的写法：

1. 类名：每个单词的首字母大写(大驼峰)
2. 方法名：首字母小写，后面每个单词的首字母大写(小驼峰)
3. 变量名：与方法名规则相同

    3.5 关键字

      关键字是由 Java 语言提前定义好的，有特殊含义的标识符，或者保留字 。

class	extends	implements	interface	inport
package	break	case	continue	default
do	if	else	for	return
switch	while	false	short	null
boolean	byte	char	try	int
long	float	double	abstract	catch
throw	throws	finally	public	final
native	private	protected	instance of	static
synchronized	transient	volatile	true	new
super	void	assert	enum	goto
const

 注：在Java中关键字都是小写的。

    3.6 数据类型与变量

       3.6.1 字面常量

        常量即程序运行期间，固定不变的量称为常量

       字面常量的分类：

1. 字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。
2.  整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000
3.  浮点数常量：程序中直接写的小数，比如：3.14、0.34
4.  字符常量：由 单引号 括起来的当个字符，比如：‘A’、‘1’
5.  布尔常量：只有两种true和false
6.  空常量：null

    3.6.2 数据类型

     在 Java 中数据类型主要分为两类： 基本数据类型 和 引用数据类型 。

     基本数据类型有四类八种：

•  四类：整型、浮点型、字符型以及布尔型
•  八种：

注意：

• 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
• 整形和浮点型都是带有符号的
• 整型默认为int型，浮点型默认为double
• 字符串属于引用类型

    3.6.3 类型转换

      Java 作为一个强类型编程语言 , 当不同类型之间的变量相互赋值的时候 , 会有较严格的校验 .

在 Java 中，当参与运算数据类型不一致时，就会进行类型转换。 Java 中类型转换主要分为两类：自动类型转换 ( 隐式) 和 强制类型转换 ( 显式 ) 。

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

     自动类型转换即： 代码不需要经过任何处理，在代码编译时，编译器会自动进行处理 。特点： 数据范围小的转为数 据范围大的时会自动进行 。

int a = 100;
long b = 10L;

//a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
b = a;

//编译报错，long的范围比int范围大，会有数据丢失，不安全
a = b;

 （2）强制类型转换（显式）

    强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大的到数据范围小 的。

int a = 10;
long b = 100L;

//int—>long，数据范围由小到大，隐式转换
b = a;

//long—>int，数据范围由大到小，需要强转，否则编译失败
a = (int)b;

注意：

•  不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
•  如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
•  将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
•  强制类型转换不一定能成功，不相干的类型不能互相转换

    3.6.4 类型提升

      不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。

     （1） int与long之间：int会被提升为long

int a = 10;
long b = 20;
int c = a + b; // 编译出错: a + b==>int + long--> long + long 赋值给int时会丢失数据
long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long

     （2） byte与byte的运算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);

// 编译报错，不兼容的类型: 从int转换到byte可能会有损失

//以下是正确的写法
byte c = (byte)(a + b);

1.  不同类型的数据混合运算, 范围小的会提升成范围大的.
2.  对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.

    3.7 字符串类型

       在Java中使用String类定义字符串类型

int num = 10;
//方法1
String str1 = num + "";
//方法2
String str2 = String.valueOf(num);

String str = "100";
int num = Integer.parseInt(str);

int a = 20;
int b = 10;
System.out.println(a + b); // 30
System.out.println(a - b); // 10
System.out.println(a * b); // 200
System.out.println(a / b); // 2
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数

System.out.println(11.5 % 2.0);
// 运行结果
1.5

// +的左侧是int，右侧是double，在加之前int被提升为double.故：输出1.2
System.out.println(1+0.2); 

int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a); // 输出3

int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似

• 如果单独使用，【前置++】和【后置++】没有任何区别
• 如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式 结束时给变量+1

   3.7.4 关系运算符

int a = 1;
int b = 2;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false

System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true

System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

   3.7.6 位运算符

 （1）按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

 （2）按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.

注意: 当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表 示逻辑运算.

（3）按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0

（4）按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

注意：如果两个数相同，则异或的结果为0

    3.7.7 条件运算符

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

    3.8 逻辑控制

    3.8.1 顺序结构

    3.8.2 分支结构

if(布尔表达式1){
// 语句1
}else if(布尔表达式2){
// 语句2
}else{
// 语句3
}

switch(表达式){
case 常量值1:{
语句1;
[break;]
}
case 常量值2:{
语句2;
[break;]
}
...
default:{
内容都不满足时执行语句;
[break;]
}
}

while(循环条件){
循环语句;
}

for(表达式①;布尔表达式②;表达式③){
表达式④;
}

do{
循环语句;
}while(循环条件);

// 方法定义
修饰符 返回值类型 方法名称([参数类型 形参 ...]){
方法体代码;
[return 返回值];
}

public class TestMethod {
public static void main(String[] args) {
int a = 10;
int b = 20;
swap(a, b);
System.out.println("main: a = " + a + " b = " + b);
}
public static void swap(int x, int y) {
int tmp = x;
x = y;
y = tmp;
System.out.println("swap: x = " + x + " y = " + y);
}
}
// 运行结果
swap: x = 20 y = 10
main: a = 10 b = 20

public class TestMethod {
public static void main(String[] args) {
add(1, 2); // 调用add(int, int)
add(1.5, 2.5); // 调用add(double, double)
add(1.5, 2.5, 3.5); // 调用add(double, double, double)
}
public static int add(int x, int y) {
return x + y;
}
public static double add(double x, double y) {
return x + y;
}
public static double add(double x, double y, double z) {
return x + y + z;
}
}

T[] 数组名 = new T[N];

int[] array = new int[5];

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

// 注意：虽然省去了new T[], 但是编译器编译代码时还是会还原
int[] array1 = {0,1,2,3,4,5,6,7,8,9};

int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};
// 注意省略格式不可以拆分, 否则编译失败
// int[] array3;
// array3 = {1, 2, 3};

public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}

// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}