static、final修饰符、内部类及Java的内存分配

static修饰符

static修饰符能够与属性、方法和内部类一起使用，表示静态的。类中的静态变量和静态方法能够与类名一起使用，不需要创建一个类的对象来访问该类的静态成员，所以，static修饰的变量又称作“类变量”。

例：

public class T{

public static String s = "This is static test.";

public static void main(String [] args){

System.out.println("s= " + T.s);

a();

}

public static void a(){

System.out.println("This is static method.");

}

}









static属性的内存分配

一个类中，一个static变量只会有一个内存空间，虽然有多个类实例，但这些类实例中的这个static变量会共享同一个内存空间。

例：

public class T{

public static String s = "This is a String.";

public static void main(String [] args){

T t1 = new T();

T t2 = new T();

t2.s = "This is a new String.";

System.out.println("t1.s= " + t1.s + "t2.s= " + t2.s + "T.s= " + T.s);

}

}









static的变量是在类装载的时候就会被初始化，即，只要类被装载，不管是否使用了static变量，都会被初始化。

static的基本规则

·一个类的静态方法只能访问静态属性

·一个类的静态方法不能直接调用非静态方法

·如访问控制权限允许，static属性和方法可以使用对象名加“.”的方式调用，也可以使用实例加“.”的方式调用

·静态方法中不存在当前对象，因而不能使用this，也不能使用super

·静态方法不能被非静态方法覆盖

·构造方法不允许声明为static的

注，非静态变量只限于实例，并只能通过实例引用被访问。

静态初始器——静态块

静态初始器是一个存在与类中方法外面的静态块，仅仅在类装载的时候执行一次，通常用来初始化静态的类属性。

例：

public class T{

static{

System.out.println("This is a static block.");

}

{

System.out.println("This is a block.");

}

public static void main(String [] args){

T t1 = new T();

T t2 = new T();

T t3 = new T();

}

}









final修饰符

在Java声明类、属性和方法时，可以使用关键字final来修饰，final所标记的成分具有终态的特征，表示最终的意思。

final的具体规则

·final标记的类不能被继承

·final标记的方法不能被子类重写

·final标记的变量（成员变量或局部变量）即成为常量，只能赋值一次

·final标记的成员变量必须在声明的同时赋值，如果在声明的时候没有赋值，那么只有一次赋值的机会，而且只能在构造方法中显式赋值，然后才能使用

·final标记的局部变量可以只声明不赋值，然后再进行一次性的赋值

·final一般用于标记那些通用性的功能、实现方式或取值不能随意被改变的成分，以避免被误用

如果将引用类型（即，任何类的类型）的变量标记为final，那么，该变量不能指向任何其它对象，但可以改变对象的内容，因为只有引用本身是final的。

内部类

在一个类（或方法、语句块）的内部定义另一个类，后者称为内部类，有时也称为嵌套类。

内部类的特点

·内部类可以体现逻辑上的从属关系，同时对于其它类可以控制内部类对外不可见等

·外部类的成员变量作用域是整个外部类，包括内部类，但外部类不能访问内部类的private成员

·逻辑上相关的类可以在一起，可以有效地实现信息隐藏

·内部类可以直接访问外部类的成员，可以用此实现多继承

·编译后，内部类也被编译为单独的类，名称为outclass$inclass的形式

例：

public class Outer{

private int size;

public class Inner{

private int counter = 10;

public void doStuff(){

size++;

}

}

public static void main(String [] args){

Outer outer = new Outer();

Inner inner = outer.new Inner();

inner.doStuff();

System.out.println(outer.size);

System.out.println(inner.counter);

}

}









内部类可以分为四种

·类级：成员式，有static修饰

·对象级：成员式，普通，无static修饰

·本地内部类：局部式

·匿名级：局部式

成员式内部类的基本规则

·可以有各种修饰符，可以用4种权限、static、final、abstract定义

·若有static限定，就为类级，否则为对象级。类级可以通过外部类直接访问，对象级需要先生成外部的对象后才能访问

·内外部类不能同名

·非静态内部类中不能声明任何static成员

·内部类可以互相调用

成员式内部类的访问

内部类访问外层类对象的成员时，语法为：

外层类名.this.属性

使用内部类时，由外部类对象加“.new”操作符调用内部类的构造方法，创建内部类的对象。

在另一个外部类中使用非静态内部类中定义的方法时，要先创建外部类的对象，再创建与外部类相关的内部类的对象，再调用内部类的方法。

static内部类相当于其外部类的static成分，它的对象与外部类对象间不存在依赖关系，因此可以直接创建。

由于内部类可以直接访问其外部类的成分，因此，当内部类与其外部类中存在同名属性或方法时，也将导致命名冲突。所以，在多层调用时要指明。

本地类是定义在代码块中的类，只在定义它们的代码块中可见。

本地类有以下几个重要特性：

·仅在定义了它们的代码块中可见

·可以使用定义它们的代码块中的任何本地final变量

·本地类不可以是static的，里边也不能定义static成员

·本地类不可以用public、private、protected修饰，只能使用缺省的

·本地类可以是abstract的

例：

public final class Outer{

public static final int TOTAL_NUMBER = 5;

public int id = 123;

public void t(){

final int a = 15;

String s = "t";

class Inner{

public void innerTest(){

System.out.println(TOTAL_NUMBER);

System.out.println(id);

System.out.println(a);

}

}

new Inner().innerTest();

}

}

匿名内部类是本地内部类的一种特殊形式，即，没有类名的内部类，而且具体的类实现会写在这个内部类里。

匿名类的规则

·匿名类没有构造方法

·匿名类不能定义静态的成员

·匿名类不能用4种权限、static、final、abstract修饰

·只可以创建一个匿名类实例

Java的内存分配

Java程序运行时的内存结构分成：方法区、栈内存、堆内存、本地方法栈几种。

方法区存放装载的类数据信息，包括：

·基本信息：每个类的全限定名、每个类的直接超类的全限定名、该类是类还是接口、该类型的访问修饰符、直接超接口的全限定名的有序列表。

·每个已装载类的详细信息：运行时常量池、字段信息、方法信息、静态变量、到类classloader的引用、到类class的引用。

栈内存

Java栈内存由局部变量区、操作数栈、帧数据区组成，以帧的形式存放本地方法的调用状态（包括方法调用的参数、局部变量、中间结果……）。

堆内存

堆内存用来存放由new创建的对象和数组。在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。

本地方法栈内存

Java通过Java本地接口JNI（Java Native Interface）来调用其它语言编写的程序，在Java里面用native修饰符来描述一个方法是本地方法。

String的内存分配

String是一个特殊的包装类数据，由于String类的值不可变性，当String变量需要经常变换其值时，应该考虑使用StringBuffer或StringBuilder类，以提高程序效率。

例：

public class T{

public void t(String s){

s = "123";

}

public static void main(String [] args){

T t = new T();

String s1 = new String("abc");

t.t(s1);

System.out.println("s1= " + s1);

}

}