Java标识符和关键字（static，final，abstract，interface）

本文的主要内容如下

　   1.标识符合关键字

　　2.Java中的关键字

　　3.static关键 字

　　4.static方法

　　5.静态代码块

　　6.static修饰符综述

　　7.final关键字

　　8.final修饰符综述

　　9.抽象类abstract class

　　10.abstract综述

　　11.抽象类和接口的区别（j精讲）

1.标识符合关键字

　　标识符命名规则

　　　　（1）由字母、数字、下划线、$组成 ，不能以数字开头

　　　　（2）大小写敏感

　　　　（3）不得使用关键字和保留字

　　习惯

　　　　（1）标识符要符合语义信息。

　　　　（2）包名所有字母小写

　　　　（3）类名每个首字母大写其他小写

　　　　（4）变量和方法第一个单词小写第二个开始首字母大写；

　　　　（5）常量所有首字母大写

　　常用的转义字符

　　　1.　\b　　退格　　　　2.\f　　换页　　3.\n　　换行　　4.\r　　回车　　5.\t　　下个tab　　6.\'　　'　　7.\"　　"

2.Java中的关键字

abstract	default	if	private	this
boolean	do	implements	protected	throw
break	double	import	public	throws
byte	else	instanceof	return	transient
case	extends	int	short	try
catch	final	interface	static	void
char	finally	long	stricftp	volatile
class	float	native	super	while
const	for	new	switch
continue	goto	package	synchronized

　　注意：

　　　　1.true、false、null不是关键字是字面量

　　　　2.特殊关键字（保留字）：goto,const

3.static关键字

　　static关键字可以修饰属性、方法、内部类、代码块

　　1.static属性

　　　　1）static修饰的资源属于类级别，是全体对象实例共享的资源

　　　　2）静态属性，是全体类的实例共享的变量。在类加载期间初始化的。使用类名.属性。Math.PI;

　　　　3）实例变量，属于对象的属性。

　　　　　　使用对象.属性访问

　　　　
public class Foo{
　　　　int id;//实例变量
   　　 static int i=0;//静态类级别的的变量
    　　public javaLearn(){
        　　id=i++;
    　　}
}
public class StaticDemo{
　　public static void main(String args[]){
　　　　Foo f1=new Foo();
　　　　Foo f2=new Foo();
　　　　System.out.println(f1.id+""+f2.id+""+f3.id);　　
}
}

　　　　id相当于水杯则i相当于水桶。程序执行的过程如下

　　　　第一步加载类　　　　　　　　      static在类加载期间初始化

　　　　第二步在内存中分配对象空间。　　属性自动初始化，为“0”值（）

　　　　第三步进行属性的赋值

　　　　第四步递归调用父类的构造器　　　默认调用父类的无参构造函数

　　　　第五步调用本类的构造器

4.static方法

　　属于类的方法一般用来表示工具的方法，在类加载后就可以自己调用不需要创建任何类的实例对象。

class Moo{
    int a=2;
    public static int main(String[] args) {
        return a;//静态的方法不能访问属于对象的资源
    }
}

5.静态代码块

　　静态代码是在类加载期间运行的代码块，由于类只加载一次所以静态代码块只加载一次。静态代码块不是很常见，一般用来在类加载后初始化以写静态资源的时候使用。

　　如加载配置文件

static{
       System.out.println("类加载了");
}

6.static修饰符综述

　　static修饰属性（类变量）

　　　　类名.属性名，为本类所有对象所共享，生成对象时先加载后构造。类变量会在加载时自动初始化，类中的实例变量是在创建对象的时候被初

　　　　始化的。类加载的过程只进行一次也就是说类变量只会被创建一次。

　　static修饰方法

　　　　类名.方法，为本类所有方法所共享，该方法不能访问非静态的成员，但是本类的非静态成员可以访问静态的成员。在静态成员中不能出现this关键字。

　　　　父类中的静态方法子类不能覆盖为非静态的方法，在符合覆盖的条件下父类的静态方法可以被子类所覆盖但是没有多态。Java中的main方法必须写成

　　　　静态的原因是：在类加载时无法创建对象，而静态的方法可以不通过创建对象来调用，所以通过main方法入口来运行程序。

　　static修饰的代码块

　　　　这个代码只有类加载时被执行一次。可以使用静态代码块初始一个类

　　　　动态初始化块写在雷替的{}这个是在对象生成的 时候运行。

class Moo{
    static int a1=2;
    Moo a=new Moo();
    int b=Moo.a1;
}

　　静态成员不能被其所在class创建的实例所访问的。

7.final关键字

　　1.final修饰的类不能被继承

　　　　String就是final类不能被继承

　　　　Mtah是final类不能被继承

　　　　Integer、Long、Character等包装器是final类不能被继承

　　　　在实际开发中原则上不予许使用final类！因为在Spring，Hiberate，Struts2,这些框架使用了动态继承代理技术，使用final类会影响"动态继承代理技术"的实现

　　2.final修饰的方法不能再被覆盖

　　3.final修饰的变量，初始化后就不允许再修改了。

　　　　final的局部变量

　　　　final的方法参数

　　　　final的成员变量

　　4.final static 修饰的变量作为常量。

　　　　一般常量名都用大写

　　　　Java常量的修饰不是const（c、c++修饰常量的修饰符）

　　final修饰的类不能被继承

　　注意：

　　　　final的局部变量，只能初始化不能改

　　　　final的方法参数，不能改

　　　　final的引用，引用指向不能改，但是对象的属性可以改

8.final修饰符综述

　　final修饰变量

　　　　被final修饰的变量就会 变成常量，一旦赋值就不能改变，常量可以在初始时赋值也可以在构造方法中赋值但是不能不赋值（对象数据成员被声明为final，单没有明确使用=赋值，表示延迟对象成员值的指定，在构造函数执行流程中，一定要有对数据成员指定值的动作不然会编译错误）。常量不会有默认初始值；锁定栈，使得栈

　　　　中的位置不可以改变。静态常量（final static）只能在初始化时直接赋值。

　　final修饰方法

　　　　被final修饰的方法不能被子类所覆盖，保持方法的稳定不被覆盖。

　　final修饰类

　　　　不能被继承

　　　　final类中的方法也是final的。

　　注意：

　　　　final不能用来修饰构造器；

　　　　final修饰一个变量是是引用变量不能变引用对象的内容是可以变得。

9.抽象类（abstract class）

　　抽象方法，只有行为的该娘没有具体的行为实现

　　　　使用abstract关键字修饰，并且没有方法体

　　　　包含抽象方法的类一定是抽象类

　　　　抽象类不能直接创建实例可以定义引用变量。

　　　　　　Shape shape=new Shape();错

　　　　　　Shape shape=new Circle();对

　　　　抽象类只能被继承，一个具体类继承一个抽象类，必须实现所有的抽象方法。

　　　　抽象类和抽象方法非常适合作为系统的分析和设计的工具。

10.抽象类综述

　　abstract修饰类

　　　　这个类是抽象类不能生成实例但是可以作为对象变量的申明的类型编译时类型。抽象类相当于类的一个半成品，需要子类继承并覆盖其中的抽象方法，

　　　　这时子类才有创建实例的能力，如果子类没有实现父类的抽象方法那么子类也要为抽象类

　　abstract修饰方法

　　　　只有声明没有实现，在子类中实现，实现部分用“;”代替，需要子类继承实现。

　　　　注意：

　　　　　　有抽象的方法类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以是全是具体的方法。

　　　　　　abstract与final不能同时使用。final阻止重写和继承的。

　　　　　　abstract与private也不能同时修饰方法，因为private阻止继承，也阻止了重写的事实。

11.抽象类与interface的区别

　　　　抽象类不能创建实例

　　　　抽象类的抽象方法不需在具体的子类来实现，不能有抽象额构造方法或者抽象的静态方法。

　　　　接口是抽象类的一种特例，接口中的所有方法都必须是抽象的，接口的方法默认为public abstract类型，接口中的成员变量默认为 public static final类型

　　区别如下

　　　　抽象类可以有构造方法，接口中不能有构造方法。

　　　　抽象类可以有普通成员变量，接口中没有。

　　　　抽象类中包含非抽象的方法，接口中的所有方法必须是抽象的。

　　　　抽象类的抽象方法访问的类型可以是public，protected和默认类型（最好不要），接口接口方法只能是public类型的，，并且默认为public abstract类型。

　　　　一个类只能继承一个抽象类，但可以实现多个接口。

摘自http://www.cnblogs.com/yongjiapei/p/5494894.html

　　你选择使用接口和抽象类的依据是什么？

　　　　接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。

　　抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。

　　人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.

　　所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

　　　　当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实

　　际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。

　　而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。

　　总结几句话来说：

　　1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

　　2、抽象类要被子类继承，接口要被类实现。

　　3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

　　4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

　　5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部

　　实现接口方法，那么该类也只能为抽象类。

　　6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果

　　7、抽象类里可以没有抽象方法

　　8、如果一个类里有抽象方法，那么这个类只能是抽象类

　　9、抽象方法要被实现，所以不能是静态的，也不能是私有的。

　　10、接口可继承接口，并可多继承接口，但类只能单根继承。

1.抽象类 和 接口 都是用来抽象具体对象的. 但是接口的抽象级别最高
2.抽象类可以有具体的方法 和属性,  接口只能有抽象方法和不可变常量
3.抽象类主要用来抽象类别,接口主要用来抽象功能.
4、抽象类中，且不包含任何实现，派生类必须覆盖它们。接口中所有方法都必须是未实现的。