1、final关键字
（1）final关键字修饰类，那么这个被修饰的类叫做太监类，不可以被继承，没有子类。
（2）final修饰方法，这个方法可以被继承但是不可以被重写，普通方法被重写后可以被final修饰
（3）final修饰变量：一次赋值终身不变
（4）final修饰成员变量（基本数据类型，引用数据类型）：必须显示赋值，或者通过构造方法赋值
（5）final修饰局部变量（基本数据类型，引用数据类型）：定义时可以不赋值，用的时候再赋值
创建一个爷爷类
public class Ye {
public final void eat(){
System.out.println("爷爷吃饭");
}
public void sleep(){
System.out.println("爷爷睡觉");
}
}
创建一个父类
public final class Fu extends Ye {
/*public void eat(){
}*/
public final void sleep() {
// TODO Auto-generated method stub
super.sleep();
}
}
创建一个子类
//不可以继承final修饰的父类
public class Zi /*extends Fu*/{
//
final int a=1;
/*public Zi(int a){
this.a=a;
}*/
}
注：Fu类是被final修饰的类，所以Zi类不可以继承Fu类。Fu类继承Ye类，不可以重写Ye类被final修饰的eat方法，重写Ye类中的sleep方法后可以再用final修饰。
在Zi类中定义的int a被final修饰，要么定义时显示赋值，要么通过构造方法进行赋值，如果通过构造方法赋值，则需要以后每一个构造方法都需要再写赋值语句。一次赋值终身不变
创建一个测试类，该测试类不依照上方的类测试
public class Demo01 {
public static void main(String[] args) {
final int a;
a=2;
final Person p=new Person("bbb",18);
p.setName("aaa");
}
}
在测试类中被final修饰的int a；定义时没有给赋值，用到的时候给a赋值了一个2。用final修饰引用数据类型时，创建对象可以直接赋值bbb，18，可以再将bbb改成aaa，原因是final修饰的引用数据类的地址值，地址值并没有发生改变，改变的是这个地址的属性，所以可以改动。
2、static关键字
被static修饰的成员变量属于类，不属于类的某个对象，也就是说，多个对象调用这个被static修饰的成员变量时，只要一个对象修改了这个成员变量的属性值，则所有调用这个成员变量的对象都发生了改变
例：创建一个Student类
public class Student {
private String name;
static String schoolname;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Student(String name) {
super();
this.name = name;
}
public Student() {
super();
}
}
创建一个测试类
public class Demo01 {
public static void main(String[] args) {
Student s1=new Student("小红帽","清华大学");
Student s2=new Student("小兰帽","清华大学");
Student s3=new Student("小白帽","清华大学");
s3.schoolname="北京大学";
System.out.println(s1.getName()+"..."+Student.schoolname);
System.out.println(s2.getName()+"..."+Student.schoolname);
System.out.println(s3.getName()+"..."+Student.schoolname);
}
}
那么这个运行结果是
小红帽...北京大学
小兰帽...北京大学
小白帽...北京大学
图解：
那我们说被static修饰的成员变量属于类，类需要用public修饰，可以直接通过类名调用，上述中用对象调用是不合适的，
那更改一下代码、
创建一个苏student类 里写一个静态方法
public class Student {
private String name;
public static String schoolname;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Student(String name) {
super();
this.name = name;
}
public Student() {
super();
}
public static void eat(){
System.out.println("这是静态方法");
}
}
创建一个测试类
public class Demo01 {
public static void main(String[] args) {
Student s1=new Student("小红帽");
Student s2=new Student("小兰帽");
Student s3=new Student("小白帽");
Student.schoolname="北京大学";
System.out.println(s1.getName()+"..."+Student.schoolname);
System.out.println(s2.getName()+"..."+Student.schoolname);
System.out.println(s3.getName()+"..."+Student.schoolname);
Student.eat();
}
}
static 修饰方法，静态方法不能访问非静态方法，非静态方法可以访问静态方法
例：
非静态方法get2可以访问静态的方法get
public static void get(){
System.out.println("静态方法");
}
public void get2(){
get();
}
注意事项：静态内容优先于对象的存在，只能访问静态，不能使用this和super关键字。在同一个类中静态成员只能访问静态成员。
在多态种，所有的方法都是用的非静态方法和非静态成员变量，所以在调用成员变量时，编译运行都看左边，调用成员方法时，编译看左边，运行看右边
如果在多态中，全部使用的静态成员变量和静态成员方法，则无论是调用成员变量还是成员方法，都是编译运行看左边
例：创建一个Fu类
public class Fu {
static int a=1;
static int b=2;
public static void eat(){
System.out.println("父类吃饭");
}
public static void sleep(){
System.out.println("父类睡觉");
}
}
创建一个子类继承Fu类
public class Zi extends Fu{
static int a=10;
static int c=30;
public static void eat(){
System.out.println("子类吃饭");
}
public static void play(){
System.out.println("子类玩耍");
}
}
创建一个测试类
public class Demo02 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Fu f=new Zi();
System.out.println(f.a);
System.out.println(f.b);
//System.out.println(f.c);
f.eat();
f.sleep();
//f.play();
}
}
运行结果
1
2
父类吃饭
父类睡觉
因为所有的成员变量和成员方法都用了static修饰，所以创建多态对象时，不能调用子类独有的变量和方法，编译运行时都以父类为基础（在这里不担心父类会有抽象方法，因为抽象方法abstract关键字与final关键字和static 关键字冲突，有static就不会有抽象方法）
定义静态常量
是用public static final 关键字修饰完成的
定义格式 public static final 数据类型 变量名 = 值;
当我们想使用类的静态成员，可以直接使用类名调用成员变量或者方法名
注：在接口中每个成员变量都是默认的用public static final 来修饰的，所有接口中的成员变量已经是静态形式，因为接口中没有构造方法，所以必须显示赋值，可以直接通过接口名进行访问