Java static
- static 特点
- static是一个修饰符，用于修饰成员。
- static修饰的成员被所有的对象所共享。
- static修饰的数据是共享数据，对象中的存储的是特有数据。
- static优先于对象存在，因为static的成员随着类的加载就已经存在了。
- static修饰的成员多了一种调用方式，就可以直接被类名所调用 。类名.静态成员 。
-
使用注意事项:
1，静态方法只能访问静态，静态有访问局限性。
2，静态方法中不能有this super关键字。
3，主函数是静态的。 -
何时使用静态变量
- 对象中所具备的成员变量的值都是相同的 ，可以用static修饰，让多个对象共享。
- 只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
函数如果访问了特有数据(非静态成员变量),该函数是非静态的。
函数如果没有访问特有数据，那么该函数就可以静态修饰。 - 如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。
- 何时使用静态函数
- 函数是否用静态修饰就参考一点，该函数功能是否有访问到对象中的特有数据。
- 简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
- 如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，
- 但是非静态需要被对象调用，而仅创建对象调用非静态的
- 没有访问特有数据的方法，该对象的创建是没有意义。
- 成员变量和静态变量的区别？
- 两个变量的生命周期不同。
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。 - 调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。 - 别名不同。
成员变量也称为实例变量。
静态变量称为类变量。 - 数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.
- 静态使用的注意事项：
- 静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)
- 静态方法中不可以使用this或者super关键字。
- 主函数是静态的。
- static 代码分析 01
代码块
1. 局部代码快。
对局部变量的生命周期进行控制。
2. 构造代码块。
对所有对象进行初始化。
3. 静态代码块。
对类进行初始化。
- 静态代码块。
随着类的加载而执行。而且只执行一次。
作用：用于给类进行初始化。
public class A_test {
static int num ;
static
{
num = 10;
System.out.println("hahahah");
}
public static void main(String args[]) {
show();
}
static {
System.out.println("hihi");
}
{
System.out.println("12345");
}
static void show()
{
System.out.println(num);
}
}
output:
hahahah
hihi
10
- 构造代码块。可以给所有对象进行初始化的。
class PersonTest
{
private String name;
{//构造代码块。可以给所有对象进行初始化的。
System.out.println("constructor code 001");
}
static
{
System.out.println("static code 001");
}
{//构造代码块。可以给所有对象进行初始化的。
System.out.println("constructor code 002");
}
static
{
System.out.println("static code 002");
}
PersonTest()//是给对应的对象进行针对性的初始化。
{
name = "baby";
cry();
}
PersonTest(String name)
{
this.name = name;
cry();
}
public void cry()
{
System.out.println("哇哇");
}
public void speak()
{
System.out.println("name:"+name);
}
static void show()
{
System.out.println("show run");
}
}
class StaticCodeTest
{
static int num ;
static
{
num = 10;
System.out.println("StaticCodeTest 001");
}
StaticCodeTest(){}
static void show()
{
System.out.println(num);
}
}
1) test01
public class AJavaTest{
public static void main(String args[]) {
PersonTest.show();
}
}
OUTPUT:
static code 001
static code 002
show run
2) test02
public class AJavaTest{
public static void main(String args[]) {
PersonTest p1 = new PersonTest();
p1.speak();
}
}
OUTPUT:
static code 001
static code 002
constructor code 001
constructor code 002
哇哇
name:baby
执行顺序： 初始化静态模块代码 -> 初始化代码块 -> 初始化对象 -> 调用函数
3) test03
public class AJavaTest{
public static void main(String args[]) {
PersonTest p2 = new PersonTest("旺财");
p2.speak();
}
}
OUTPUT:
static code 001
static code 002
constructor code 001
constructor code 002
哇哇
name:旺财
4) test04
public class AJavaTest{
public static void main(String args[]) {
new PersonTest();
}
}
OUTPUT:
static code 001
static code 002
constructor code 001
constructor code 002
哇哇
执行顺序：同test01
class StaticCodeTest
{
static int num ;
static
{
num = 10;
System.out.println("StaticCodeTest 001");
}
StaticCodeTest(){}
static void show()
{
System.out.println(num);
}
}
5) test05
public class AJavaTest{
public static void main(String args[]) {
new StaticCodeTest().show();
new StaticCodeTest().show();
}
}
OUTPUT:
StaticCodeTest 001
10
10
解析： static类型作为类成员变量，只初始化一次。
- static 代码分析 02
class Demo
{
int age ;
static int num = 9;
Demo(int age)
{
this.age = age;
}
public static void speak()
{
System.out.println(num);
}
public void show()
{
System.out.println(age);
}
}
class StaticDemo3
{
public static void main(String[] args)
{
Demo d = new Demo(30);
d.speak();
}
}
报错：The static method speak() from the type Demo should be accessed in a static way
分析： 访问的变量是非静态的，因此有误。
- 子父类负载静态方法
class Fu1
{
public static void show()
{
System.out.println("fu show run");
}
}
class Zi1 extends Fu1
{
public static void show()
{
System.out.println("Zi show run");
}
}
class ExtendsDemo3
{
public static void main(String[] args)
{
Zi1 z = new Zi1();
z.show();
}
}
OUTPUT:
Zi show run
注： 静态只能覆盖静态，或被静态覆盖。
网友评论