Java关键字final、static使用(珠海20090326)

一.
final 最终. 可以用来对以下进行修饰.
1.属性 
只能赋值一次,值不能改变.
可以在定义时赋值,或在构造函数中赋值(只能这两个地方).
2.方法
不能被覆盖,但可以被继承(继承指的是子类可用父类的方法).
3.类
要是非抽象类,修饰的类不能被继承.
4.函数的参数
可以读取该参数,但无法改变参数的值.
对于引用类型的参数来说,不可改变其引用,更可以修改其引用的对象.

package com.method.test;

class LoginInfo {
	String userName;
	String password;

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

}

public class TestFinal {

	public static void checkInt(final int i) {
		//i = 200;  //不能通过编译,因为fianl不容许修改
		System.out.println(i);
	}

	public static void checkLoginInfo(final LoginInfo login) {
		//login = new LoginInfo(); 
		//不能通过编译 new会新建实例，然后传引用给login;
		login.setUserName("yun");
		//final不可更改，不能改的是引用地址，不是不能改引用的对象。
	}

	public static void main(String[] args) {
		int i = 1;
		System.out.println(i);
		checkInt(i);
		System.out.println(i);

		LoginInfo login = new LoginInfo();
		login.setPassword("1235");
		login.setUserName("mygod");
		System.out.println("username:" + login.getUserName() + ",password:"
				+ login.getPassword());
		checkLoginInfo(login);
		System.out.println("username:" + login.getUserName() + ",password:"
				+ login.getPassword());
	}
}

1
1
1
username:mygod,password:1235
username:yun,password:1235

二.
static 静态.
可以用来对以下进行修饰.
1.属性
2.方法
3.static代码块

声明为静态的话,就是属于类的,而非对象的,实例的.所以类属性,类方法是可以在任何实例对象创建时使用.这就是类变量与实例变量的区别了.
类在第一次使用前会完成static代码块(包括父类和自己的static代码块).并且static代码块是只做一次的,不似实例的instance initialize block是每建一个实例都会运行,是属于实例的.

package com.constructor.test;

class Parent {
	int pm1;
	int pm2 = 100;
	int pm3 = pmethod();
	{
		System.out.println("Parent's instance initialize block");
	}
	public static int spm1 = 200;
	static {
		System.out.println("Parent's static initialize block");
	}

	Parent() {
		System.out.println("Parent's default constructor");
	}

	static void staticmethod() {
		System.out.println("Parent's staticmethod");
	}

	int pmethod() {
		System.out.println("Parent's method");
		return 3;
	}
}

class Child extends Parent {
	int cm1;
	int cm2 = 1000;
	int cm3 = cmethod();
	Other co;
	public static int scm1 = 2000;
	{
		System.out.println("Child's instance initialize block");
	}
	static {
		cmethod2(); // 要static的方法才行
		System.out.println("Child's static initialize block");
	}
	{
		System.out.println("Child's instance initialize block 2222");
	}

	Child() {
		co = new Other();
		System.out.println("Child's default constructor");
	}

	Child(int m) {
		this();
		cm1 = m;
		System.out.println("Child's self-define constructor");
	}

	static void staticmethod() {
		System.out.println("Child's staticmethod");
	}

	int cmethod() {
		System.out.println("Child's method");
		return 3;
	}

	static void cmethod2() {
		System.out.println("Child's method2!!!");
	}

}

class Other {
	int om1;

	Other() {
		System.out.println("Other's default constructor");
	}

}

public class TestConstructor {
	public static void main(String args[]) {
		Child c;
		System.out.println("program start");
		System.out.println("Child.scm1=" + Child.scm1);
		// System.out.println("c.cm3="+c.pm2); pm2还未被初始化!
		c = new Child(10);
		System.out.println("program end");
		Child d = new Child(20);
	}
}

program start

Parent's static initialize block

Child's method2!!!
Child's static initialize block
Child.scm1=2000

Parent's method
Parent's instance initialize block

Parent's default constructor

Child's method
Child's instance initialize block
Child's instance initialize block 2222

Other's default constructor
Child's default constructor
Child's self-define constructor

program end

Parent's method
Parent's instance initialize block
Parent's default constructor

Child's method
Child's instance initialize block
Child's instance initialize block 2222
Other's default constructor
Child's default constructor
Child's self-define constructor