java基础知识——基础语法

java的基本语法格式

[修饰符] class 类名{程序代码
}

方法的定义

一般情况下，定义一个方法包含以下语法：

修饰符 返回值类型 方法名(参数类型 参数名){...方法体...return 返回值;
}

JAVA标识符规范：

1.标识符可以由任意顺序的大小写字母、数字、下划线（_）和美元符号组成，不能以数字开头。
2.包名所有字母一律小写。
3.类名和接口名每个单词首字母都要大写。
4.常量名所有字母都要大写，单词之间用下划线连接。
5.变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写，变量名不能使用java中的关键字。
6.我们的变量名最好是用英文单词来描述。(见名知意)

Java驼峰式命名法：
1、变量名必须为有意义的单词
2、变量名如果只有一个单词，则小写
3、如果有2个以及多个单词，则从第二个单词开始首字母大写
给类和方法起名的时候，尽量不要用中文拼音，太长而且不好看。可以借鉴API里面的类似起名。
类名：表示一类对象的抽象，通常是名词，形容词+名词，名词+名词，通常一个英文单词能表示，组合中每个单词首字母大写（AbstractStringBuilder.class）。类名称力求表意，能明确的表达所对应的意思。最好能够体现和其他名称的区分度，比如InputStream和OutputStream，而且容易扩展和分门别类：FileInputStream、InputStreamReader。
方法名：表示对象的行为，通常是动词，或者动词+宾语，动词的首字母小写，其他单词首字母大写（doSomething()）。方法起名根据用法，比如判断（isOK()）、能否（canRead()）、获得（getThings()）、从…（cutFrom(…)）、变成（toString()）、无对象行为（run()）和有对象行为（goto(Object where）等等，好记很多。
最后记一记常用的单词：
outer外部、inner内部、append附加、sub（子的）和sup（父的）、before之前、width宽、height高、default默认、switch匹配、index位置、count计数、encapsulation封装、init初始、show展示、para参数、sort排序、trim整理、buffer缓冲、ignore忽视、concatenate连接、submit提交、parse解析、confirm确认、set设置、none空无、scroll滚动、on当…、to变成、of什么的、at在…、max最大的、min最小的、add加、only只、constructor构造器、overload重载、override重写、position位置、inheritance继承、print打印、log日志、undo撤销、contain包含、result结果、connect连接、create创建、charset字符、translate翻译、direct方向、POST推送、channel频道、attribute属性、content内容、redo重做、edit编辑、format格式化、validate验证、invalidate失效、view视图、control控制、active活跃的、bean实体、order次序、simple简单、access访问、factory工厂、client客户端、prefix前缀、proxy代理、action动作、frame框、mapping映射、forward向前、backward向后、scope范围、dispatch分发、operate操作、iterate迭代、Iterator迭代器、condition条件、fresh刷新、member成员、fetch取得、identity标识、query查询、exact精确的、inverse反转、context上下文、aspect方面、orient朝向、advice通知、interceptor拦截器、target目标、focus焦点、remove移除、remote远程、synchronize同步、asynchronize异步、schedule时间表、point分数、total全部的、reference关系、insert插入、compare对比、rectangle矩形、triangle三角形、circle圈、invert倒转、since从…之后、date日期等。
API源码，返回值->方法名->参数名->注释->说明，都是最常用的单词，看多了英语也会有很大提升。

Java修饰符

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized

Java 变量

Java 中主要有如下几种类型的变量

局部变量
类变量（静态变量）
成员变量（非静态变量）

Java 关键字

下面列出了 Java 关键字。这些关键字不能用于常量、变量、和任何标识符的名称。

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
类、方法和变量修饰符	abstract	声明抽象
	class	类
	extends	扩充,继承
	final	最终值,不可改变的
	implements	实现（接口）
	interface	接口
	native	本地，原生方法（非 Java 实现）
	new	新,创建
	static	静态
	strictfp	严格,精准
	synchronized	线程,同步
	transient	短暂
	volatile	易失
程序控制语句	break	跳出循环
	case	定义一个值以供 switch 选择
	continue	继续
	default	默认
	do	运行
	else	否则
	for	循环
	if	如果
	instanceof	实例
	return	返回
	switch	根据值选择执行
	while	循环
错误处理	assert	断言表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕获异常
包相关	import	引入
	package	包
基本类型	boolean	布尔型
	byte	字节型
	char	字符型
	double	双精度浮点
	float	单精度浮点
	int	整型
	long	长整型
	short	短整型
变量引用	super	父类,超类
	this	本类
	void	无返回值
保留关键字	goto	是关键字，但不能使用
	const	是关键字，但不能使用
	null	空

接口

在 Java 中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。
接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

Java语言支持的变量类型

类变量：独立于方法之外的变量，用 static 修饰。

1.类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
2.静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
3.静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
4.与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
5.默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
6.静态变量可以通过：ClassName.VariableName的方式访问。
7.类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

实例变量：独立于方法之外的变量，不过没有 static 修饰。

1.实例变量声明在一个类中，但在方法、构造方法和语句块之外；
2.当一个对象被实例化之后，每个实例变量的值就跟着确定
3.访问修饰符可以修饰实例变量；
4.实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
5.实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
6.实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

局部变量：类的方法中的变量。

1.局部变量声明在方法、构造方法或者语句块中；
2.访问修饰符不能用于局部变量；
3.局部变量是在栈上分配的。
4.局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

非访问修饰符

static 修饰符，用来修饰类方法和类变量。

1.静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为 static 变量。

类名.变量名//静态变量可以使用如下语法来访问

2.静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

类名.方法//静态方法可以使用如下两种语法来访问
实例对象名.方法

3.静态代码块
当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块也只执行一次。通常会使用静态代码来对类的成员变量进行初始化。

static{//静态代码块的语法}

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

1.final 变量：
（1）.final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
（2）.final 修饰符通常和 static 修饰符一起使用来创建类常量。
2.final 方法
（1）.父类中的 final 方法可以被子类继承，但是不能被之类重写。
（2）.声明 final 方法的主要目的是防止该方法的内容被修改。
3.final 类
final 类不能被继承，没有类能够继承 final 类的任何特性。

abstract 修饰符，用来创建抽象类和抽象方法。

1.抽象类：
（1）.抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
（2）.一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
（3）.抽象类可以包含抽象方法和非抽象方法。
2.抽象方法
（1）.抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
（2）.任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
（3）.抽象方法的声明以分号结尾，例如：public abstract sample();。

synchronized 和 volatile 修饰符，主要用于线程的编程。

1.synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
2.transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
3.volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个 volatile 对象引用可能是 null。

instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof运算符使用格式如下：

( Object reference variable ) instanceof  (class/interface type)

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

下面是一个例子：

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

如果被比较的对象兼容于右侧类型,该运算符仍然返回true。

Java 增强 for 循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式) {//代码句子
}

1.声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
2.表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

public class Test {//举例public static void main(String args[]){int [] numbers = {10, 20, 30, 40, 50};for(int x : numbers ){System.out.print( x );System.out.print(",");}System.out.print("\n");String [] names ={"James", "Larry", "Tom", "Lacy"};for( String name : names ) {System.out.print( name );System.out.print(",");}}
}

以上实例编译运行结果如下：

10,20,30,40,50,
James,Larry,Tom,Lacy,

Arrays 类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

具体说明请查看下表：

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

可变参数

JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。

方法的可变参数的声明如下所示：

typeName... parameterName

在方法声明中，在指定参数类型后加一个省略号(…) 。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

实例

public class VarargsDemo {public static void main(String args[]) {// 调用可变参数的方法printMax(34, 3, 3, 2, 56.5);printMax(new double[]{1, 2, 3});}public static void printMax( double... numbers) {if (numbers.length == 0) {System.out.println("No argument passed");return;}double result = numbers[0];for (int i = 1; i <  numbers.length; i++){if (numbers[i] >  result) {result = numbers[i];}}System.out.println("The max value is " + result);}
}

以上实例编译运行结果如下：

The max value is 56.5
The max value is 3.0

finalize() 方法

Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。

例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。

在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。

finalize() 一般格式是：

protected void finalize() {// 在这里终结代码
}

关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。

当然，Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用上面的方法。

实例

public class FinalizationDemo { public static void main(String[] args) { Cake c1 = new Cake(1); Cake c2 = new Cake(2); Cake c3 = new Cake(3); c2 = c3 = null; System.gc(); //调用Java垃圾收集器}
} class Cake extends Object { private int id; public Cake(int id) { this.id = id; System.out.println("Cake Object " + id + "is created"); } protected void finalize() throws java.lang.Throwable { super.finalize(); System.out.println("Cake Object " + id + "is disposed"); }
}

运行以上代码，输出结果如下：

$ javac FinalizationDemo.java
$ java FinalizationDemo
Cake Object 1is created
Cake Object 2is created
Cake Object 3is created
Cake Object 3is disposed
Cake Object 2is disposed

Java Scanner 类

java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。

下面是创建 Scanner 对象的基本语法：

Scanner s = new Scanner(System.in);

next() 与 nextLine() 区别

next():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。

nextLine()：

1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。
如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取：