面向对象——(static关键字)

static关键字:

   用于修饰成员(成员变量和成员函数)

被修饰后的成员具备一下特点:

    1、随着类的加载而加载

     2、优先于对象存在

     3、可以被所有对象共享   :当多个对象中有一个属性都相同时,把这个属性定位static,通过对象调用属性就可共享此属性。

     4、可以直接被类名调用,不必创建对象。

使用注意:

    静态方法只能访问静态成员。

    静态方法中不能写this,super关键字。

    mian主函数是静态的。

    statice 的特点:

1、static 是修饰符,可以修饰成员和方法。

2、static修饰的成员被所有的对象所共享。

3、static优先于对象存在,因为static的成员随着类的加载就已经存在了。比如:饮水机和杯子,教室里面的饮水机随着教师的额出现而出现,而杯子是学生所特有的,教室就是类。

4、static修饰的成员多了一种调用的方式,用类名直接调用。类名.静态成员。

5、static修饰的是共享数据,对象中存储的是特有的数据。

 

成员变量和静态变量的区别:

1、两个变量的生命周期不同。

           成员变量随着对象的创建而存在,对象的被回收而释放。

           静态变量随着类加载而存在,随着类的消失而消失。

2、调用方式不同。

          成员变量只能创建对象,通过对象来调用。

        静态变量可以被对象调用,也可以被类名直接调用。 考虑内存方面,静态变量更优先选择被类调用,因为创建对象,需要开辟内存空间。

3、别名不同。

         成员变量也称为实例变量。

         静态变量称为类变量。

4、数据存储位置不同。

      成员变量数据存储在堆内存的对象中,所以也称对象的特有数据。

     静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据

 

静态方法是使用事项:

1、静态方法只能访问(使用)静态成员。非静态方法既可以访问静态,又可以访问非静态。

2、静态方法中不能存在this,或super关键字。  this指代当前对象,静态成员优先与对象执行。

3、主函数是静态的。

 


class Person
{
	String name;//成员变量,实例变量
	static String country = "CN";//静态变量。类变量 
	public  void show()
	{
		System.out.println(Person.country+":"+this.name);
	}
}


/*
static的特点:
1,static是一个修饰符,用于修饰成员。
2,static修饰的成员被所有的对象所共享。
3,static优先于对象存在,因为static的成员随着类的加载就已经存在了。 
4,static修饰的成员多了一种调用方式,就可以直接被类名所调用 。 类名.静态成员 。
5,static修饰的数据是共享数据,对象中的存储的是特有数据。

成员变量和静态变量的区别?
1,两个变量的生命周期不同。
	成员变量随着对象的创建而存在,随着对象的被回收而释放。
	静态变量随着类的加载而存在,随着类的消失而消失。

2,调用方式不同。
	成员变量只能被对象调用。
	静态变量可以被对象调用,还可以被类名调用。

3,别名不同。
	成员变量也称为实例变量。
	静态变量称为类变量。 

4,数据存储位置不同。
	成员变量数据存储在堆内存的对象中,所以也叫对象的特有数据.
	静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据.



静态使用的注意事项:
1,静态方法只能访问静态成员。(非静态既可以访问静态,又可以访问非静态)
2,静态方法中不可以使用this或者super关键字。
3,主函数是静态的。





*/

class StaticDemo 
{
	int num = 4;
	public static void main(String[] args) 
	{
//		Person  p = new Person();
//		p.name = "小强";
//		p.show();
//		System.out.println(p.country);
//		System.out.println(Person.country);
//		Person.show();
		new StaticDemo().show();
	}

	public void show()
	{
		System.out.println(num);
	}
}

public static void main(String[ ] args)

主函数特殊之处:

    1、格式是固定的。

    2、被JVM所识别和调用

public : 因为权限必须是最大的。

static : 不需要对象的,直接用主函数所属类名调用即可。

void :主函数没有具体的返回值。

main : 函数名,不是关键字,只是JVM识别的固定的名字。

String[ ] args :这是主函数的参数列表,是一个数组类型的参数,而且元素都是字符串类型。

/*
public static void main(String[] args) 

主函数特殊之处:
1,格式是固定的。
2,被jvm所识别和调用。

public:因为权限必须是最大的。
static:不需要对象的,直接用主函数所属类名调用即可。
void:主函数没有具体的返回值。
main:函数名,不是关键字,只是一个jvm识别的固定的名字。
String[] args:这是主函数的参数列表,是一个数组类型的参数,而且元素都是字符串类型。

*/

class MainDemo 
{
	public static void main(String[] args) //new String[0]
	{
		/**/
//		System.out.println(args);//[Ljava.lang.String;@c17164
		System.out.println(args.length);
		for(int x=0; x

静态什么时候用?
1,静态变量。
    当分析对象中所具备的成员变量的值都是相同的 。
    这时这个成员就可以被静态修饰。
    只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的。
    如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的。

2,静态函数。
    函数是否用静态修饰,就参考一点,就是该函数功能是否有访问到对象中的特有数据。
    简单点说,从源代码看,该功能是否需要访问非静态的成员变量,如果需要,该功能就是非静态的。
    如果不需要,就可以将该功能定义成静态的。当然,也可以定义成非静态,
    但是非静态需要被对象调用,而仅创建对象调用非静态的
    没有访问特有数据的方法,该对象的创建是没有意义。

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();
		Demo.speak();

//		System.out.println("Hello World!");
	}
}

    static 静态代码块

随着类的加载而执行(首先执行static静态代码块),而且只执行一次。

作用:用于给类进行初始化。

class StaticCode
{
	static int num ;
	static 
	{
		num = 10;
//		num *=3;
		System.out.println("hahahah");
	}
	StaticCode(){}

	static void show()
	{
		System.out.println(num);
	}
}

class Person
{
	private String name;
	
	

	{//构造代码块。可以给所有对象进行初始化的。

		System.out.println("constructor code ");
//		cry();
	}
	
	static 
	{
		System.out.println("static code");
	}
	
	Person()//是给对应的对象进行针对性的初始化。 
	{
		name = "baby";
//		cry();
	}
	Person(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 StaticCodeDemo 
{
	static
	{
//		System.out.println("a");
	}
	public static void main(String[] args) 
	{


	}
}

 

构造代码块:

在创建对象的时候,给对象赋初始值。

构造代码块与构造函数的区别:

构造代码块,只要一创建对对象,就会调用执行。构造函数是针对特定的对象,进行初始化。

class StaticCode
{
	static int num ;
	static 
	{
		num = 10;
//		num *=3;
		System.out.println("hahahah");
	}
	StaticCode(){}

	static void show()
	{
		System.out.println(num);
	}
}

class Person
{
	private String name;
	
	

	{//构造代码块。可以给所有对象进行初始化的。

		System.out.println("constructor code ");
    	cry();
	}
	
	static 
	{
		System.out.println("static code");
	}
	
	Person()//是给对应的对象进行针对性的初始化。 
	{
		name = "baby";
//		cry();
	}
	Person(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 StaticCodeDemo 
{
	static
	{
//		System.out.println("a");
	}
	public static void main(String[] args) 
	{
      Person P1=new Person();
	  P1.speak();
	  Person p2=new Person("张三");
	  p2.speak();

	}
}

运行结果:

面向对象——(static关键字)_第1张图片

构造代码快总是先执行。

面试题:静态代码块、构造函数、构造代码块的执行顺序。

答案: 静态代码块——>构造代码块——>构造函数。

你可能感兴趣的:(Java)