Java基础大全

Java基础语法

基本数据类型：byte，short，int，long

浮点类型：float，double

字符类型：char

布尔类型：boolean

注释：//单行注释，/**/多行注释，/** */文档注释

关键字：

abstract	表明类或者成员方法具有抽象属性
assert	断言，用来进行程序调试
boolean	基本数据类型之一，布尔类型
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	声明一个类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范 [1]
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

表格中的实例假设整数变量A的值为10，变量B的值为20：

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
--	自减: 操作数的值减少1	B-- 或 --B 等于 19（区别详见下文

 

自增自减运算符

1、自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。

 

2、前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。

 

3、后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算 

关系运算符

下表为Java支持的关系运算符

表格中的实例整数变量A的值为10，变量B的值为20：

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

 

位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~A= 1100 0011

逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
| |	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A | | B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false

赋值运算符

下面是Java语言支持的赋值运算符：

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	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 |

Java运算符优先级

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

例如，（1+3）＋（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。

再如，x = 7 + 3 * 2;这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	expr++ expr--	从左到右
一元	++expr --expr + - ～ ！	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>>  <<	左到右
关系	> >= < <=	左到右
相等	==  !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	|	左到右
逻辑与	&&	左到右
逻辑或	| |	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = | =	从右到左
逗号	，	左到

 

Java 数组

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量number0，number1，....，number99。

本教程将为大家介绍 Java 数组的声明、创建和初始化，并给出其对应的代码。

 

声明数组变量

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar;   // 首选的方法

 

或

 

dataType arrayRefVar[];  // 效果相同，但不是首选方法

JAVA 类和对象的实例

什么是类？

1. 类是具有相同的属性和功能的事物的抽象的集合，在面向对象程序设计中，人们把一类事物的静态属性和动态可以执行的操作组合在一起就得到类这个概念。

2. 类是个抽象的概念，用来模拟一类事物，一旦定义了一个类，这个类就永远存在。

比如：人，人有男人和女人，他们都有身高，体重等相同的属性，他们都具有走路，吃饭，工作等这些相同的，可动态执行的操作，所以可以定义“人类”这样一个类来包含他们相同的属性和功能。

什么是对象，类和对象之间是什么关系，怎样创建一个对象？

1. 对象是类的一个个体，是具体的，实实在在存在的事物，它有自己的生命周期，由类可以创建出对象，对象也会消亡。

2. 类一旦被建立后，就可以用这个类创建出任意个对象，然后去操作这些对象，类是抽象的，对象是具体的。

3. 对象也叫实例，是一个真实的实体。

关系： 1. 如果把对象比作是实实在在存在一辆汽车，那么类就是这辆汽车的设计图纸，当然通过设计图纸(类)还可以制造第二辆，第三辆这样的汽车(对象)。

2. 如上，通过Person类可以创建出一个叫“小明”的对象，也可以创建出另一个叫“阿黄”的对象。

语法

class 类名称 {

属性 (变量) ;

行为 (方法) ;

}

（1）格式一：声明并实例化对象

1.类名称 对象名称 = new 类名称 () ;

（2）格式二：先声明对象，然后实例化对象：

1.类名称 对象名称 = null ;

2.对象名称 = new 类名称 () ;

事例，比如如何定义一个Person的类

然后可以在定义一个对象，比如new 一个小明

或者这样

Java访问权限控制

修饰符用来定义类、方法或者变量，通常放在语句的最前端。

Java语言提供了很多修饰符，主要分为以下两类：

• 访问修饰符
• 非访问修饰符

其中非访问修饰符主要有：static、final、abstract、synchronized和volatile，非访问修饰符根据各自的特性来保证特定功能的实现。

Java中使用访问控制符来保护对类、变量、方法和构造方法的访问，访问控制修饰符对应的权限控制的大小情况为：public > protected > default(包访问权限) > private。

 

编译单元和包

编译单元：即为最小的可以被编译且执行的Java文件。

一个.java文件就是一个编译单元，一个编译单元必须只包含有一个public类，可以包含有其他非public的类，并且用publi类标示的类名必须和文件名相同。如果.java文件中不包含有publi类，则这个类也是没有意义的，因为不能被外界所访问。.java文件中包含有几个类，编译后就会生成几个.class文件。

包含有一组类，是以一个名字空间集合在一起的类而已。

 

 

访问控制修饰符

• public : 对所有类可见
  使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见
  使用对象：变量、方法。 注意：不能修饰类（外部类）
• default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符
  使用对象：类、接口、变量、方法。
• private : 在本类中可见
  使用对象：变量、方法。 注意：不能修饰类（外部类）

private和protected修饰符不能用以修饰类/接口

 

2.1 公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。

由于类的继承性，类所有的公有方法和变量都能被其子类继承。

 

2.2 受保护的访问修饰符-protected

protected 又称继承访问权限

protected 需要从以下两个点来分析：

• 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
• 子类与基类不在同一包中：在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法

子类能访问 protected 修饰符声明的方法和变量，这样就能避免不相关的类使用这些方法和变量。

在碰到涉及protected成员的调用时，首先要确定出该protected成员来自何方，其可见性范围是什么，然后就可以判断出当前用法是否可行了

package p2;

class MyObject2 {

protected Object clone() throws CloneNotSupportedException{

       return super.clone();

    }

}

 

package p22;

public class Test2 extends MyObject2 {

    public static void main(String args[]) {

       MyObject2 obj = new MyObject2();

       obj.clone(); // Compile Error         ----（1）

 

       Test2 tobj = new Test2();

       tobj.clone(); // Complie OK         ----（2）

    }

}

对于(1)而言，clone()方法来自于类MyObject2本身，因此其可见性为包p2及MyObject2的子类，虽然Test2是MyObject2的子类，但在Test2中不能访问基类MyObject2的protected方法clone()，因此编译不通过;

对于(2)而言，由于在Test2中访问的是其本身实例的从基类MyObject2继承来的的clone()，因此编译通过。

 

 默认访问修饰符-不使用任何关键字

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。

接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

 

私有访问修饰符-private

被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。

声明为私有访问类型的变量可以通过类中公共（public修饰）的 getter 方法被外部类访问。

private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据