java变量与常量

常量与变量：
1. 在为相同类型的变量进行初始化时，可以使用逗号分隔，例如：
int a1=100,a2=200,a3=300;
但如下的写法是非法的：
int b1,b2,b3;
b1=100,b2=200,b3=300;

2. 对于类的成员变量，允许只进行声明。若变量为基本类型，Java虚拟机会自动将它们初始化为默认值，各基本类型的默认值请参看2.3.1节中的表2.2；若为引用类型变量，则被初始化为null。例如：
public class VariableInit {
    private static int store;                             //int型成员变量被自动初始化为默认值0
    private static String bookName;                        //String型成员变量被自动初始化为null
    public static void main(String[] args) {
        int buy;                                             //局部变量buy未进行初始化
        String author;                                     //局部变量author未进行初始化
        store+=100;                                              //store值为100
        buy++;                                              //编译出错
        System.out.println(bookName);                          //输出null
        System.out.println(author);                         //编译出错
    }
}
3. 成员变量：在类中声明，在整个类中有效。
   局部变量：在方法内或方法内的某代码块（方法内部，“{”与“}”之间的代码）中声明的变量。在代码块声明的变量，   只在当前代码块中有效；在代码块外、方法内声明的变量在整个方法内都有效。
public class Olympics {
    private int medal_All=800;                                   //成员变量
    public void China(){
        int medal_CN=100;                             //方法的局部变量
        if(true){                                             //代码块
            int gold=50;                               //代码块的局部变量
            medal_CN+=50;                             //允许访问
            medal_All-=150;                             //允许访问
               }
        gold=100;                                       //编译出错
        medal_CN+=100;                                //允许访问
        medal_All-=200;                                  //允许访问
    }
public void Other(){
        medal_All=800;                                   //允许访问
        medal_CN=100;                                  //编译出错, 不能访问其他方法中的局部变量
        gold=10;                                        //编译出错
    }
}
   类的成员变量又可分为两种：静态变量和实例变量。静态变量是指通过static关键字进行修饰的成员变量，没有被static    关键字修饰的变量为实例变量。它们的区别如下。
   静态变量的有效范围是整个类，并且可以被类的所有实例共享。可以通过“类名.变量名”的方式来访问静态变量。静态变量的生命周期取决于类的生命周期，当类被加载时，为类中的静态变量分配内存空间，当卸载类时，释放静态变量占用的空间，静态变量被销毁。类加载时，就为静态变量分配内了存空间，之后无论创建了多少类的实例，都不会再为静态变量分配内存空间，这些实例会使用同一个静态变量。
   实例变量与类的实例对应，它的有效范围是整个实例。每创建一个类的实例，都会为当前实例分配实例变量的内存空间。 所以实例变量的生命周期取决于实例的生命周期，实例被创建时，为实例变量分配内存空间，当销毁实例时，释放实例变    量占用的内存空间。
public class Student{
    public static int amount=100;                    //声明一个静态变量amount
    public int age=24;                              //声明一个实例变量age
}
然后创建Student类的两个实例，代码如下：
Student st1=new Student();
Student st2=new Student();
下面分别通过引用变量st1和st2，来修改各自所引用实例中的实例变量age，并通过st2引用变量来修改静态变量amount，代码如下：
st1.age+=2;
st2.age+=3;
st2.amount+=100;            //或通过类名进行访问: Student.amount+=100
此时的Java虚拟机的运行时数据区中存储的两个实例的实例变量及类的静态变量的值发生了改变

局部变量
在类的方法中声明的变量，包括方法的参数，都属于局部变量，它们只在当前的方法内有效，不能用于类的其他方法中。在方法的代码块中声明的变量也是局部变量，但它只在该代码块内有效。
局部变量的生命周期取决于方法，当方法被调用时，Java虚拟机为方法中的局部变量分配内存空间，当方法的调用结束后，则释放该方法中局部变量占用的内存空间，局部变量被销毁。
可以声明一个与成员变量同名称的局部变量，此时在方法中访问该变量，针对的是方法中的局部变量；否则若没有在方法中声明与成员变量同名称的局部变量，在方法中访问该变量时针对的是成员变量。例如：
public class Access{
    private int times=3;
    private static int order=2;
    public static void main(String[] args) {
        int times=5;
        System.out.println(times);           //输出结果为: 5
        System.out.println(order);           //输出结果为: 2
    }
}
 在声明时，不能使用public、protected、private和static关键字对局部变量进行修饰。
 不能通过类名或引用变量来访问局部变量。
数据类型：
4. 对变量赋值后，通过输出语句会自动地将变量值转换为十进制整数输出。
byte a=123;                    //定义byte型变量a, 并赋给十进制数值123
short b=045;                   //定义short型变量b, 并赋给八进制数值045
int c=0xb12f;                        //定义int型变量c, 并赋给十六进制数值0xb12f
long d=0x160000000L;                //定义long型变量d, 并赋给十六进制数值0x160000000L
System.out.println(a);                       //输出结果为: 123
System.out.println(b);                       //输出结果为: 37
System.out.println(c);                       //输出结果为: 45359
System.out.println(d);                       //输出结果为: 5905580032
float a1=12.34F;                  //为float型变量a1赋值为十进制表示的单精度小数(在数字后加F)
float a2=1.234E1F;              //为float型变量a2赋值为科学记数法表示的单精度小数(在数字后加F)
double b1=56.78;                 //为double型变量b1赋值为十进制表示的双精度小数
double b2=567.8E-1;                  //为double型变量b2赋值为科学记数法表示的双精度小数
System.out.println(a1);                     //输出结果为: 12.34
System.out.println(a2);                     //输出结果为: 12.34
System.out.println(b1);                     //输出结果为: 56.78
System.out.println(b2);                     //输出结果为: 56.78
char a='m';                          //为字符型变量ch1赋值字符常量'm'
char b='明';                         //为字符型变量ch1赋值字符常量'明'
char c='9';                                //为字符型变量ch1赋值字符常量'9'
char d='@';                         //为字符型变量ch1赋值字符常量'@'
System.out.println(a);                       //输出结果为: m
System.out.println(b);                       //输出结果为: 明
System.out.println(c);                       //输出结果为: 9
System.out.println(d);                       //输出结果为: @
char ch1=97;                             //为字符型变量ch1赋值十进制数97
char ch2=0142;                         //为字符型变量ch2赋值八进制数0142
char ch3=0x63;                         //为字符型变量ch2赋值十六进制数0x63
System.out.println(ch1);                   //输出结果为: a
System.out.println(ch2);                   //输出结果为: b
System.out.println(ch3);                   //输出结果为: c
//
 代表反斜杠字符
/r
 回车，将光标定位在当前行的开头，不会跳到下一行
/n
 换行符，将光标定位在下一行的开头
/'
 表示单引号
/"
 表示双引号
/t
 垂直制表符，将光标移到下一个制表符的位置
/b
 退格
/f
 换页
 /ddd
 1～3位八进制数据所表示的字符，如/123
 /uxxxx
 4位十六进制数所表示的字符，如/u005f
 boolean married=false;
boolean alive=true;
System.out.println("已婚："+married);                      //输出结果为: false
System.out.println("生命："+alive);                          //输出结果为: true
Java语言中的引用类型包括类引用类型、接口引用类型以及数组引用类型。定义引用类型变量与定义基本数据类型变量语法相同。
数据类型 变量名称
以下代码分别定义了类引用类型变量someBody、接口引用类型变量fileFilter和数组引用类型变量myLikes。
People someBody;
FileFilter fileFilter;
int[] myLikes;
其中People为自定义类，所以变量someBody被指定为类引用类型。通过类引用类型变量可以引用类的实例，关于类的讲解请参见第5章。FileFilter是Java类库中java.io包下的一个接口，所以变量fileFilter被指定为接口引用类型，它将引用实现了FileFilter这个接口的类的对象。数组引用类型的变量myLikes将引用int数组，在Java语言中，数组也被看作对象。由此可见，不管何种引用类型的变量，它们引用的都是对象。
如果使一个引用类型变量不引用任何对象，可赋给它null值。这通常在初始化一个引用类型变量时赋初值为null。
Person someBody=null;
FileFilter fileFilter=null;
int[] myLikes=null;
引用变量存储的不是具体的某个对象，而是存储了被引用对象存储在内存中某个位置的地址，所以说该变量引用了某个对象。Java语言没有提供像int型、float型或char型一样的内建字串类型，但标准Java库中包含了一个预定义类String，每个用一对双引号封闭的字符串都是String类的一个实例，例如：“明日科技”。也就是说，在Java语言中，字符串是作为对象来处理的。