Java 是什么?
Java 的特点：
面向对象
平台无关(跨平台)：
简单
安全
体系结构 - 中性
可移植
健壮
多线程
解释型
高性能
分布式
动态
Java安装及环境设置：
java的安装及环境配置可以看java开发环境配置章节。
Java 基础语法
对象 - 对象有状态和行为。例如：狗有状态色，名字，品种以及行为 - 摇头晃脑，吠叫，吃。对象是类的一个实例。
类 - 类可以被定义为一个模板/蓝本描述该行为/状态及其支持对象类型。
方法 - 方法基本上是一个行为。一个类可以包含(拥有)多个方法。 将逻辑写入方法，数据操纵和所有的动作都会被执行。
实例变量 - 每个对象都有其独特(唯一)的实例变量。对象的状态是由分配给这些瞬间变量的值来创建。
第一个Java程序：
让我们来看看，以下代码将打印一个简单词语 Hello World
public class MyFirstJavaProgram{
/* This is my first java program.
* This will print 'Hello World' as the output
*/
public static void main(String []args){
System.out.println("Hello World"); // prints Hello World by manongjc.com
}
}
关于Java程序，记住以下几点非常重要。
区分大小写 - Java是大小写敏感的，这意味着标识Hello和hello在Java中有不同的含义。
类名称 - 对于所有的类名首字母应该大写。如果几个单词来形成一个类的名字，那么每个单词的第一个字母应该大写。例如：class MyFirstJavaClass
方法名称 - 所有方法的名称的开始字母应该用小写字母。如果几个单词来形成方法的名称，那么每个单词的第一个字母要大写。例如：public void myMethodName()
程序文件名 - 程序文件名应当和类名完全匹配。保存文件时，应该使用类名保存它(记住Java是区分大小写)，再追加 '.java' 到文件名称的末尾.(如果文件名和类名不匹配程序将无法编译)。例如：假设“MyFirstJavaProgram”是类名。那么这个文件应当被保存为 'MyFirstJavaProgram.java'
public static void main(String args[]) - java程序处理是从main()方法开始，这是每一个Java程序开始的必须部分.
Java 标识符：
所有的Java组件都需要一个名字。用于类，变量和方法名称叫做标识符。
在Java中的标识符有几点要记住。它们如下：
所有的标识符应该由字母(A至Z或a到z)，货币字符($)或下划线(_)组成。
标识符的第一个字符之后可以具有字符的任意组合。
关键字不能被用作标识符。
标识符最重要特点是区分大小写的。
合法标识符的示例：age, $salary, _value, __1_value
非法标识符的示例：123abc, -salary
Java修饰符：
就像其它语言，它可以改变类，方法等，通过使用修辞符。有两大类的修辞符。
访问修饰符 : default, public , protected, private
非访问修饰符 : final, abstract, strictfp
我们将会在下一节中研究/学习有关修饰符的更多细节。
Java 变量:
我们会看到下面Java的变量类型：
局部变量
类变量(静态变量)
实例变量(非静态变量)
Java 数组:
数组是存储相同类型的多个变量的对象。然而数组本身就是在堆上的对象。我们将探讨如何声明，构建并初始化在即将到来的章节。
Java 枚举:
枚举是在Java 5.0中才开始进行介绍。枚举一个变量只限于几个预定义值之一。在此枚举列表中的值称为枚举。
通过使用枚举能够减少代码的错误的数量。
因为，如果我们考虑了鲜榨果汁店的一个应用实例将有可能限制玻璃尺寸为小，中，大。这将确保不会允许任何人订制尺寸在小型，中型或大型之外的类型。
例子：
class FreshJuice{
enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
FreshJuiceSize size;
}
public class FreshJuiceTest{
public static void main(String args[]){
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice. FreshJuiceSize.MEDIUM ;
System.out.println("Size :" + juice.size);
}
}
注：枚举可以声明为它们自己或在类中。方法，变量，构造函数可以也可以在枚举内定义。
Java 关键字:
下面列出了Java中的保留字(关键字)。这些保留字不可以用作常量或变量或任何其它标识符名称。
| abstract | assert | boolean | break |
| byte | case | catch | char |
| class | const | continue | default |
| do | double | else | enum |
| extends | final | finally | float |
| for | goto | if | implements |
| import | instanceof | int | interface |
| long | native | new | package |
| private | protected | public | return |
| short | static | strictfp | super |
| switch | synchronized | this | throw |
| throws | transient | try | void |
| volatile | while |
Java 注释
Java支持单行和多行注释非常类似于C和C++的注释方式。 所有字符在注释里面，都是会被Java编译器忽略。
public class MyFirstJavaProgram{
/* This is my first java program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments.
*/
public static void main(String []args){
// This is an example of single line comment
/* This is also an example of single line comment. */
System.out.println("Hello World");
}
}
Java数据类型
在Java中可用两种数据类型：
原始数据类型
引用/对象数据类型
原始数据类型
Java语言支持八种原始数据类型。原始数据类型是由语言预定义且由关键字命名。 现在让我们来详细看看八种原始数据类型。
byte
short
int
long
float
double
boolean
char
引用数据类型
使用类定义的构造创建引用变量。它们是用来访问对象。这些变量被声明为一个不能改变的特定类型。例如, Employee, Puppy 等。
类对象，以及各种类型的数组变量，都在参考数据类型。
任何引用变量的缺省值是null。
引用变量可以用于引用声明类型或任何兼容类型的任何对象。例如: Animal animal = new Animal("giraffe")
Java 字面值
字面值是一个源代码表示的固定值。它们是直接用代码来表示，无需任何计算。
字面值可以被分配给任何基本类型的变量。例如：
byte a = 68;
char a = 'A'
在Java中的字符串字面值规定，就像它们在大多数其他语言的字符序列一样，使用一对双引号包围在它们之间。字符串的例子如下：
"Hello World"
"two\nlines"
"\"This is in quotes\""
java语言支持字符串以及一些特殊的转义序列字符文字。它们是：
| 符号 | 字符表示 |
| \n | 新一行 (0x0a) |
| \r | 回车 (0x0d) |
| \f | 换页 (0x0c) |
| \b | 退格 (0x08) |
| \s | 空格 (0x20) |
| \t | tab |
| \" | 双引号 |
| \' | 单引号 |
| \\ | 反斜线 |
| \ddd | 八进制字符 (ddd) |
| \uxxxx | 十六进制UNICODE字符 (xxxx) |
Java访问修饰符：
Java提供了一些访问修饰符来设置类，变量，方法和构造函数的访问级别。这四个访问级别分别是：
可见到包。不需要修饰这是默认的。
只可见到类(private)。
可见到所有 (public).
可见到包和所有子类(protected).
Java运算符
Java提供了一套丰富的运算符来操作变量。我们可以把所有的Java运算符分成以下几组：
1. 算术运算符
假设A=10, B=20，那么
| 运算符 | 描述 | 示例 |
| + | 加法 - 对运算符的两侧的值增加 | A + B = 30 |
| - | 减法- 从左操作数减去右操作数 | A - B = -10 |
| * | 乘法- 相乘操作符两侧值 | A * B = 200 |
| / | 除法 - 由右侧操作数除以左侧操作数 | B / A = 2 |
| % | 模数- 由右侧操作数除以左侧操作数的余数 | B % A = 0 |
| ++ | 增量- 操作数的值增加1 | B++ = 21 |
| -- | 递减 - 操作数的值减小1 | B-- = 19 |
2.关系运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果是，则条件为true。 | (A == B) 不为 true. |
| != | 检查两个操作数的值是否相等，如果值不相等，则条件为true。 | (A != B) 为 true. |
| > | 检查左边的操作数的值是否大于右操作数的值，如果是，则条件为true。 | (A > B) 不为 true. |
| < | 检查左边的操作数的值是否小于右操作数的值，如果是，则条件为true。 | (A < B) 为 true. |
| >= | 检查左边的操作数的值是否大于或等于右操作数的值，如果是，则条件为true。 | (A >= B) 不为 true. |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件变为true。 | (A <= B) 为 true. |
3.位运算符：
| 运算符 | 描述 | 示例 |
|---|---|---|
| & | 二进制与（AND）操作符拷贝位的结果，如果它存在于两个操作数。 | (A & B) = 12 也就是 0000 1100 |
| | | 二进制或（OR）操作符拷贝位，如果它存在一个操作数中。 | (A | B) = 61 也就是 0011 1101 |
| ^ | 二进制异或操作符拷贝，如果它被设置在一个操作数而不是两个比特。 | (A ^ B) = 49 也就是 0011 0001 |
| ~ | 二进制的补运算符是一元的，具有“翻转”位的效应。 | (~A ) = -61 也就是 1100 0011 以2的补码形式，由于它是一个带符号二进制数。 |
| << | 二进制向左移位运算符。左边的操作数的值由右操作数指定的位数向左移动。 | A << 2 = 240 也就是 1111 0000 |
| >> | 二进制向右移位运算符。左边的操作数的值是通过右操作数指定的位数向右移动。 | A >> 2 = 15 也就是 1111 |
| >>> | 右移补零运算符。左边的操作数的值是通过右操作数指定的位数向右移动，并转移值以零填充。 | A >>>2 = 15 也就是 0000 1111 |
4.逻辑运算符：
| 运算符 | 描述 | 示例 |
|---|---|---|
| && | 所谓逻辑与运算符。如果两个操作数是非零那么条件为true。 | (A && B) 为 false. |
| || | 所谓逻辑OR运算符。如果任何两个操作数都非零那么条件变为true。 | (A || B) 为 true. |
| ! | 所谓逻辑非运算符。使用反转其操作数的逻辑状态。如果条件为true，那么逻辑非运算结果为false。 | !(A && B) 为 true. |
5.赋值运算符：
| 运算符 | 描述 | 示例 |
|---|---|---|
| = | 简单的赋值操作符，赋值是从右侧的操作数到左侧的操作数 | C = A + B 将分配 A + B 的值到 C |
| += | 加法与赋值运算符，它将右操作数加上左操作数并分配结果左操作数 | C += A 相当于 C = C + A |
| -= | 减法并赋值运算符，从左边的操作数减去右操作数并分配结果给左操作数 | C -= A 相当于 C = C - A |
| *= | 乘法与赋值运算符，左操作数乘以右操作数并分配结果给左操作数 | C *= A 相当于 C = C * A |
| /= | 除法与赋值运算符， 左操作数除以右操作数并分配结果给左操作数 | C /= A 相当于 C = C / A |
| %= | 模数与赋值运算符， 这需要使用模量两个操作数并分配结果左操作数 | C %= A 相当于 C = C % A |
| <<= | 左移位并赋值运算符 | C <<= 2 类似于C = C << 2 |
| >>= | 右移位并赋值运算符 | C >>= 2 类似于 C = C >> 2 |
| &= | 按位与赋值运算符 | C &= 2 类似于 C = C & 2 |
| ^= | 按位异或并赋值运算符 | C ^= 2 类似于 C = C ^ 2 |
| |= | 按位或并赋值运算符 | C |= 2 类似于 C = C | 2 |
6.其它运算符
Java语言支持其他一些运算符。
6.1 条件运算符 ( ? : ):
条件运算也被称为三元运算符。这个操作符包括三个操作数，用于计算布尔表达式。 此运算符的目标是决定哪个值应分配给变量。运算符可写为：
variable x = (expression) ? value if true : value if false
6.2 instanceOf 运算符:
此运算符仅用于对象引用变量。此运算符检查对象是否是特定类型(类类型或接口类型)。instanceOf运算被写为：
( Object reference variable ) instanceOf (class/interface type)
Java运算符的优先级：
| 分类 | 操作符 | 关联性 |
|---|---|---|
| 后缀 | () [] . (点操作符) | 左到右 |
| 一元 | ++ - - ! ~ | 从右到左 |
| 乘法 | * / % | 左到右 |
| 加法 | + - | 左到右 |
| 移动 | >> >>> << | 左到右 |
| 关系 | > >= < <= | 左到右 |
| 相等 | == != | 左到右 |
| 位AND | & | 左到右 |
| 位XOR | ^ | 左到右 |
| 位 OR | | | 左到右 |
| 逻辑 AND | && | 左到右 |
| 逻辑OR | || | 左到右 |
| 条件 | ?: | 从右到左 |
| 赋值 | = += -= *= /= %= >>= <<= &= ^= |= | 从右到左 |
| 逗号 | , | 左到右 |
while 循环:
while循环是一种控制结构，可以让你重复执行任务的若干次。
while循环的语法是：
while(Boolean_expression)
{
//Statements
}
do ... while循环：
do... while 循环类似于 while 循环，不同的是do ... while循环是保证至少执行一次。
do ... while循环的语法是：
do
{
//Statements
}while(Boolean_expression);
for 循环:
for循环是一个循环控制结构，可以有效地编写需要执行的特定次数的循环。
当知道任务要多少次重复，一个for循环是非常有用的。
for循环的语法是：
for(initialization; Boolean_expression; update) { //Statements }
改进Java的for循环：
从Java5中开始增强了for循环。这主要是用于数组。
增强的for循环的语法是：
for(declaration : expression) { //Statements }
break关键字:
关键字break用于停止整个循环。Break关键字必须使用在任何循环或switch语句中。
Break关键字将停止最内层循环的执行，并开始执行的下一行代码块之后的语句。
continue关键字:
continue关键字可以在任一环的控制结构可以使用。它会导致循环立即跳转到循环的下一次迭代。
在for循环中，continue关键字使流程控制立即跳转到update语句。
在while循环或do/while循环，流控制立即跳转到布尔表达式。
if 语句:
if 语句包含一个布尔表达式后跟一个或多个语句。
一个if语句的语法：
if(Boolean_expression)
{
//Statements will execute if the Boolean expression is true
}
if...else 语句:
if语句可以跟着一个可选的else语句，当else执行时，if 中布尔表达式是假的。
if...else 的语法是:
if(Boolean_expression){
//Executes when the Boolean expression is true
}else{
//Executes when the Boolean expression is false
}
if...else if...else 语句:
if 语句可以跟着一个可选的 else if ... else 语句，这是非常有用的，使用单一的 if...else if 语句以测试各种条件。
if...else 的语法是：
if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
}else if(Boolean_expression 2){
//Executes when the Boolean expression 2 is true
}else if(Boolean_expression 3){
//Executes when the Boolean expression 3 is true
}else {
//Executes when the one of the above condition is true.
}
嵌套 if...else 语句:
嵌套if-else语句始终是合法的。当要 if , else if , else else语句时有几点要牢记。
一个 if 可以有零或一个else，它必须跟从 else if 之后。
一个 if 可以零个或多个 else if ,它们必须在 else 之前。
一旦一个 else if 条件成功，其他剩余的 else if 或 else 将不会被测试。
嵌套 if...else 的语法如下：
if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
if(Boolean_expression 2){
//Executes when the Boolean expression 2 is true
}
}
switch 语句:
switch语句允许一个变量来反对值列表平等的进行测试。每个值被称为一个的情况(case)，该变量被接通检查每种情况。
switch 的语法是：
switch(expression){
case value :
//Statements
break; //optional
case value :
//Statements
break; //optional
//You can have any number of case statements.
default : //Optional
//Statements
}
Java 方法:
Java方法是组合在一起来执行操作语句的集合。当调用System.out.println方法，例如，系统实际上是在控制台上显示执行的语句的消息。
在一般情况下，方法的语法如下：
modifier returnValueType methodName(list of parameters) { // Method body; }
方法定义包含一个方法头和方法体。下面是一个方法的所有部分：
修饰符: 修饰符，这是可选的，告诉编译器如何调用该方法。这定义了该方法的访问类型。
返回类型: 方法可能会返回一个值。returnValueType是方法返回的值的数据类型。有些方法执行所需的操作不返回任何值。在这种情况下，returnValueType是关键字 void.
方法名称: 这是该方法的实际名称。方法的名称和参数表共同构成方法签名。
参数: 参数就像一个占位符。当调用一个方法，传递一个参数值。这个值被称为实际参数或参数。参数列表表示类型，顺序和方法的参数的数量。参数是可选的;也就是说，一个方法可包含任何参数。
方法体: 方法体包含了定义方法执行语句的集合。
Java类和对象：
对象 - 对象有状态和行为。例如： 狗有状态颜色，名字，品种以及行为-摆尾，叫声，吃。对象是类的一个实例。
类- 类可以被定义为一个模板/蓝本来描述行为/状态，其类型支持对象。
一个类的示例如下：
public class Dog{
String breed;
int age;
String color;
void barking(){
}
void hungry(){
}
void sleeping(){
}
}
一个类可以包含任何下列变量类型。
局部变量 . 在方法，构造函数或块里面定义的变量称为局部变量。变量将被声明在方法中并初始化，当方法调用完成变量也将被销毁。
实例变量 . 实例变量是在一个类里，在方法以外的变量。这些变量在类加载时实例化。实例变量可以在类内部的任何方法，构造函数或特定类的块中访问。
类变量 . 类变量是在一个类中声明的变量，任何方法外，用static关键字。
异常处理：
一种捕获异常方法就是使用try和catch关键字组合。 try/ catch块将被置于可能产生异常的代码。一个try/ catch块中的代码被称为保护代码，使用try/ catch语句的语法如下所示：
try
{
//Protected code
}catch(ExceptionName e1)
{
//Catch block
}
多个catch块：
一个try块可以跟随多个catch块。多个catch块的语法如下所示：
try
{
//Protected code
}catch(ExceptionType1 e1)
{
//Catch block
}catch(ExceptionType2 e2)
{
//Catch block
}catch(ExceptionType3 e3)
{
//Catch block
}
throws/throw 关键字:
如果一个方法不处理检查异常，该方法必须使用关键字throws声明它。 throws关键字出现在方法签名的结束位置。
可以抛出一个异常，用throw关键字在一个新实例化或一个刚刚捕获的异常。 试着去了解 throws 和 throw 关键字的不同。
finally 关键字
finally关键字用于创建一个代码块在try块后面。 finally块中的代码始终执行，无论是否发生异常。
使用finally块，可以运行要执行，无论是在受保护的代码会不会发生发生异常都会被执行，可以放一些清理工作之类的语句(代码)。
finally块必须出现在catch块的结束位置，它的语法如下：
try
{
//Protected code
}catch(ExceptionType1 e1)
{
//Catch block
}catch(ExceptionType2 e2)
{
//Catch block
}catch(ExceptionType3 e3)
{
//Catch block
}finally
{
//The finally block always executes.
}
(编辑：雷林鹏 来源：网络|侵删)
来源：https://www.cnblogs.com/pengpeng1208/p/12574261.html