java_notes_static、final、内部类、代码块

static：静态的，可以用来修饰类的属性、方法、初始化块、内部类

一、static修饰属性(类变量)

1) 由类创建的所有对象都共用这一属性。

2) 当其中一个对象对此属性进行操作时，会导致其它对象的此属性的一个调用。

3) 类变量随着类的加载而加载并且独一份。

4) 静态的变量可以通过'类.类变量'的形式进行调用。

5) 类变量的加载是要早于对象的。实例变量(非static属性)是随着对象的创建而被加载的。

6) 类变量存在于静态域中。

举例：

<span style="font-family:KaiTi_GB2312;font-size:14px;">public class Test {
	
	public static void main(String[] args) {
		Test1 t1 = new Test1("AAA","China");
		Test1 t2 = new Test1("BBB"); 
		System.out.println(t1);
		System.out.println(t2);
	}
	
}

class Test1 {
	
	String name;
	static String nation;
	
	public Test1(String name) {
		super();
		this.name = name;
	}
	
	public Test1(String name, String nation) {
		super();
		this.name = name;
		Test1.nation = nation;
	}
	
	public String toString() {
		return "Test1 [name=" + name + " nation=" + nation + "]";
	}
}</span>

打印结果:

Test1 [name=AAA nation=China]
Test1 [name=BBB nation=China]

二、static修饰方法(类方法)

1) 随着类的加载而加载，在内存中独一份。

2) 可以直接通过'类.类方法'的方式调用。

3) 静态方法内部可以调用静态的属性和方法，因为它们都是随着类的加载而创建的。但是不能调用非静态属性或方法，因为在没有实例化对象时，非静态属性和方法是不存在的。

4) 非静态的方法中可以调用静态属性和方法，道理和3)中一样。static类型的生命周期早于非static类型的。

5) static结构出生早于非static，回收晚于非static。

三、static修饰内部类

内部类：在类内部定义的类。

分为：成员内部类(类内部方法外)、局部内部类(类方法中)

A是成员内部类、B是局部内部类

<span style="font-family:KaiTi_GB2312;font-size:14px;">public class Test{
	
	String name;
	
	class A{
		//...
	}
	
	public void method1(){
		class B{
			//...
		}
	}
	
}</span>

成员内部类：

  1）是外部类的一个成员

  2）具有成员的特性：可以有修饰符(4个)、可以用static、final、abstract修饰

  3）具有类的特性：用abstract修饰、有属性、方法、构造器。

局部内部类：

1.如何创建成员内部类：

<span style="font-family:KaiTi_GB2312;font-size:14px;">public class MyTest{
	
	public static void main(String[] args) {
		//非static成员类
		Person p = new Person();
		Person.Eat e = p.new Eat();
		//static成员类
		Person.Sleep s = new Person.Sleep();
	}
	
}

class Person{
	
	public class Eat{
		
	}
	
	static public class Sleep{
		
	}
	
}</span>

2.如何区分外部类、内部类中的变量(当有重名变量时)

<span style="font-family:KaiTi_GB2312;font-size:14px;">public class MyTest{
	
	public static void main(String[] args) {
		Person p = new Person();
		Person.Name n = p.new Name("王五");
	}
	
}

class Person{
	
	String name = "张三";
	
	class Name{
		
		String name = "李四";
		
		public Name(String name){
			System.out.println(name);
			System.out.println(this.name);
			System.out.println(Person.this.name);
		}
	}
}</span>

类Name构造器打印结果依次为：王五、李四、张三

3.局部内部类的使用

<span style="font-family:KaiTi_GB2312;font-size:14px;">class Person{
	
	public Comparable getComparable(){
		class MyComparable implements Comparable{
			public int compareTo(Object arg0) {
				return 0;
			}
		}
		return new MyComparable();
		
	}
	
	public Comparable getComparable1(){
		return new Comparable(){
			public int compareTo(Object arg0) {
				return 0;
			}
		};
	}
	
}</span>

四、初始化代码块

非静态代码块:

<span style="font-family:KaiTi_GB2312;font-size:14px;">class Person{
    String name;
    static int age;
    {
        age = 10;
    }
}</span>

1.可以对类的属性进行初始化操作;

2.里面可以有输出语句;

3.一个类可以定义多个代码块,代码块之间按照顺序呢结构执行;

4.没创建一个类对象非静态代码块就执行一次;

5.非静态代码块的执行要早于构造器。

静态代码块:

<span style="font-family:KaiTi_GB2312;font-size:14px;">class Person{
    String name;
    static int age;
    static{
        age = 10;
        //name = "aa"; //error
    }
}</span>

1.里面可以有输出语句；

2.随着类的加载而加载,且只能被加载一次,是随着类的加载而加载不是随着对象而加载的;

3.多个静态代码块之间按照顺序呢结构执行;

4.静态代码块要早于非静态代码块执行;

5.只能对静态属性进行操作,不可对非静态属性进行操作。

final:可以理解为最终的,它可以用来修饰类、属性、方法。

final修饰类: 此类不能被其它类继承。即此类不能作为任何类的父类。

<span style="font-family:KaiTi_GB2312;font-size:14px;">final class A{}
class B extends A{}//error</span>

final修饰方法:此方法不能被重写。

<span style="font-family:KaiTi_GB2312;font-size:14px;">class A{
    final void Func(){}
}

class B extends{
    void Func(){}//error
}</span>

final修饰属性:此属性的值不能被改变,即此属性为一常量。此常量不能使用默认初始化,可以显式赋值、在代码块和构造器也可。

<span style="font-family:KaiTi_GB2312;font-size:14px;">final boolean FLAG = true;
FLAG = false; //error</span>

注意：如果一个属性同时被static final修饰,那么此属性为全局常量。