一、static关键字
1.static关键字的引入
当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上 的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象， 其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少 对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个 国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中 都单独分配一个用于代表国家名称的变量。
2.static关键字的使用
(1)使用范围： 在Java类中，可用static修饰属性、方法、代码块、内部类，不能修饰构造器。
(2)使用static修饰属性：静态变量（或类变量）。如果想让一个类的所有实例共享数据，就用类变量！类中的常量也常常声明为static。
属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)。
实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的 非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用。
静态变量的加载要早于对象的创建。
由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
类变量 vs 实例变量内存解析
(3)使用static修饰方法：静态方法。操作静态属性的方法，通常设置为static的。工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections
随着类的加载而加载，可以通过"类.静态方法"的方式进行调用。
在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构。
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性。
因为不需要实例就可以访问static方法，因此static方法内部不能有this、super关键字。
static修饰的方法不能被重写 。
public class StaticTest {
public static void main(String[] args) {
Chinese.nation = "中国";
Chinese c1 = new Chinese();
c1.name = "姚明";
c1.age = 40;
c1.nation = "CHN";
Chinese c2 = new Chinese();
c2.name = "马龙";
c2.age = 30;
c2.nation = "CHINA";
System.out.println(c1.nation);
//编译不通过
// Chinese.name = "张继科";
c1.eat();
Chinese.show();
//编译不通过
// Chinese.eat();
// Chinese.info();
}
}
//中国人
class Chinese{
String name;
int age;
static String nation;
public void eat(){
System.out.println("中国人吃中餐");
//调用非静态结构
this.info();
System.out.println("name :" +name);
//调用静态结构
walk();
System.out.println("nation : " + nation);
}
public static void show(){
System.out.println("我是一个中国人！");
//不能调用非静态的结构
// eat();
// name = "Tom";
//可以调用静态的结构
System.out.println(Chinese.nation);
walk();
}
public void info(){
System.out.println("name :" + name +",age : " + age);
}
public static void walk(){
}
}
关于静态属性和静态方法的使用，都从生命周期的角度去理解。
(4)使用static修饰代码块：静态代码块。
一个类中代码块若有修饰符，则只能被static修饰。
1. 可以有输出语句。
2. 可以对类的属性、类的声明进行初始化操作。
3. 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
4. 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
5. 静态代码块的执行要先于非静态代码块。
6. 静态代码块随着类的加载而执行，且只执行一次。
3.static关键字的应用
(1)单例 (Singleton)设计模式。
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对 某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构 造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生 类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无 法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象 的变量也必须定义成静态的。
单例(Singleton)设计模式-饿汉式 ----》对象加载时间过长。
class Singleton {
// 1.私有化类的构造器
private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single = new Singleton();
// 3.提供公共的静态的方法，返回当前类的对象
public static Singleton getInstance() {
return single;
}
}
public class SingletonTest1 {
public static void main(String[] args) {
// Bank bank1 = new Bank();
// Bank bank2 = new Bank();
Bank bank1 = Bank.getInstance();//对象唯一
Bank bank2 = Bank.getInstance();
System.out.println(bank1 == bank2);//true
}
}
//饿汉式
class Bank{
//1.私有化类的构造器
private Bank(){
}
//2.内部创建类的对象
//4.要求此对象也必须声明为静态的
private static Bank instance = new Bank();
//3.提供公共的静态的方法，返回类的对象
public static Bank getInstance(){
return instance;
}
}
单例(Singleton)设计模式-懒汉式 ---》延迟对象的创建。
class Singleton {
// 1.私有化构造器 private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single;
// 3.提供公共的静态的方法，返回当前类的对象
public static Singleton getInstance() {
if(single == null) {
single = new Singleton();
}
return single;
}
}
public class SingletonTest2 {
public static void main(String[] args) {
Order order1 = Order.getInstance();
Order order2 = Order.getInstance();
System.out.println(order1 == order2);//true
}
}
//懒汉式
class Order{
//1.私有化类的构造器
private Order(){
}
//2.声明当前类对象，没有初始化
//4.此对象也必须声明为static的
private static Order instance = null;
//3.声明public、static的返回当前类对象的方法
public static Order getInstance(){
if(instance == null){
instance = new Order();
}
return instance;
}
}
4.main方法的使用
(1)理解main方法的语法
由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是 public，又因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须 是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。
又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在之前的例子中多次碰到。
main()方法作为程序的入口。
main()方法可以作为我们与控制台交互的方式。
二、final关键字
在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。
final标记的类不能被继承。提高安全性，提高程序的可读性。如String类、System类、StringBuffer类。
final标记的方法不能被子类重写。比如：Object类中的getClass()。
final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只 能被赋值一次。final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋 值，然后才能使用。 final double MY_PI = 3.14;
final修饰属性（成员变量）：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化。
public class FinalTest {
final int WIDTH = 0;
final int LEFT;
final int RIGHT;
//final int DOWN;
{
LEFT = 1;
}
public FinalTest(){
RIGHT = 2;
}
public FinalTest(int n){
RIGHT = n;
}
//public void setDown(int down){//不能这样赋值
// this.DOWN = down;
//}
}
final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值
以后，就只能在方法体内使用此形参，但不能进行重新赋值。
public void show(final int num){
// num = 20;//编译不通过
System.out.println(num);
}
static final 用来修饰属性：全局常量；用来修饰方法不能被重写。