知识点1- final的定义

• 在Java中，final关键字有最终的，不可修改的含义

  
  



• final 用于声明属性，方法和类

  属性：定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改。

  方法：定义必须有实现代码，并且子类里不可被覆盖。

  类：不能被定义为抽象类或是接口,不可被继承。

  
  

知识点2- final修饰属性

• 如果某个变量被final修饰，那么该变量就成为常量，不能被修改，一般语法：

  
  

　　

• 常量在声明时必须初始化，声明之后不能对其进行二次赋值，其后任何试图对常量进行赋值的语句都将报错。

  
  



• 规范：定义常量的时候，变量名所有字母都大写，每个单词之间使用下划线

  
  



• 赋值两种方式：构造方法赋值和声明时等号赋值

  
  



• 一些数学定理中的常量经常使用final修饰

  eg:π= 3.14159265358979; E= 2.718281828459045;

  
  



• 对参数做final修饰

  
  
  
  

  • 在方法参数前面加final关键字，为了防止数据在方法体中被修改。

    
    
  
  
  
  

package com.tjetc.myfinal;
public class FinalTest {
//方式一：定义常量直接赋值
public static final int USER_ROLE = 1; //final修改属性，属性就是常量，不能二次赋值
//public static final int ADMIN_ROLE; //当使用方法二构造方法进行给常量值赋值的情况，不能使用static
public final int ADMIN_ROLE;
// new一个对象开内存空间，常量的值是不变的，意味着没有必要为常量开多个内存空间。多个对象共享一个常量，static保证多个对象共享一个。
// 一般情况：定义常量static+final一起用
//方式二：构造方法给常量赋值
public FinalTest(int adminRole) {
this.ADMIN_ROLE = adminRole;
}
public void test() {
//USER_ROLE=2; //不能二次赋值
System.out.println("常量USER_ROLE=" + USER_ROLE);
System.out.println("常量ADMIN_ROLE=" + ADMIN_ROLE);
}
public static void main(String[] args) {
FinalTest test = new FinalTest(6);
test.test();
System.out.println("常量USER_ROLE=" + test.USER_ROLE);
}
}
/**
* 常量USER_ROLE=1
* 常量ADMIN_ROLE=6
* 常量USER_ROLE=1
*/

知识点3- final修饰方法

• 如果将某个成员方法修饰为final，则意味着该方法不能被子类覆盖，这就和抽象方法必须由子类实现的规定互相矛盾，因此，final和abstract不能同时修饰一个方法

  
  



• final方法的一般声明格式是：

  

  
  

知识点4- final修饰类

• 如果将某个类修饰为final，则说明该类无法被继承，一般语法：

  

  
  



• Java中有一个最常用的final类：java.lang.String

  
  

知识点5-静态的定义

• static被称为静态，可以用来修饰类的属性或者方法。

  
  



• 如果类的某个属性，不管创建多少个对象，属性的存储空间只有唯一的一个，那么这个属性就应该用static修饰，被static修饰的属性被称为静态属性，被static修饰的方法被称为静态方法。

  
  



• static属性可以使用对象调用，也可以直接用类名调用。

  
  



• 静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中只有一个。

  
  

知识点6-静态成员变量

• 被static修饰的成员变量被称为静态成员变量或者是静态属性

  package com.tjetc.myfinal;
  public class Employee {
  String name;
  double salary;
  //默认是0 静态成员变量 是所有对象共享的一个成员变量，可以使用对象调用也可以使用类名称调用
  static int count;
  //默认是0 成员变量 每个对象 有各自的成员变量，不共享的
  int myCount;
  public Employee(String name, double salary) {
  this.name = name;
  this.salary = salary;
  //让count和myCount 都自增1
  count++;
  myCount++;
  }
  public static void main(String[] args) {
  Employee e1 = new Employee("carat", 10000);
  System.out.println("姓名:" + e1.name + "\t工资：" + e1.salary + "\tcount:" + e1.count + "\tmyCount:" + e1.myCount);
  Employee e2 = new Employee("seventeen", 15000);
  System.out.println("姓名:" + e2.name + "\t工资：" + e2.salary + "\tcount:" + e2.count + "\tmyCount:" + e2.myCount);
  }
  }
  /**
  * 姓名:carat 工资：10000.0 count:1 myCount:1
  * 姓名:seventeen 工资：15000.0 count:2 myCount:1
  */
  

知识点7-静态方法

• 如果某个方法不需要与某个特定的对象绑定，那么该方法可以使用static修饰，被static修饰的方法称为静态方法。

  
  

• 静态方法如何调用：static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用。

  package com.tjetc.myfinal;
  public class SellTicket {
  private static int a = 10;//静态成员变量
  private int b; //成员变量
  //静态方法 能够只用静态的成员变量
  public static void sell() {
  //静态方法中 可以定义局部变量并且使用
  int c = 4;
  System.out.println("使用局部变量c=" + c);
  //静态方法 不能够使用成员变量（非静态）
  //b = 2;b无法使用
  a -= 1;
  System.out.println("使用静态成员变量：" + a);
  }
  public static void main(String[] args) {
  //通过类名调用方法,以下两种都可以
  SellTicket.sell();
  sell();
  //通过对象名调用
  SellTicket sell1 = new SellTicket();
  sell1.sell();
  }
  }
  /**
  * 使用局部变量c=4
  * 使用静态成员变量：9
  * 使用局部变量c=4
  * 使用静态成员变量：8
  * 使用局部变量c=4
  * 使用静态成员变量：7
  */
  

知识点7-静态方法-总结

• 本类的方法之间的调用

  
  
  
  

  • 静态方法可以被任何方法(静态方法和非静态方法)直接调用；

    
    
  
  

  • 非静态方法可以被非静态方法直接调用；

    
    
  
  

  • 非静态方法不能被静态方法直接调用，需要创建对象，用对象名调用。

    
    
  
  
  
  



• 不同类方法之间的调用

  
  
  
  

  • 调用静态方法，使用类名直接调用 ;

    
    
  
  

  • 非静态方法不能直接调用，需要创建对象，用对象名调用。

    
    
  
  
  
  

知识点8-静态代码块

• static代码块

  随着类的加载而加载，只执行一次，用于给类进行初始化

  看JVM加载类的过程：装载、连接、初始化（静态代码块，静态变量）

  static块的执行发生在“初始化”的阶段。初始化阶段，jvm主要完成对静态变量的初始化，静态块执行等工作。

  
  



• 构造代码块（实例代码块）

  
  



• 构造方法给对象初始化

  
  



• static代码块和构造代码块同时出现时优先级

  静态代码块>构造代码块>构造方法

  
  

package mystatic;
//优先父类初始化
class HelloA {
public HelloA() {
System.out.println("HelloA");
}
//在实例化对象过冲程中，早于构造方法执行
{
System.out.println("I'm A class");
}
//static块的执行发生在“初始化”的阶段。初始化阶段，jvm主要完成对静态变量的初始化，静态块执行等工作。在实例化对象之前
static {
System.out.println("static A");
}
}
class HelloB extends HelloA {
public HelloB() {
System.out.println("HelloB");
}
{
System.out.println("I'm B class");
}
static {
System.out.println("static B");
}
public static void main(String[] args) {
new HelloB();
}
}
/**
* static A
* static B
* I'm A class
* HelloA
* I'm B class
* HelloB
*/

知识点9-Static Import机制

• JDK1.5中引入了“Static Import”机制，借助这一机制，可以用略掉所在的类或接口名的方式，来使用静态成员

  
  



• 之前我们是这样调用静态方法的：

  

  
  



• 现在可以这样简化