java中static静态关键字
一、静态的概述
我们可以基于一个类创建多个对象，每个对象都拥有自己的成员，所有成员变量的值是根据对象而存在的，有些时候我们希望一个类的所有对象共享一个成员，这就用到了static静态关键字。
被静态关键字修饰的成员属于静态成员，它属于整个类所有，而并不仅仅是一个对象中的成员所共享，当系统第一次使用该类时，就会为其分配内存空间，直到该类被销毁是才进行资源回收，静态成员也有自己特有的访问方法。
static可以修饰变量、方法、代码块。
1. static变量：
对于静态变量在内存中只有一个拷贝，这样节省了内存，Java虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问方便，当然也可以通过对象来访问，但这样也没有静态存在的意义了。
而对于实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响比较灵活。
所以一般在需要实现以下两种情况时使用静态变量：#在对象之间共享值时 #在方便访问变量时
2. static方法：
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法，只能访问所属类的静态成员变量和成员方法。
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。
例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。
静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的
3. static代码块：
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。
利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。
二、静态的特点
1、被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）
2、被static修饰的成员可以并且建议通过类名直接访问
访问静态成员的格式:
类名.静态成员变量名
类名.静态成员方法名(参数)
3、静态的加载优先于对象,随着类的加载而加载
案例代码
package com.test;
/*
*static:是一个关键字，用于修饰成员变量和成员方法
*static的特点：
* 被所有的对象所共享
* 可以使用类名调用
* 静态的加载优先于对象
* 随着类的加载而加载
*
*/
public class StaticDemo {
public static void main(String[] args) {
Person.comeFrom = "成都";
Person p = new Person();
p.name = "张三";
p.age = 18;
//p.comeFrom = "成都";
p.speak();
Person p2 = new Person();
p2.name = "李四";
p2.age = 20;
//p2.graduateFrom = "成都";
p2.speak();
}
}
class Person {
String name;
int age;
static String comeFrom;
public void speak() {
System.out.println(name + "---" + comeFrom);
}
}
二、静态的注意事项
1、静态成员只能直接访问静态成员
2、非静态成员既可以访问非静态成员也可以访问静态成员
案例代码
package com.test;
/*
* static的注意事项：
* 静态方法：
* 可以调用静态的成员变量
* 可以调用静态的成员方法
* 不可以调用非静态成员变量
* 不可以调用非静态成员方法
* 静态方法只能调用静态的成员
* 非静态方法：
* 可以调用静态的成员变量
* 可以调用静态的成员方法
* 可以调用非静态的成员变量
* 可以调用非静态的成员方法
*
* 静态的方法中是否有this这个对象？没有的
*
*
*/
public class StaticDemo2 {
public static void main(String[] args) {
Student.comeFrom = "成都";
Student.study();
}
}
class Student {
String name;
int age;
static String comeFrom;
public static void study() {
System.out.println(name);
eat();
}
public void eat() {
System.out.println("eat");
System.out.println(comeFrom);
}
}
三、静态的优缺点
1、静态优点:
对对象的共享数据提供单独空间的存储，节省空间，没有必要每一个对象都存储一份可以直接被类名调用,不用在堆内存创建对象
静态成员可以通过类名直接访问,相对创建对象访问成员方便
2、静态弊端:
访问出现局限性。（静态虽好，但只能访问静态）
四、静态应用
Math类使用：
1、Math 类包含用于执行基本数学运算的方法。数学操作常用的类。
2、Math类的构造方法被private,无法创建对象,也就无法通过对象来访问Math类中的成员
3、Math类中所有的成员都被静态修饰,因此我们可以直接通过类名访问
案例代码
package com.test;
public class MathDemo {
public static void main(String[] args) {
//Math:包含了一些基本的数学运算方法
//static double PI
//System.out.println(Math.PI);
//static double abs(double a) //返回绝对值
//System.out.println(Math.abs(15));
//System.out.println(Math.abs(-10));
//static double ceil(double a) //天花板 向上取整
//System.out.println(Math.ceil(1.2));
//System.out.println(Math.ceil(1.6));
//static double floor(double a) //地板 向下取整
//System.out.println(Math.floor(1.2));
//System.out.println(Math.floor(1.6));
//static long round(double a) //四舍五入
//System.out.println(Math.round(1.2));
//System.out.println(Math.round(1.6));
//static double max(double a, double b)
//System.out.println(Math.max(3, 4));
//static double pow(double a, double b) //返回第一个参数的第二个参数次幂
//System.out.println(Math.pow(3, 2));
//static double random() //返回一个随机数，大于零且小于一
System.out.println(Math.random());
}
}
自定义工具类:
需求:自定义一个专门对数组操作的工具类,具有的功能如下
1、定义一个方法,该方法可以返回数组中最大元素
2、定义一个方法,该方法根据指定的值去数组中查找是否存在该值
存在,返回该值在数组中的索引
不存在,返回-1
案例代码
package com.test;
public class MyArrays {
private MyArrays() {}
/*
* 返回数组中最大的元素
*/
public static int getMax(int[] arr) {
int max = 0;//参照物
//遍历数组
for(int x = 0;x < arr.length;x++) {
if(arr[x] > max) {
max = arr[x];//替换参照物
}
}
return max;
}
/*
* 返回数组中指定参数的索引
*/
public static int getIndex(int[] arr,int a) {
//遍历数组
for(int x = 0;x < arr.length;x++) {
if(arr[x] == a) {
return x;
}
}
return -1;//如果查不到制定的参数，则返回-1
}
}
package com.test;
public class MyArraysDemo {
public static void main(String[] args) {
int[] arr = {3,5,8,10,2};
int max = MyArrays.getMax(arr);
System.out.println(max);
int index = MyArrays.getIndex(arr, 8);
System.out.println(index);
}
}
五、类变量与实例变量分析
1、类变量:其实就是静态变量
定义位置:定义在类中方法外
所在内存区域:方法区
生命周期:随着类的加载而加载
特点:无论创建多少对象,类变量仅在方法区中,并且只有一份
2、实例变量:其实就是非静态变量
定义位置:定义在类中方法外
所在内存区域:堆
生命周期:随着对象的创建而加载
特点:每创建一个对象,堆中的对象中就有一份实例变量
代码案例
package com.test
public class Classmate {
static String name = "张三"; //被static修饰，是类变量
public int age = 18; //实例变量
}
class Print {
public static void main(String[] args) {
Classmate classmateA = new Classmate();
classmateA.name = "李四";
classmateA.age = 21;
//实例变量被修改后的值
System.out.println(classmateA.name+"..."+classmateA.age);
Classmate classmateB = new Classmate();
//name为类变量，已经被更改，int为实例对象，沿用classmate原本的值
System.out.println(classmateB.name+"..."+classmateB.age);
}
}
六、代码块
1、局部代码块：
局部代码块是定义在方法或语句中。
案例代码
package com.test;
public class BlockDemo {
public static void main(String[] args) {
//局部代码块：存在于方法中，控制变量的生命周期（作用域）
{
for(int x = 0;x < 10;x++) {
System.out.println("我爱Java");
}
int num = 10;
}
//System.out.println(num);//无法访问num,超出num的作用域范围
}
}
2、构造代码块：
构造代码块是定义在类中成员位置的代码块。
案例代码
class Teacher {
String name;
int age;
{
for(int x = 0;x < 10;x++) {
System.out.println("我是Java");
}
System.out.println("我是Java");
}
public Teacher() {
System.out.println("我是无参空构造");
}
public Teacher(String name,int age) {
System.out.println("我是有参构造");
this.name = name;
this.age = age;
}
}
3、静态代码块：
静态代码块是定义在成员位置，使用static修饰的代码块。
案例代码
class Teacher {
String name;
int age;
//静态代码块：随着类的加载而加载，只加载一次，加载类时需要做的一些初始化，比如加载驱动
static {
System.out.println("我是Java");
}
public Teacher() {
System.out.println("我是无参空构造");
}
public Teacher(String name,int age) {
System.out.println("我是有参构造");
this.name = name;
this.age = age;
}
}
4、每种代码块特点:
4.1 局部代码块:
以”{}”划定的代码区域，此时只需要关注作用域的不同即可
方法和类都是以代码块的方式划定边界的
4.2 构造代码块：
优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
每创建一个对象均会执行一次构造代码块。
4.3 静态代码块：
它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
该类不管创建多少对象，静态代码块只执行一次。
可用于给静态变量赋值，用来给类进行初始化。
案例代码
package com.test;
/*
* Coder静态代码块执行 --- Coder构造代码块执行 --- Coder无参空构造执行
*
* BlockTest静态代码块执行 --- BlockTest的主函数执行了 --- Coder静态代码块执行 --- Coder构造代码块执行 --- Coder无参空构造执行
* Coder构造代码块执行 --- Coder无参空构造执行
*
*/
public class BlockTest {
static {
System.out.println("BlockTest静态代码块执行");
}
{
System.out.println("BlockTest构造代码块执行");
}
public BlockTest(){
System.out.println("BlockTest无参构造执行了");
}
public static void main(String[] args) {
System.out.println("BlockTest的主函数执行了");
Coder c = new Coder();
Coder c2 = new Coder();
}
}
class Coder {
static {
System.out.println("Coder静态代码块执行");
}
{
System.out.println("Coder构造代码块执行");
}
public Coder() {
System.out.println("Coder无参空构造执行");
}
}
扫一扫
336
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
