java语言的特点：
1、简单
2、面向对象（重要特性）：java完全具备面向对象的三个基本特性：封装、继承和多态，去掉了多继承等复杂的该概念，只支持单继承
3、分布式：jdk中包含了支持HTTP和FTP等基于TCP/IP协议的类库。java程序可凭借URL打开并访问网络上的对象，其访问方式与访问本地系统几乎完全相同
4、结构中立：Java 程序需要在很多不同网络设备中运行，为能够使 Java 程序能在网络的任何地方运行Java 编译器编译生成了与机器结构（CPU 和操作系统）无关的字节码（byte-code）文件。任何种类的计算机，只要可以运
行 Java 虚拟机，字节码文件就可以在该计算机上运行
5、可移植：针对不同的CPU和操作系统java虚拟机右不同的版本，这样就可以保证相同的java字节码文件可移植到多个不同的平台上面运行
6、解释执行：为实现跨平台，java设计成为解释执行的，即java源代码文件首先被编译成为字节码文件，这些字节码本身包含了许多编译时生成的信息，在运行时候java编译器负责将字节码文件解释成为特定的机器码进行运行
7、健壮：java采用自动内存垃圾回收机制，程序员不再需要管理内存，从而减少内存错误的发生，提高了程序的健壮性
8、安全：java虚拟机采用的是“沙箱”运行模式，即把java程序的代码和数据都限制在一定内存空间里执行，不允许程序访问该内存空间外的内存
9、高性能、
强制类型转换：在变量或常量之前加上"(目标类型)"实现
引用数据类型（相当于指针类型）（复杂数据类型）{含类、接口和数组声明的数据类型}
运算符(一元运算符和二元运算符)
一元：- （取反）、++、--
二元：+、-、*、/、%（取余）
算数赋值运算符（一般用于变量自身的变化）：+=、-=、*=、/=、%=
关系运算符（结果是布尔类型数据）：==、！=、>=、<=、< 、>
逻辑运算符（对布尔型变量进行运算）（实际编程中优先考虑短路与或短路或）：！(逻辑非)、&（逻辑与）、|（逻辑或）、 &&（短路与：如果a为false，则不计b）、||（短路或：如果a为true，则不计b）
例子：示例代码如下：
int i = 0;
int a = 10;
int b = 9;
if ((a > b) || (i == 1)) { ①
System.out.println("或运算为 真");
} else {
System.out.println("或运算为 假");
}
if ((a < b) && (i == 1)) { ②
System.out.println("与运算为 真");
} else {
System.out.println("与运算为 假");
}
if ((a > b) || (a++ == --b)) { ③
System.out.println("a = " + a);
System.out.println("b = " + b);
}
上述代码运行输出结果如下：
或运算为 真
与运算为 假
80 / 237
a = 10, b = 9
其中，第①行代码进行短路计算，由于(a > b)是 true，后面的表达式(i == 1)不再计算，
输出的结果为真。类似地，第②行代码也进行短路计算，由于(a < b)是 false，后面的表达
式(i == 1)不再计算，输出的结果为假。 代码第③行中在条件表达中掺杂了++和—运算，由于(a > b)是 true，后面的表达式(a++
== --b)不再计算，所以最后是 a = 10, b = 9。如果把短路或（||）改为逻辑或（|），那么输
出的结果就是 a = 11, b = 8 了。
******没怎么看=>位运算（是以二进位（bit）为单位进行运算的，操作数和结果都是整形数据）：&、|、^、~、>>、<<、>>>以及相应的赋值运算符
其他运算符：三元运算符（？：）例：x?y:z
小括号。起到改变表达式运算顺序作用，它的优先级最高
中括号。数组下标
引用号（.）。对象调用实例变量或实例方法的操作符，也是类调用静态变量或静态方法的操作符
实例：Date date = new Date(); //new运算符可以创建Date对象
System.out.println(date.toString()); //通过.运算符调用方法
赋值号（=）
instanceof。判断某个对象是否属于某个类
new。对象内存分配运算符
箭头（->）。java8新增加的，用来声明Lambda表达式
双冒号（：：）。java8新增加，用于Lambda表达式中方法的引用
运算符优先级：
1、 . (引用号) 小括号 中括号
2、 ++ -- -(数值取反) ~(位反) !(逻辑非) 类型转换小括号
3、 * / %
4、 + - 5 << >> >>>
6、 < > <= >= instanceof
7、 == !=
8、 &(逻辑与、位与) 9 ^(位异或)
10、 |(逻辑或、位或)
11、 &&
12、 ||
13、 ?:
14、 ->
15、 = *= /= %= += -= <<= >>= >>>= &= ^= |
大体顺序，从高到低：算数运算符-> 位运算符-> 关系运算符-> 逻辑运算符-> 赋值运算符
控制语句
分支语句：if和switch（表达式计算结果只能是int、byte、short和char类型，不能是long更不能其他类型）
循环语句：while、do-while和for 另外java5之后推出for-each循环语句
跳转语句：break、continue、return和throw
for-each实例：
假设有一个数组，采用 for 语句遍历数组的方式如下：
//
int[] nums ={ 43, 32, 53, 54, 75, 7, 10};
System.out.println("----for-------");
//
for(int i = 0;i<nums.length;i++){
System.out.println("Count is:" + nums[i]);
}
那么采用 for-each 循环语句遍历数组的方式如下：
// 声明并初始化int数组
int[] nums = { 43, 32, 53, 54, 75, 7, 10 };
System.out.println("----for each----");
// for-each语句
for (int item : nums) {
System.out.println("Count is:" + item);
}
break 语句有两种方式:带有标签和不带标签
break; //不带标签
break label; //带标签，label是标签名
实例：
不带标签的：
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (int i = 0; i < numbers.length; i++) {
if (i == 3) {
//跳出循环
break;
}
System.out.println("Count is: " + i);
}
结果如下：
Count is: 0
Count is: 1
Count is: 2
带标签的：
label1: for (int x = 0; x < 5; x++) { ①
for (int y = 5; y > 0; y--) { ②
if (y == x) {
//跳转到label1指向的循环
break label1; ③
}
System.out.printf("(x,y) = (%d,%d)", x, y);
// 打印一个换行符，实现换行
System.out.println();
} }
System.out.println("Game Over!");
运行结果如下：
(x,y) = (0,5)
(x,y) = (0,4)
(x,y) = (0,3)
(x,y) = (0,2)
(x,y) = (0,1)
(x,y) = (1,5)
(x,y) = (1,4)
(x,y) = (1,3)
(x,y) = (1,2)
Game Over!
如果 break 后面没有指定外循环标签，则运行结果如下：
(x,y) = (0,5)
(x,y) = (0,4)
(x,y) = (0,3)
(x,y) = (0,2)
(x,y) = (0,1)
(x,y) = (1,5)
(x,y) = (1,4)
数组：
基本特性：1、一致性：数组只能保存相同数据类型的元素
2、有序性：数组中的元素是有序的，可通过下标访问
3、不可变性：数组一旦初始化，则长度（数组中元素的个数）可不变
在java中数组下标是从零开始的，java数组下标访问运算符是中括号，如intArray[0]，表示访问intArray数组的第一个元素，0是第一个元素的下标。
java中的数组本身是引用数据类型，它的长度属性是length。
数组又可以分为一维数组和二维数组
一维数组：数组中每个元素都是带一个下标时，就是一维数组。数组时引用数据类型，引用数据类型在使用之前一定要做：声明和初始化
数组声明：宣告这个数组中元素类型，数组的变量名
语法如下：元素数据类型[] 数组变量名;（推荐采用）
元素数据类型 数组变量名[];
数组初始化：静态初始化和动态初始化
静态初始化： 举例： int[] intArray;
//静态初始化int数组
intArray = {21,32,43,45};
String[] strArray;
//静态初始化Stirng数组
strArray = {"张三","李四","王五","董六"};
//声明同时初始化数组
int intArray[] = {21,32,43,45};
String strArray[] = {"张三","李四","王五","董六"};
当不知道元素有多少，更不知道元素的内容，可采用动态初始化
动态初始化：（动态初始化使用new运算符分配指定长度的内存空间）
int intArray[];
// 动态初始化int数组
intArray = new int[4]; ①
intArray[0] = 21;
intArray[1] = 32;
intArray[2] = 43;
intArray[3] = 45; ②
// 动态初始化String数组
String[] stringArray = new String[4]; ③
// 初始化数组中元素
stringArray[0] = "张三";
stringArray[1] = "李四";
stringArray[2] = "王五";
stringArray[3] = "董六"; ④
new分配数组内存空间后，数组中的元素内容是：数组类型的默认值，不同类型默认值不同
******数组合并
二维数组声明：
元素数据类型[][] 数组变量名;
元素数据类型 数组变量名[][];
元素数据类型[] 数组变量名[];
二维数组的初始化：动态与静态
静态初始化示例：
示例：int intArray[][] = { { 1, 2, 3 }, { 11, 12, 13 }, { 21, 22, 23 }, { 31, 32, 33 } };
上述示例，创建并初始化了一个 4×3 二维数组
动态初始化语法：
new 元素数据类型[高维数组长度] [低维数组长度] ;
示例：int[][] intArray = new int[4][3];
示例：
public class HelloWorld {
public static void main(String[] args) {
// 静态初始化二维数组
int[][] intArray = {
{ 1, 2, 3 },
{ 11, 12, 13 },
{ 21, 22, 23 },
{ 31, 32, 33 } };
// 动态初始化二维数组
double[][] doubleArray = new double[4][3];
// 计算数组intArray元素的平方根，结果保存到doubleArray
for (int i = 0; i < intArray.length; i++) {
for (int j = 0; j < intArray[i].length; j++) {
// 计算平方根
doubleArray[i][j] = Math.sqrt(intArray[i][j]); ① }
}
// 打印数组doubleArray
for (int i = 0; i < doubleArray.length; i++) {
for (int j = 0; j < doubleArray[i].length; j++) {
System.out.printf("[%d][%d] = %f", i, j, doubleArray[i][j]);
System.out.print('\t');
}
System.out.println();
}
}
}
其中：Math.sqrt(intArray[i][j])表达式是计算平方根，Math是java.lang包中提供的用于数学计算类，它提供很多常用的数学计算方法，sqrt是计算平方根，如取绝对值的abs、幂运算的pow等
面向对象
三大基本特性：1、封装性
2、继承性
3、多态性
1.1类
1.1.1 类声明：类声明和类体
[public][abstract|final] class className [extends superclassName] [implements interfaceNameList] {
//类体
}
class是声明类的关键字，className 是自定义的类名；class 前面的修饰符 public、
abstract、final 用来声明类。
superclassName 为父类名，可以省略，如果省略则该类继承 Object 类，Object 类所有类
的根类，所有类都直接或间接继承 Object；interfaceNameList 是该类实现的接口列表，可
以省略，接口列表中的多个接口之间用逗号分隔。
类体是类的主题，包括数据和操作，即成员变量和成员方法
1.1.2 成员变量
声明类体中成员变量语法格式如下：
class className {
[public | protected | private ] [static] [final] type variableName; //成员变量
}
type是成员变量数据类型，variableName是成员变量名。type前的关键字都是成员变量修饰符
1. public、protected 和 private 修饰符用于封装成员变量。
2. static 修饰符用于声明静态变量，所以静态变量也称为“类变量”。
3.final修饰符用于声明变量，该变量不能被修改
1.1.3成员方法
class className {
[public | protected | private ] [static] [final | abstract] [native] [synchronized]
type methodName([paramList]) [throws exceptionList] {
//方法体
} }
navite修饰方法，称为本地方法，本地方法调用平台本地代码，不能实现跨平台
synchronized修饰的方法是同步的，当多线程方式同步方法时，只能串行地执行，保证是线程安全的。
方法声明中还有（【paramList】）部分，它是方法的参数列表。throws exceptionList是声明抛出异常列表
1865
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
