java关键字static和final的理解
2018-11-30 本文已影响37人
移动端_小刚哥
一、static
“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”
方便在没有创建对象的情况下来进行调用（方法/变量）。
很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。
static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。
1.1 static修饰成员方法
static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用
如下代码
public class Test {
private static String str1 = "staticProperty";
private String str2 = "property";
public Test(){}
public void print1(){
Log.d(str1,"");
Log.d(str2,"");
print2();
}
public static void print2(){
Log.d(str1,"");
Log.d(str2,""); //报错
print1(); //报错
}
}
1.2 static修饰成员变量
static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
static成员变量的初始化顺序按照定义的顺序进行初始化
1.3 static修饰静态代码块
如下代码
public class Test {
/**
* static代码块
*/
static {
Log.d("","static代码块");
}
/**
* 构造代码块
*/
{
Log.d("","构造代码块");
}
public Test(){
Log.d("","构造方法1");
}
public Test(String name){
Log.d("","构造方法2");
}
}
代码块分为static代码块和构造代码块，static代码块在该类被装载时仅执行一次，而构造代码块在调用构造方法时都会被调用，而且执行顺序早于构造方法。上述代码可写为：
public class Test {
/**
* static代码块
*/
static {
Log.d("","static代码块");
}
public Test(){
Log.d("","构造代码块");
Log.d("","构造方法1");
}
public Test(String name){
Log.d("","构造代码块");
Log.d("","构造方法2");
}
}
1.4 注意⚠️
- static关键字并不会影响访问权限，使用static修饰的变量也不会自动变成public，访问权限还是要以权限修饰关键字为准（public、private、protected等）
- static是不允许用来修饰局部变量。不要问为什么，这是Java语法的规定
- 如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为static。我们最常见的static方法就是main方法，至于为什么main方法必须是static的，现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问
1.5 能通过this访问静态成员变量吗？
是可以的
1.6 常见的笔试面试题
1.6.1 面试题一
public class Test extends Base{
static{
System.out.println("test static");
}
public Test(){
System.out.println("test constructor");
}
public static void main(String[] args) {
new Test();
}
}
class Base{
static{
System.out.println("base static");
}
public Base(){
System.out.println("base constructor");
}
}
结果为
base static
test static
base constructor
test constructor
执行顺序：
- 先加载Test类，而在加载Test类的时候发现Test类继承自Base类，因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块
- 在Base类加载完成之后，便继续加载Test类，然后发现Test类中也有static块，便执行static块
- 在加载完所需的类之后，便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器
- 然后再调用自身的构造器
1.6.2 面试题二这段代码输出什么
public class Test {
Person person = new Person("Test");
static{
System.out.println("test static");
}
public Test() {
System.out.println("test constructor");
}
public static void main(String[] args) {
new MyClass();
}
}
class Person{
static{
System.out.println("person static");
}
public Person(String str) {
System.out.println("person "+str);
}
}
class MyClass extends Test {
Person person = new Person("MyClass");
static{
System.out.println("myclass static");
}
public MyClass() {
System.out.println("myclass constructor");
}
}
执行结果为
test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor
执行顺序
- 首先加载Test类，因此会执行Test类中的static块
- 接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块
- 在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块
- 接着执行父类的构造器，完成了父类的初始化
- 然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器
1.6.3 面试题三这段代码输出什么
public class Test {
static{
System.out.println("test static 1");
}
public static void main(String[] args) {
}
static{
System.out.println("test static 2");
}
}
执行结果
test static 1
test static 2
因为static修饰的代码块是在加载类时被调用一次，和类有关而不依赖于类的实例对象
