• Java中的标识符如何命名?可以用中文吗?

Java语言中，为各种变量、方法和类等起的名字称为标识符

• Java标识符的命名规则：
  应以字母、下划线、美元符开头
  后跟字母、下划线、美元符或数字
  Java标识符大小写敏感，长度无限制
  1.java中能用作标识符的有：26个英文字母（大、小写），数字，下划线，美元符号$。 但是不能以数字开头。
  2.类名首个字母必须大写，多个单词组成的，每个单词首字母都要大写。
  3.方法名一般首个字母小写（构造方法例外），多个单词组成方法名，后面单词首字母大写。
  4.变量命名规则同方法名名。
  注意：不能使用java中的关键字做标识符。
• Java保留关键字
  Java语言有51个关键字，其中const和goto虽然被保留但未使用。你不能使用保留关键字来命名类、方法或变量。

序号	类别	内容
1	数据类型	boolean int long short byte float double char class interface
2	流程控制	if else do while for switch case default break continue return try catch finally
3	修饰符	public protected private final void static strictfp abstract transient synchronized volatile native
4	动作	package import throw throws extends implements this super instanceof new
5	保留字	true false null goto const

• this关键字有什么含义?在哪些情况下应用?

• 使用this调用本类中的属性。
  现在观察以下代码。看会有哪些问题：

public void setName(String name){
name=name;
}

这里面的两个name都是setName方法中的name参数。
此时，特别希望通过一个指定的标识明确的表示要把传入的name参数的值给类中的属性，所以此时就需要使用this关键字，使用this.name就表示类中的属性。

class Person{
private String name;
private int age;
public Person(String name,int age){
this.setName(name);
this.setAge(age);
}

public void setName(String name){
this.name=name;
}

public void setAge(int age){
this.age=age;
}

public String getName(){
return this.name;
}

public int getAge(){
return this.age;
}

public void print(){
System.out.println(“姓名：”+this.name+”,年龄:this.age”);
}

public class Demo35{
public static void main(String args[]){
Person p1=new Person(“张三”,30);
p1.print();
}
}
}

• 使用this还可以从一个构造方法中调用其他构造方法。
  例如：有以下一个需求，一个类中存放了三个构造方法，但是要求，不管怎么调用，最终都要求可以在对象实例化的时候打印一个“新的对象产生了”的提示。

class Person{
private String name;
privare int age;
public Person(){
System.out.println(“新的对象产生了。。。。”);
}

public Person(String name){
System.out.println(“新的对象产生了。。。。”);
this.name=name;
}

public Person(String name,int age){
System.out.println(“新的对象产生了。。。。”);
this.setName(name);
this.setAge(age);
}

public void setName(String name){
this.name=name;
}

public void setAge(int age){
this.age=age;
}

public String getName(){
return this.name;
}

public int getAge(){
return this.age;
}

public void print(){
System.out.println(“姓名：”+this.name+”,年龄：”+this.age);
}
}

以上代码虽然可以实现功能，但是同样的代码出现了三次，而且后面的两次出现纯属多余吧，用this()的形式可以调用类中的无参构造方法。

class Person{
private String name;
private int age;
public Person(){
System.out.println(“新的对象产生了。。。。”);
}

public Person(String name){
//最终都是调用无参构造方法
this();
this.setName(name);
}

public Person (String name,int age){
this(name);
this.setAge(age);
}

public void  setName(String name){
this.name=name;
}

public void  setAge(int age){
this.age=age;
}

public String getName(){
return this.name;
}

public int getAge(){
return this.age;
}

public void print(){
System.out.println(“姓名：”+this.name+”,年龄：”+this.age);
}
} 

public class Demo36{
public static void main(String args[]){
Person p1=new Person(“张三”,30);
p1.print();
}
}

• 注意点1：
  如果使用this调用了其他构造方法，则此语句，必须写在构造函数方法的首行。

public void fun(){
//发现在调用fun方法的时候，必须设置name的值
this(“zhangsan”);
}

public Person(String name,int age){
this.setAge(age);
this(name);         //----->必须放在首行
}

• 注意点2：
  使用this可以调用本类中的其他构造方法，但是至少留一个构造方法，作为程序的出口。

public Person(){
this(“a”,10);
System.out.println(“新的对象产生了。。。。。”);
}

public Person(String name){
//最终都是调用无参构造方法
this();
this.setName(name);
}

public Person(String name ,int age ){
this(name);        //---->必须放在首行
this.setAge(age);
}

• this最重要的特性——表示当前对象
  当前对象在程序中用以下形式体现：当前操作方法的对象，就称为当前对象。

class Demo{
public void print(){
System.out.println(this);
}
}

public class Demo38{
public static void main(String args[]){
Demo d1 = new Demo();
System.out.println(d1);
d1.println();
System.out.println(“——————————————————”);
Demo d2=new Demo();
System.out.println(d2);
d2.println();
}
}

this关键字是Java语言中一个具有独特作用的关键字。真是由于这个关键字的存在，Java面向对象的特征才表现的淋漓尽致。那么这个this关键字在Java语言中到底有哪些应用呢？笔者今天就给大家揭开这个谜题。

• 应用一：引用成员变量

Public Class Student{
String name; //定义一个成员变量name
private void SetName(String name){ //定义一个参数(局部变量)name
this.name=name; //将局部变量的值传递给成员变量
}
}

如上面这个代码中，有一个成员变量name。同时在方法中有个形式参数，名字也是name。然后再方法中将形式参数name的值传递给成员变量name。虽然我们可以看明白这个代码的含义，但是作为Java编译器它是怎么判断的呢?到底是将形式参数name的值传递给成员变量name，还是反过来讲成员变量name的值传递给形式参数name呢?也就是说，两个变量名字如果相同的话，那么Java如何判断使用哪个变量?此时this这个关键字就起到作用了。This这个关键字其代表的就是对象中的成员变量或者方法。也就是说，如果在某个变量前面加上一个this关键字，其指的就是这个对象的成员变量或者方法，而不是指成员方法的形式参数或者局部变量。为此在上面这个代码中，this.name代表的就是对象中的成员变量，又叫做对象的属性。而后面的name则是方法的形式参数。代码this.name=name就是将形式参数的值传递给成员变量。这就是上面这个代码的具体含义。
一般情况下，在Java语言中引用成员变量或者成员方法都是以对象名.成员变量或者对象名.成员方法的形式。不过有些程序员即使在没有相同变量的时候，也喜欢使用this.成员变量的形式来引用变量。这主要是从便于代码的阅读考虑的。一看到这个this关键字就知道现在引用的变量是成员变量或者成员方法，而不是局部变量。这无形中就提高了代码的阅读性。不过话说回来，这是this关键字在Java语言中的最简单的应用。从这个应用中，我们可以看出this关键字其代表的就是对象的名字。掌握这个基本的原理之后，再了解后续的一些高级应用，也就是水到渠成的事情了。
在这里只是以一个形式参数为例。其实如果是局部变量的话，也是相同的道理。如在上面的代码中，name不是形式参数，而是一个局部变量。此时Java也会遇到相同的疑惑，即变量名name代表的到底是局部变量还是形式参数?name=name到底代表的是什么含义?根据局部变量的作用域，在方法内部，如果局部变量与成员变量同名的话，那么是以局部变量为准。可是在name=name这个赋值语句中，将局部变量的值赋值给自己，显然并不是很合适。根据代码的含义，本来的意思应该是将局部变量赋值给成员变量。为了更清晰的表达这个含义，为此最好采用如下的书写格式：this.name=name。这里的this关键字含义就是对象名student。为此this.name就表示student.name。这就转换为正规的成员变量应用了。

• 应用二：调用类的构造方法。
  在一个Java类中，其方法可以分为成员方法和构造方法两种。构造方法是一个与类同名的方法，在Java类中必须存在一个构造方法。如果在代码中没有显示的体现构造方法的话，那么编译器在编译的时候会自动添加一个没有形式参数的构造方法。这个构造方法跟普通的成员方法还是有很多不同的地方。如构造方法的话一律是没有返回值的。而且也不用void关键字来说明这个构造方法没有返回值。而普通的方法可以有返回值、也可以没有返回值，程序员可以根据自己的需要来定义。不过如果普通的方法没有返回值的话，那么一定要在方法定义的时候采用void关键字来进行说明。其次构造方法的名字有严格的要求，即必须与类的名字相同。也就是说，Java编译器发现有个方法与类的名字相同才把其当作构造方法来对待。而对于普通方法的话，则要求不能够与类的名字相同，而且多个成员方法不能够采用相同的名字。在一个类中可以存在多个构造方法，这些构造方法都采用相同的名字。只是形式参数不同。Java语言就凭用户参数的参数来判断调用那个构造方法。
  this 关键字除了可以调用成员变量之外，还可以调用构造函数方法。如下面的代码：

public class  Student{ //定义一个类，类的名字为student。
public Student(){ //定义一个方法，名字与类相同故为构造方法
this(“luobo”)
}

public Student(String  name){ //定义一个带形式参数的构造方法
}
}

在上面这个代码中，定义了两个构造方法，一个带参数，另一个没有带参数。构造方法都不会有返回值，不过由于构造方法的特殊性，为此不必要在构造方法定义时带上void关键字来说明这个问题。在第一个没有带参数的构造方法中，笔者使用了this(“luobo”)这个代码。这个代码表示什么含义呢?在构造方法中使this关键字表示调用类中的构造方法。如果一个类中有多个构造方法，因为其名字都相同，跟类名一致，那么这个this到底是调用哪个构造方法呢?其实，这跟采用其他方法引用构造方法一样，都是通过形式参数来嗲用构造方法的。如上例中，this关键字后面加上了一个参数，那么就表示其引用的是带参数的构造方法。如果现在有三个构造方法，分别为不带参数、带一个参数、带两个参数。那么Java编译器会根据所传递的参数数量的不同，来判断该调用哪个构造方法。从上面这个示例中可以看出，this关键字不仅可以用来引用成员变量，而且还可以用来引用构造方法。
不过如果要使用这种方式来调用构造方法的话，有一个语法上的限制。一般来说，利用this关键字来调用构造方法，只有在无参数构造方法中第一句使用this调用有参数的构造方法。否则的话，翻译的时候，就会有错误信息。这跟引用成员变量不同。如果引用成员变量的话，this关键字是没有位置上的限制的。如果不熟悉这个限制的话，那么还是老老实实的采用传统的构造方法调用方式为好。虽然比较麻烦，但是至少不会出错。

• 应用三：返回对象的值。
  this关键字除了可以引用变量或者成员方法之外，还有一个重大的作用就是返回类的饮用。如在代码中，可以使用return this，来返回某个类的引用。此时这个this关键字就代表类的名称。如这个代码在上面这个student类中，那么这个代码其代表的含义就是return student。可见，这个this关键字除了可以引用变量或者成员方法之外，还可以做为类的返回值。这才是this关键字最引人注意的地方。
  在使用this关键字的时候，需要注意一个细节问题。在笔者谈到的第一个案例中，利用this关键字来引用成员变量。即this.name=name。这个语句是将局部变量或则形式参数赋值给成员变量。其实，此时这个this关键字不加也可以起到类似的效果。即上面这个语句中，与name=name这个语句时相同的。即Java编译器会自动将第一个name当作成员变量来对待。而将等号右边的name变量当作形式参数。虽然这么书写代码，可以节省this这几个字符的输入。但是对于代码的阅读是不利的。为此，从代码的阅读性考虑，如果成员变量与形式参数或者局部变量相同的话，那么最好是使用this.成员变量(成员方法)的方式来引用成员变量。虽然语法上没有错误，但是作为一个高级的JAVA程序员，在代码书写的规范上，也不能够忽视。

• super关键字有什么含义?在哪些情况下应用?

super有两种用法：

• 其一：在构造方法内使用
  如下：

public class a extends b{
       public a (int t){
           super(t);
        }
}

• 其二：在其它非构造方法中使用
  如下：

public class a extends b{
        public a(){}
        public print(String a){
            super.print(a);
        }
}

1.表示父类
2.调取父类成员
3.作为方法名表示父类构造方法
4.子类对象的创建：沿继承链调用父类的构造方法
例如：

public class Employee{
   private String name;
   privarte int age;
   public String getDetails(){
       return “name:”+name+”\nAge:”+age;
   }
}

public class Manager extends Employee{
      private String getDetails(){
      //call parent method
       return super.getDetails()+”\nDeparment:”+department;
       }
}

public class Manage extends Employee{
         private String department;
         public Manage(String name,int age;String dept){
               super(name,age);
               department=dept;
        }
          public Manage(String n,String dept){
                super(name);
                department=dept;
         }

          public Manage(String dept){       //This code fails:no super()
                    department=dept;    
          }
}

super.xxx用于在子类中调用与父类重名的属性。或者是被子类重写的方法。
super()是在子类中调用父类的构造方法。每个子类构造方法第一行，必须是这样调用。因为若想实例化子类对象，则必须先实例化其父类对象。
super是调用父类的构造函数
使用super调用有一些限制条件，不能在super调用中使用实例变量作为参数，而且在构造函数中，调用必须写在继承类的构造函数定义的第一行，不能在构造函数的后面使用。
this是调用的同类的构造函数。
super的限制条件同样适用于this函数。
一个构造函数定义中不能同时包含this调用和super调用，如果想同时包括的话，可以在this中首先进行super调用。

---

成员函数中定义了和成员变量中相同的变量时，引用成员变量要用this。
构造函数中调用同一个类的其他构造函数时用this。
子类中覆盖了与父类成员变量或成员函数时，在子类中调用父类的变量或函数时要用super
子类的构造函数里调用父类的构造函数用super
包（package）是类的容器，用来保存划分的类名空间。
创建一个包是很简单的：只要包含一个package命令作为一个人Java源文件的第一句就可以了。该文件中定义的任何类将属于指定的包。
下面是package声名的一般形式：
package pkg;
接口是用来实现类间多重继承功能的，他将完成特定功能的若干属性组织成相对独立的属性集合，该属性集合就是接口。接口的定义仅仅是实现某一特定功能的对外接口和规范，而并没有真正实现这个功能。真正实现在继承这个接口的各个类中完成，因此通常把接口功能的继承成为”实现“。
异常是指程序在运行过程中的不正常情况。Java的异常处理机制则避免了这些问题，而且在处理过程中，把对运行时对错误的处理以面向对象的方式解决。在标准包java.lang中，Java定义了若干个异常类。前面的例子曾用到其中一些，这些异常一般是标准类RuntimeException的子类。因为java.lang实际上被所有的java程序引用。而且，他们不需要被包含在任何方法的throws列表中。Java语言中，这被叫做未经检查的异常（unchecked exception）。因为编译器不检查它是否处理或引发了这些异常。

• static关键字有什么含义？具体如何应用？能修饰构造方法吗？

• static关键字可以用来修饰类的变量，方法和内部类。
  static是静态的意思，也是全局的意思它定义的东西，属于全局与类相关，不与具体实例相关。就是说它调用的时候吗，只是ClassName.method()，而不是new ClassName().method()。new ClassName()不就是一个对象了吗？static的变量和方法不可以这样调用。它不与具体的实例有关。

class Count{
       private int serialNumber;
       public static int counter=0;  //一个静态变量counter
       public Count(){
       counter++;        //创建counter的时候递增
       serialNumber=counter；
      }

       public int getSetialNumber(){
       return serialNumber;
       }
}

class OtherClass{
         public int increment(){
         return Count.counter++;   //静态的变量不属于任何实例只能直接用类调用
        }
}

public class TestStaticVar{
        public static void main(String[] args){
        Count[] cc = new Count[10];
        OtherClass   o  = new OtherClass();
        for (int i=0;i<cc.length;i++){
        cc[i] = new Count();
        System.out.println(“cc[“+i+”].serialNumber=”+cc[i].getSerialNumber());
        System.out.println(o.increment);
        }
     }
}

• 类的方法中带有static关键字，这个方法就是静态方法。静态方法也是要通过类名，而不是实例访问。

class GenerealFunction {
public static int add(int x,int y){
return x+y;
}
}

public class UseGeneral {
public static void main(String[] args){
//调用时还是用类直接调用
int c = GenerealFunction.add(19,18);
System.out.println("结果是"+c);
}
}

注意：子类不能重写父类的静态方法哦，也不能把父类不是静态的重写成静态的方法。想隐藏父类的静态方法的话，在子类中声明和父类相同的方法就行了。

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。
声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制：
· 它们仅能调用其他的static 方法。
· 它们只能访问static数据。
· 它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。
如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：
// Demonstrate static variables，methods，and blocks.

class UseStatic { 
static int a = 3; 
static int b;

static void meth(int x) { 
System.out.println("x = " + x); 
System.out.println("a = " + a); 
System.out.println("b = " + b);
}

static { 
System.out.println("Static block initialized."); 
b = a * 4;
}

public static void main(String args[]) { 
meth(42); 
} 
}

一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。
注意：在一个static 方法中引用任何实例变量都是非法的。
下面是该程序的输出：
Static block initialized.
x = 42
a = 3
b = 12
在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：
classname.method( )
这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。
下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。

class StaticDemo { 
static int a = 42; 
static int b = 99; 
static void callme() {

System.out.println("a = " + a); 
} 
}

class StaticByName {
public static void main(String args[]) { 
StaticDemo.callme(); 
System.out.println("b = " + StaticDemo.b);
} 
}

下面是该程序的输出：
a = 42
b = 99
static成员是不能被其所在class创建的实例访问的。
如果不加static修饰的成员是对象成员，也就是归每个对象所有的。
加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的