类变量
简介
类变量也叫静态变量或静态属性,是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。
public static int a;
类变量内存布局
根据版本的不同,static变量的存储位置可能在堆中也可能在静态域。下面是两个相关的博客:
Java static变量保存在哪?_晚晴小筑-CSDN博客_java static变量存储在哪里
java中的静态变量和Class对象究竟存放在哪个区域? - 知乎
不管static变量在哪里,有几条共识—— 1. static 变量是同一个类所有对象共享。 2. static类变量,在类加载的时候就生成了(因此可以用类名进行调用,即使没有创建对象实例也可以访问)。
如何定义类变量
语法: 访问修饰符 static 数据类型 变量名;(推荐,也可以访问修饰符和static调换位置)
如何访问类变量
类名.类变量名(推荐) 或者 对象名.类变量名
注意静态变量的访问修饰符的访问权限和范围和普通属性相同。
注意事项
1. 什么时候需要用类变量:当我们需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量(静态变量):比如定义学生类,统计所有学生共交多少钱。
2. 类变量与实例变量(普通属性)区别:类变量是该类的所有对象共享的,而实例变量是每个对象独享的。
3. 加上static称为 类变量 或 静态变量。否则称为 实例变量/普通变量/非静态变量。
4. 实例变量不能通过 类名.类变量名 的方式访问。
5. 类变量是在类加载时就初始化了,也就是说,即使没有创建对象,只要类加载了,就可以使用类变量了。
6. 类变量的生命周期是随类的加载开始,随着类消亡而销毁。
类方法
基本介绍
类方法也叫静态方法,形式如下:
访问修饰符 static 数据返回类型 方法名(){ } //推荐
static 访问修饰符 数据返回类型 方法名(){ }
使用方式: 类名.类方法名 或 对象名.类方法名。
使用场景
当方法中不涉及到任何和对象相关的成员(也就是不需要声明一个对象),则可以将方法设计成静态方法,提高开发效率,比如Math类,Arrays类的方法等。
在实际开发中,往往会将一些通用的方法设计成静态方法,这样不需要创建对象就可以使用了,比如冒泡排序,打印一维数组等。
注意事项
1. 类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区,类方法中无this参数,普通方法中隐含着this参数。
2. 类方法可以通过类名调用,也可以通过对象名调用(遵循继承规则,只要能继承,可以用父类名调用,也可以用子类名调用)。普通方法只能通过对象名调用。
3. 类方法中不允许使用和对象有关的关键字,比如this和super。
4. 静态的方法,只能访问静态的成员(没有this,只能访问类变量和类方法)。非静态的方法,可以访问静态成员和非静态成员。
public class Person {
private int id;
private static int total = 0;
public static void setTotalPerson(int total){
this.id = total; //错误,不能使用this
this.total = total; //错误,不能使用this
Person.total = total; //正确,如果不重名的话可以不加类名
}
}
5. 不能用普通方法给静态变量赋值。
public class Person {
public static int id = this.show(); //报错
public int show(){
System.out.println("调用show");
return 10;
}
}
main方法
解释形式
public static void main(String[] args){}
1. public:因为main方法是Java虚拟机进行调用的,因此访问修饰符需要使用public。
2. static:Java虚拟机在执行main方法时不必创建对象,所以该方法必须是static。
3. String[] args:main方法接收String类型的数组参数,该数组中保存执行Java命令时传递给所运行的类的参数。
public class args{
public static void main(String[] args) {
System.out.println("传入的第一个参数是"+args[0]);
System.out.println("传入的第二个参数是"+args[1]);
System.out.println("传入的第三个参数是"+args[2]);
}
}
在IDEA中传入参数:
特别提示
1. 在main方法中,我们可以直接调用main方法所在类的静态方法或静态属性。
2. 但是,不能直接访问该类中的非静态成员,必须创建该类的一个实例对象后,才能通过这个对象去访问类中的非静态成员。
public class Test {
public static double PI = 3.14;
public int ss = 10;
public static void test100(){
System.out.println("调用静态方法");
}
public static void main(String[] args) {
test100();
System.out.println(PI);
System.out.println(ss); //报错
}
}
代码块
基本介绍
代码块又称为初始化块,属于类中的成员(即类的一部分),类似于方法,将逻辑语句封装在方法体中,用{}包围起来。
但和方法不同,没有方法名,没有返回值,没有参数,只有方法体,而且不用通过对象或类显式调用,而是加载类时或创建对象时隐式调用。
基本语法
(static){...
};
1. static关键字和分号(;)可写可不写。
2. 代码块分为两类,使用static修饰的叫做静态代码块,没有static修饰的叫做普通代码块/非静态代码块。
3. 逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)。
好处
1. 相当于另外一种形式的构造器(对构造器的补充机制),可以做初始化的操作。
2. 场景:如果多个构造器中都有重复的语句,可以抽取到代码块中,提高代码的重用性。
public class Person {
private String name;
private int age;
private String job;
{
System.out.println("输入信息中...");
System.out.println("请稍后...");
System.out.println("信息输入成功");
} //代码块
public Person(String name, int age, String job) {
System.out.println("调用三个参数的构造器");
this.name = name;
this.age = age;
this.job = job;
}
public Person(String name) {
System.out.println("调用一个参数的构造器");
this.name = name;
} //不管用哪个构造器创建对象,都会先调用代码块的内容
}
public class Test {
public static void main(String[] args) {
Person a = new Person("shang",10,"teacher");
}
}
注意事项
1. static代码块也叫静态代码块,作用就是对类进行初始化,而且它随着类的加载而执行,并且只会执行一次。如果是普通代码块,每创建一个对象,就执行。
2. 类什么时候被加载 —— (1) 创建对象实例时(new) (2) 创建子类对象实例,父类也会被加载 (3) 使用类的静态成员时(静态属性,静态方法)。注意只会执行一次。
public class Person {
private String name;
public static int id = 10; //静态属性
public static void show(){ //静态方法
System.out.println("调用静态方法");
}
{
System.out.println("调用普通代码块");
}
static{
System.out.println("调用静态代码块");
}
public Person(String name) {
System.out.println("调用构造器");
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
Person a = new Person("Jack");
System.out.println(Person.id);
Person.show();
}
}
发现在创建对象时,静态代码块和普通代码块都调用了,因为静态代码块已经调用过一次了,因此调用静态成员时没有调用静态代码块。
3. 普通的代码块,在创建对象实例时,会被隐式的调用,被创建一次,就会调用一次(可以理解为是构造器的补充)。如果只是使用类的静态成员,普通代码块并不会执行。
public class Test {
public static void main(String[] args) {
Person a = new Person("Jack");
Person b = new Person("Tom");
Person c = new Person("Smith");
}
}
4. 创建一个对象时,在一个类中的调用先后顺序:(1) 调用静态代码块和静态属性初始化(注意:静态代码块和静态属性初始化调用的优先级一样,如果有多个静态代码块和多个静态变量初始化,则按照他们定义的顺序调用) (2) 调用普通代码块和普通属性的初始化(注意:普通代码块和普通属性初始化调用的优先级一样,与静态判断方法相同) (3) 调用构造方法
public class Person {
public static int id = getId(); //静态变量初始化
{
System.out.println("调用普通代码块");
} //普通代码块
public int num = getNum(); //普通变量初始化
static{
System.out.println("调用静态代码块");
} //静态代码块
public static int getId(){
System.out.println("调用静态方法");
return 10;
}
public int getNum(){
System.out.println("调用普通方法");
return 100;
}
public Person() {
System.out.println("调用构造器!");
}
}
首先看静态变量初始化以及静态代码块的位置,发现静态变量初始化在前,因此先加载静态变量初始化,为了更明显的看出先后,因此调用了方法。再分析普通变量初始化和普通代码块,最后是构造器。
public class Test {
public static void main(String[] args) {
Person a = new Person(); //因为是初始化一个对象,因此静态代码块和普通代码块都调用
}
}
5. 构造器的最前面其实 隐含了super()和调用普通代码块,静态相关的代码块,属性初始化,在类加载时就执行完毕了,因此优先于构造器和普通代码块。而构造器执行时先执行super和普通代码块,这与第四点相互印证。
public class Person {
{
System.out.println("调用父类的普通代码块");
}
public Person() {
//super() 隐藏语句,Object类没有输出信息
//调用普通代码块 隐藏语句
System.out.println("调用父类的构造器");
}
}
public class Student extends Person{
{
System.out.println("调用子类的普通代码块");
}
public Student(){
// super() 隐藏语句
// 调用普通代码块 隐藏语句
System.out.println("调用子类的构造器");
}
}
public class Test {
public static void main(String[] args) {
Student a = new Student();
}
}
6. 静态代码块只能直接调用静态成员,普通代码块可以调用任意成员。
调用顺序总结
1. 父类的静态代码块和静态属性(优先级相同,按书写顺序执行)
2. 子类的静态代码块和静态属性(优先级相同,按书写顺序执行)
3. 父类的普通代码块和普通属性初始化(优先级相同,按书写顺序执行)
4. 父类的构造方法
5. 子类的普通代码块和普通属性初始化(优先级相同,按书写顺序执行)
6. 子类的构造方法
注:为了更好看到属性初始化的顺序,一般用方法给属性初始化,方法里加输出。
public static int id = getId(); //静态变量初始化
public static int getId(){
System.out.println("调用静态方法");
return 10;
}
单例设计模式
设计模式
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱,不同的棋局,我们用不同的棋谱,免去我们自己再思考和摸索。
单例设计模式
采取一定方法保证在整个软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法。
单例模式有两种方式:1. 饿汉式 2. 懒汉式
饿汉式
1. 构造器私有化——防止直接new出来一个对象。
2. 类的内部创建一个静态对象。
3. 向外暴露一个静态的公共方法,该方法返回一个静态对象。
public class GirlFriend {
private String name;
private static GirlFriend gf = new GirlFriend("小红"); //内部创建的对象
public static GirlFriend getInstance(){
return gf;
} //对外公开的获得对象方法
private GirlFriend(String name) {
this.name = name;
} //构造器私有化
}
public class Test {
public static void main(String[] args) {
GirlFriend gf1 = GirlFriend.getInstance();
GirlFriend gf2 = GirlFriend.getInstance(); //都返回 gf
if(gf1 == gf2){
System.out.println("同一个人"); //输出 同一个人
}
}
}
注:饿汉式在内部就创建了对象,如果不使用的话会造成内存空间的浪费。
懒汉式
1. 仍然构造器私有化。
2. 定义一个static静态属性对象(注意不new)。
3. 提供一个public的static方法,可以返回一个static对象。
4. 当用户第一次使用getInstance方法时,才会创建static对象,再次调用就返回那个静态对象。
public class Person {
private static Person aa; //私有经典对象
private Person(){
System.out.println("构造器调用");
}
private static Person getInstance(){
if(aa == null){
aa = new Person(); //调用时才分配空间
}
return aa;
}
}
区别
1. 二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载之前就创建了对象实例,而懒汉式是在使用时才创建。
2. 饿汉式不存在线程安全问题,懒汉式存在线程安全问题。
3. 饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用,那么饿汉式创建的对象就浪费了,懒汉式是使用时才创建,就不存在这个问题。
4. 在JavaSE标准类中,java.lang.Runtime就是经典的单例模式。