一、static：
1、static是一个标识符：
- 有static修饰的成员表明该成员是属于类的;
- 没有static修饰的成员表明该成员是属于实例/对象的。
2、static修饰的成员(Field、方法、初始化块),与类共存亡；static修饰的成员建议总是通过类名来访问,虽然它也可以通过实例来访问(实质也是通过类来访问的),所以平时若在其他程序中见到通过实例/对象来访问static成员时,可以直接将实例/对象 替换成类名；
3、程序都是先有类再有对象的,有可能出现有类但没有实例/对象的情况,反过来绝对不可能出现有实例/对象却没有类的现象。
4、类加载时会把属于类的Field存放到永生代堆内存中。
规则：
A、static修饰的成员不允许访问非static成员,非static成员可以访问static成员;
B、this引用、super都丕允许出现在static成员中;
C、若Field是实例/对象的,相当于前面省略了this. , 若Field是类的则相当于前面省略了类名.
注意点:若自己写程序永远都不要使用对象/实例去调用static修饰的方法、Field，若看到其他程序出现实例/对象去调用static修饰的方法、Field，我们阅读时则先把对象换成类名.
public class TestStatic{
private int age;
private String name;
private static String gender;
private double weight;
public void test(String name){
System.out.println("他/她叫: " + name);
}
public static void main(String[] args){
TestStatic ts = new TestStatic();
ts.test("小猴子");
//通过对象ts来访问static成员,可以替换成类名.gender
//因为gender是string引用变量且属于成员变量,若程序员没给它赋初始值,系统会默认给个null值它
System.out.println(ts.gender);
System.out.println(TestStatic.gender);
}
}
public class TestStatic2{
static int count = 99;
int age;
{
age = 22;
test();
}
static{
test();
//age = 13; //static成员不能访问非static成员
}
public void way(){
System.out.println("age值为: " + age);
}
public static void test(){
//static方法引用了非static修饰的age,报错
//System.out.println("age的值为: " + age);
System.out.println("~~这是一个test方法~~");
}
public static void main(String[] args){
//定义了一个t2引用变量但t2并未指向任何对象
TestStatic2 t2 = null;
TestStatic2 t3 = new TestStatic2();
//对于static修饰的Field、方法,直接打印时相当于前面省略了类名
System.out.println(count); //t2.count
//成员变量前必须有主调对象且有static修饰的方法不能直接访问没有static修饰的变量
System.out.println(t3.age); //t3.age;
}
}
二、final：
final作为一个修饰符,只能修饰:变量、方法和类。
1、final修饰变量
--final修饰的变量只能被赋值一次且赋值后不可改变。
A、final修饰成员变量：
Java成员变量默认可以由系统执行初始化,程序员可以不指定初始化,但final修饰的成员变量必须由程序员执行初始化
[原因]:如果final修饰的成员变量由系统执行初始化,那它的值只能是0、0.0、null、false、\u0000,且还不能改变,那么该变量则会变得毫无价值
若final修饰【实例变量】,可以在以下3个地方指定初始值：
①、定义时指定初始值；
②、初始化块中指定初始值；
③、构造器中指定初始值。
注意：final修饰的变量只能指定一次初始值且普通方法是不允许为final实例变量赋值的。
public class TestFinal{
//final修饰实例变量必须指定初始值且只能在定义时、初始化块、构造器中指定。
final int age = 20;
final double weight;
/*
{final修饰的变量只能被赋值一次。
weight = 150;
}*/
{
System.out.println("~~实例初始化块~~");
}
public TestFinal(){
weight = 140;
}
/* 普通方法不能为final修饰的变量赋值
public void setWeight(){
this.weight = weight;
}*/
public static void main(String[] args){
TestFinal tf = new TestFinal();
//实例变量必须拥有主调者
System.out.println(tf.weight);
}
}
若final修饰【类变量】,只可以在以下两个地方指定初始值:
①、定义时指定初始值;
②、类初始化块中指定初始值。
B、final修饰局部变量:
Java的局部变量默认就必须由程序员来指定初始值。
final修饰局部变量后,只有【一个变化】：一旦赋值后就不能再改变了。
public class TestFinal3{
public static void main(String[] args){
final int age;
age = 12;
System.out.println(age);
//final修饰age后,age只能赋值一次,否则报错"可能已分配变量age"
//age = 22;
//System.out.println(age);
}
}
C、final修饰的变量，它会被执行“宏替换”。如果final修饰的变量，可以【在编译的时候就确定】它的值，那么这个【变量就不存在】“宏替换” -- 就是查找、替换
public class FinalConstant {
public static void main(String[] args) {
String s1 = new String("疯狂java");
String s2 = new String("疯狂java");
System.out.println(s1 == s2); //false
//JVM会把所有用过的String对象进行缓存
String s3 = "fkjava.org";
String s4 = "fkjava.org";//第二次用的是缓存中的fkjava.org对象
System.out.println(s3 == s4); //true
//由于+前后的值都是"直接量"，可以直接计算
String s5 = "疯狂" + "软件";
//在编译的时候,编译器已经把"+运算"计算出来,由于+前后的值都是"直接量",可直 //接计算
String s6 = "疯狂软件" ;//JVM在编译时就自动去掉+号
//s5、s6两个引用变量是否相等【必须指向同一个对象才相等】。
System.out.println(s6 == s5); //true
String s7 = "疯狂";
String s8 = "java";
//由于s7、s8都是变量，他们的值只有在运行时才能确定下来
//因此s9、s10的值只能在运行是动态的确定,都不会缓存，因此无法直接使用缓存中的值
String s9 = s7 + s8;
String s10 = s7 + s8;
System.out.println(s9 == s10);
/*
final String s11 = "fkjava";
final String s12 = ".org";
String s13 = s11 + s12;
String s14 = s11 + s12;
System.out.println(s13 == s14); //true */
// final修饰的变量，【声明时就指定了初始值】,但他们的初始值在编译时不能确定, //所以不能执行宏替换,所以s11、s12只有在运行时才能确定
final String s11 = s9; //s11的字符序列是：疯狂java
final String s12 = s10;//s12的字符序列是：疯狂java
String s13 = s11 + s12;
String s14 = s11 + s12;
System.out.println(s13 == s14); //false
//final修饰的变量，【声明时就指定了初始值】，【而且初始值在编译就可以确定】
//那么这个变量就不存在,s15/s16会执行“宏替换”，也就是这两个变量根本就不存 //在，所有出现s15的地方都会替换成"fkjava",s16替换成".org"
//final String s15 = "fkjava";
//final String s16 = ".org";
/*String s17 = s15 + s16;
String s18 = s15 + s16;*/
String s17 = "fkjava" + ".org";
String s18 = "fkjava" + ".org";
System.out.println(s17 == s18); //true
}
}
3、final修饰方法：
final修饰的方法不能被重写@Override；
好处:禁止父类的方法被重写,避免破坏父类方法
注意点:final与private结合没有实际意义,两者存一即可(private本身就不能被重写)。
4、final修饰类:
final类不能有子类,由于它不能有子类,所以它的方法能可以被更好的保护,典型的final类有:String、System、Math和包装类。