final的含义在不同的场景下有细微的差别，但总体来说，它指的是“不可变”。
final变量

凡是对成员变量或者本地变量(在方法中的或者代码块中的变量称为本地变量)声明为final的都叫作final变量。final变量经常和static关键字一起使用，作为常量。用final关键字修饰的变量，只能进行一次赋值操作，并且在生存期内不可以改变它的值。

不过在针对基本类型和引用类型时，final关键字的效果存在细微差别。例如：
				class value {
				    int v;
				    public value(int v) {
				        this.v = v;
				    }
				}
				public class FinalTest {
				    final int f1 = 1;
				    final int f2;
				    public FinalTest() {
				        f2 = 2;
				    }
				    public static void main(String[] args) {
				        final int value1 = 1;
				        // value1 = 4;
				        final double value2;
				        value2 = 2.0;
				        final Value value3 = new Value(1);
				        value3.v = 4;
				    }
				}

上面的例子中，main方法中被final修饰的数据，在给value1赋初始值之后，我们无法再对value1的值进行修改，final关键字起到了常量的作用。从value2我们可以看到，final修饰的变量可以不在声明时赋值，即可以先声明，后赋值。value3时一个引用变量，这里我们可以看到final修饰引用变量时，只是限定了引用变量的引用不可改变，即不能将value3再次引用另一个Value对象，但是引用的对象的值是可以改变的。

另一方面，我们看到了用final修饰成员变量时的细微差别，因为final修饰的数据的值是不可改变的，所以我们必须确保在使用前就已经对成员变量赋值了。因此对于final修饰的成员变量，我们有且只有两个地方可以给它赋值，一个是声明该成员时赋值，另一个是在构造方法中赋值，在这两个地方我们必须给它们赋初始值。

转自：西瓜汁拌面

原文链接：https://www.cnblogs.com/mululu/p/9072596.html

实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，也就是成员变量。
实例方法：在类中声明的方法，例如：my(self)，必须实例化之后才可以使用，否则会报错。
类变量：公共的变量,每个实例都可以用。
类方法
     1、不用实例化就可以直接调用。

     2、它可以通过cls使用类变量

     3、它不能调用这个类里面的其他实例方法和实例变量

静态方法
     #你不想实例化的时候，就可以定义成类方法

     #静态方法就是一个普通函数，只不过是写在类里面而已，它用不了类变量、类方法、实例变量、实例方法

下面从实例中了解这几个知识点的具体用法，代码如下：
class Baby():
    nationality = 'China' #类变量，公共的变量,每个实例都可以用
    def __init__(self,name):   #带了self的都是实例方法，必须实例化了之后才能调用，否则会报错
        self.name = name  #实例变量，也叫成员变量
        print('self的内存地址',id(self))
    def cry(self):           #实例方法
        print('哇哇哇')

    @property   #这是一个装饰器，也叫属性方法，hhh函数就不能传参数了。如果函数没有入参就可以写property，调用的时候不能加括号了。
    def hhh(self):
        return 198
# b = Baby()
# print(b.hhh)       #调用的时候不能加括号，看起来像属性的一个方法。

    @classmethod           #类方法
    def xm(cls):           #cls代表的就是baby
        print(cls.nationality)
        print('我是类方法')
      #  print(cls.name)  cls不能调用实例变量，会报错
      #  cls.cry()        cls不能调用实例方法，会报错

    @staticmethod        #静态方法
    def xh():
        print('这个是静态方法，它和一个没写在类里面的函数一样')

##############静态方法调用#############
Baby.xh()

###############类变量调用#############
Baby.nationality='USA'   #类变量是可以直接通过类名.xxx来进行修改的。

dcg = Baby()
dcg.nationality = 'Japan'     #不会改变类变量的值，只是改变了dcg这个实例中nationality的值
print(dcg.nationality)
yjt = Baby()
print(yjt.nationality)

############装饰器，属性方法#############
b = Baby()
print(b.hhh)    #调用时直接对象.函数名，不需要加括号，看起来像属性的方法

##############self###############
dcg = Baby('春光')
print('董春光的内存的',id(dcg))
zll = Baby('张流量')
print('董春光的内存的',id(zll))

>>>self的内存地址 7338696
   董春光的内存的 7338696
   self的内存地址 7338920
   张流量的内存的 7338920

                                                    
局部变量：在方法、构造方法或语句块中定义的变量称为局部变量。局部变量的声明和初始化都是在方法中，方法结束后，局部变量就会自动销毁。
 
成员变量：在类里面，方法体之外的变量称为成员变量。成员变量在创建对象的时候就会被实例化。成员变量可以被类中的方法、构造方法和特定类的语句块访问。
 
 
                                                    
转载于:https://my.oschina.net/u/3891918/blog/1865442

由static修饰的变量、常量和方法被称作静态变量、常量和方法。

被声明为static的变量、常量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和"."运算符调用成员变量

语法如下：

类名.静态类成员

通过以下示例说明语法的使用：

public class staticTest1 {
	static double PI = 3.1415;	//定义静态常量
	static int id;				//定义静态变量
	
	public static void method1() {	//定义静态方法
		System.out.println("静态方法输出！");
	}
	
	public void method2() {
		System.out.println(staticTest1.PI);//调用静态常量
		System.out.println(staticTest1.id);//调用静态变量
		staticTest1.method1();//调用静态方法
	}

}

在上述代码中设置了3个静态成员，分别是常量、变量和方法，然后再method2()方法中分别调用了三个静态成员，直接使用"类名.静态成员"形式进行了调用。

在Java语言中对静态方法有两点规定：

1、静态方法不可以使用this关键字

2、在静态方法中不可以直接调用非静态方法