深入了解static关键字的作用和应用--java面向对象学习
Static修饰成员变量
Static是什么
- 叫静态，可以修饰成员变量，成员方法
成员变量按有无static修饰分俩种：
- 类变量：有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享
- 实例变量（对象的变量）：无static修饰，属于每个对象的
类变量为所有对象共享，类变量的生命周期同类一样，而每个对象都有独属于自己的示例变量，实例变量的生命周期同对应实例一样，公家的和自家的区别
访问类变量的方式：
- 类名.类变量（推荐，高效，方便）
- 对象.类变量（不推荐）
——通过类名访问相当于直接去方法区找到类和对应类方法，而通过对象访问是先找到对象再通过对象去找类，再找到对应类方法
代码演示：
- 创建一个学生类：
public class Student { static int grade; //年级 String name; //姓名 } - 创建俩个学生对象：
public class StaticDemo1 { public static void main(String[] args) { Student s1 = new Student(); //定义学生对象1 Student s2 = new Student(); //定义学生对象2 Student.grade = 1; //通过类名访问类变量，给类变量grade赋值 // s1.grade = 2; //也可以通过对象来访问类变量，不过不推荐这麽做 s1.name = "小明"; //学生对象1实例变量赋值 s2.name = "小红"; //学生对象2示例变量赋值 System.out.println("我是" + Student.grade +"年级的" + s1.name); //输出学生对象1和学生对象2的信息 System.out.println("我是" + Student.grade +"年级的" + s2.name); } }
注：实例变量不能通过类名去访问
像这种访问方式是错误的，因为实例变量独属于每个对象，只通过类名怎么知道你是想访问哪个对象呢~
类变量的应用场景
- 在开发中，如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义成类变量来记住
案例：
- 有一个学生类，希望学生类可以自己记录已经创建过多少学生对象
public class Student2 {
public static int number; //记录已经创建多少个学生对象
public Student2() {
//在同一个类中，访问自己类的类变量可以不写类名，在别的类中需要写类名
number++; //每次调用构造函数，都记录下来
}
}public class StaticDemo2 {
public static void main(String[] args) {
Student2 s1 = new Student2();
Student2 s2 = new Student2();
Student2 s3 = new Student2();
System.out.println("我已经创建了" + Student2.number + "个学生对象啦");
}
}运行结果：
Static修饰成员方法
成员方法按有无Static修饰分俩种
- 类方法：有Static修饰的成员方法，属于类
- 实例方法：无Static修饰的成员方法，属于对象
类方法不可以访问实例方法和实例变量，但是实例方法可以访问类方法和类变量
访问类方法的方式：
- 类名.类方法（推荐，高效，方便）
- 对象.类方法（不推荐）
代码演示：
- 对象
public class Student3 { double score; //分数 public static void HelloWorld(){ //Static修饰的成员方法——类方法 System.out.println("HelloWorld!"); } public void Pass(){ //没用Static修饰的成员方法——实例方法 System.out.println(this.score >= 60? "及格" : "不及格"); } } - 访问
public class StaticDemo3 { public static void main(String[] args) { //通过类名访问实例方法，推荐 Student3.HelloWorld(); //通过对象访问实例方法.不推荐 Student3 s = new Student3(); s.HelloWorld(); //通过类名访问实例方法，报错 // Student3.Pass(); } }注：同实例对象一样实例方法也不能通过类名去访问
小知识：
其实main方法就是一个类方法，当我们用java命令执行程序的时候，虚拟机会用当前类直接.main()方法，也就是说 java test == test.main(), 那么main方法括号里的字符串数组是干什么的呢？：
，这个数组实际上是用来接收数据的，并且我们也可以去使用这个数组里的数据（如果有的话），我们可以在控制台执行class文件的时候传入一些参数给main方法使用，比如现在有这麽一串代码：
public class Test {
public static void main(String[] args) {
for (String arg : args) {
System.out.println(arg);
}
}
}在控制台编译执行并传入数据给它：
类方法的常见应用场景
- 类方法最常见的应用场景是设计工具类
工具类是什么
- 用来完成某一个功能的，用来给开发人员共同使用的类方法
使用类方法设计工具类有什么好处
- 提高了代码复用，调用方便，提高了开发效率
如果需要一个类只存一些需要重复使用的方法，那么就可以创造一个专门提供这些方法的工具类，在类里面创造需要的类方法，需要使用该方法的时候直接类名.类方法就可以很方便的使用了。例如有多个类都需要创建指定位数验证码时，就可以 创建一个工具类专门存放生成随机验证码方法以供调用：
案例：
假设现在有一个方法1需要创建一个四位验证码，另一个方法2需要创建一个六位验证码，为了提高代码复用，减少重复代码，我们就可以专门为创建验证码这个方法设计一个方法类，放在工具类中以供调用：
方法1代码：
public class Demo1 {
//需要创建四位验证码
public void CreateCode(){
System.out.println(MyUtil.CreateCode(4));
}
}方法2代码：
public class Demo2 {
//需要创建六位验证码
public void CreateCode(){
System.out.println(MyUtil.CreateCode(6));
}
}工具类代码：
import java.util.Random;
public class MyUtil { //专门存放需要重复使用的方法的工具类
public static String CreateCode(int digit) { //验证码随机生成方法，作为类方法提高复用性
Random r = new Random();
String numbers = "1234567890abcdefghijklmnopqistuvwxyzABCDEFGHIJKLMNOPQISTUVWXYZ"; //字符池
StringBuilder code = new StringBuilder();
while(digit-- != 0){ //传入的形参控制位数
code.append(numbers.charAt(r.nextInt(0, 63)));
}
return code.toString();
}
}测试：
public class Test {
public static void main(String[] args) {
Demo1 d1 = new Demo1();
Demo2 d2 = new Demo2();
d1.CreateCode();
d2.CreateCode();
}
}运行结果：
小知识：
- 为什么工具类中的方法要用类方法不用实例方法？
- 用实例方法当然也是可行的，但是作为实例方法必须使用对象调用，必须先创建类对象才能调用相关实例方法，而此时对象只是为了调用方法，浪费内存，不如直接使用类方法
- 因为工具类只是为了提供类方法而存在，不需要创建对象，所以其实可以将工具类的构造方法私有：
使用类方法、实例方法时的几点注意事项
- 类方法中可以直接访问类变量，不可以直接访问实例变量
- 实例方法中既可以直接访问类成员，也可以直接访问实例成员
- 实例方法中可以出现this关键字，类方法中不可以出现this关键字
Static修饰代码块
代码块是什么
- 代码块是类的五大成分之一（成员变量、构造器、方法、代码块、内部类）
代码块按有无Static修饰分俩种：
- 静态代码块
-->格式：static{ ... }
-->特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次
-->作用：完成类的初始化，例如：对类变量的初始化赋值 - 实例代码块
-->格式：{ ... }
-->特点：每次创建对象时，执行实例代码块，并在构造器前执行
-->作用：和构造器一样，都是用来完成对象的初始化，例如对示例变量进行初始化赋值
代码演示：
静态代码块：
public class Block {
static int age = 18; //类变量
static{ //静态代码块,只会在类加载时执行一次
System.out.println("静态代码块被执行");
}
}测试：
public class Test {
public static void main(String[] args) {
System.out.println(Block.age); //访问Block类的类变量，会先加载Block类
System.out.println(Block.age); //访问三次
System.out.println(Block.age);
}
}结果：
虽然访问了三次类变量，但是静态代码块只在第一次访问加载时执行了一次
实例代码块：
public class Block {
String name; //实例变量
{ //实例代码块,每次创建对象在构造器前执行一次
System.out.println("实例代码块执行");
}
public Block() {
System.out.println("无参构造器执行");
}
public Block(String name) {
System.out.println("有参构造器执行");
}
}测试：
public class Test {
public static void main(String[] args) {
Block b1 = new Block(); //创建对象并调用无参构造器
Block b2 = new Block("小明"); //创建对象并调用有参构造器
}
}结果：
每次创建对象时，都会在调用构造器之前执行一次实例代码块
虽然实例代码块可以给示例变量赋初值，但是意义不大，因为实例代码块不能传参，所有赋初值的实例变量都是一个值，所以一般不会去使用实例代码块给实例变量赋初值，但是可以用实例代码块记录日志之类的，比如每次有人创建对象，就可以在实例代码块记录一下
Static应用：单例设计模式
设计模式是什么
- 一个问题通常有n种解法，其中肯定有一种解法时最优的，这个最优的解法就是设计模式
- 设计模式总共有23种，对应各种软件开发种会遇到的问题
单例设计模式
- 确保一个类只有一个对象
- 把类的构造器私有
- 定义一个类变量记住类的一个对象
- 定义一个类方法返回对象
代码演示：
单例设计模式设计一个类：
public class SingleCase {
private static SingleCase s = new SingleCase(); //2、定义一个类变量记住一个类对象
private SingleCase(){} //1、私有类的构造器
public static SingleCase getObject(){ //定义一个类方法返回类对象
return s;
}
}
测试：
public class Test {
public static void main(String[] args) {
// SingleCase s = new SingleCase(); 无法再通过原来的方法创建该类对象
SingleCase s1 = SingleCase.getObject(); //但是可以通过类方法调用类变量返回一个对象
SingleCase s2 = SingleCase.getObject(); //因为类变量只会在类加载的时候创建一次，所以通过这种方法创建的类对象都是同一个
System.out.println(s1);
System.out.println(s2);
}
}运行结果：
俩个类对象的地址都是一样的，说明它们引用的是同一个对象
单例设计模式的应用
这是官方提供的Runtime类，可以看到它就是使用的单例设计模式来设计的
比如说我们常用到的任务管理器就是单例设计模式，不管启动多少次任务管理器，它都只会打开那一个任务管理器。在只需要一个对象即可解决问题时，就可以使用单例设计模式来设计，即可以避免内存浪费
小知识：
单例设计模式不止一种：
像刚才代码演示的单例设计模式只是其中一种，称为饿汉式单例设计模式，除此之外还有懒汉式单例模式、双检索等等.......