java--面向对象（static关键字、main、静态什么时候使用、静态代码块、对象的初始化过程）

一：static关键字：

package a;


class person{
	String name;
	String country="CN";
	public void show(){
		System.out.println(name+"::"+country);
	}
}
public  class a{
	
	public static void main(String [] args)
	{
		person p=new person();
		p.name="zhangsan";
		p.show();
	}
}

控制台输出结果：
zhangsan::CN

/*
 * 静态：static
 * 用法：是一个修饰符，用于修士成员（成员变量，成员函数）。
 * 党成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外,
 * 还可以直接被类名调用，写法格式是：  类名.静态成员
 */

//样例一：

package a;
class person{
	String name;
	static String country="CN";
	public void show(){
		System.out.println(name+"::"+country);
	}
}
public  class a{
	
	public static void main(String [] args)
	{
		person p=new person();
		System.out.println(p.country);
		
		//System.out.println(person.country);
	}
}
/*
 控制台输出结果：
 CN
  
 */


//样例二：
/*
package a;
class person{
	String name;//成员变量，实例变量
	static String country="CN";//静态的成员变量，类变量
	public void show(){
		System.out.println(name+"::"+country);
	}
}
public  class a{
	
	public static void main(String [] args)
	{
	   System.out.println(person.country);
	}
}

控制台输出结果：
CN
 
*/

static 特点：

1.随着类的加载而加载

           也就是说静态会随着类的消而消失，说明它的生命周期最长

2.优先于对象存在

            明确一点，静态实现存在的，对象是后存在的1.

3.被对象所共享

4.可以直接被类名所调用

实例变量和类变量的区别：

1.存放位置： 类变量随着类的加载而存在于方法区中，实例对象随着类的建立而存在于堆内存中。

2.生命周期： 类变量生命周期最长，随着类的消失而消失；实例变量生命周期随着对象的消失而消失。

静态的使用注意事项：

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

            非静态方法既可以访问静态成员，也可以访问非静态成员

2.静态方法中可以定义this，super关键字

            因为静态优先于对象存在，所以静态方法中不可以出现this

（二）main：

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


主函数： 主函数是一种特殊的函数，作为程序的入口，


主函数的定义：
public：代表该函数访问权限最大
static：代表函数随着类的加载已经存在了
void：主函数没有具体的返回值
main：不是关键字，但是是一个特殊的单词，可以被识别
主函数是固定形式的、
 */

（三）静态什么时候使用：

/*
 * 什么使用静态？
 *   要从两个方面下手：
 *   因为静态修饰的有成员变量和函数。
 * 什么时候使用静态呢？
 *    当对象中出现共享数据时，（不是属性，比如两个人共用张三这个名字，这属于属性），所属的学校是属于共享数据，该数据被静态所修饰。
 *    对象中的特有数据要定义成非静态存在于堆内存中，
 * 什么时候定义静态函数呢？
 *    当功能内部没有访问
 */

静态的应用--工具类：

首先创建一个类a，然后定义主函数；再创建一个工具类aa，之后再运行a。

package a;

public class a{
	public static void main(String[] args)
	{
		int s=aa.max();
		System.out.println("max="+s);
	}
}

控制台运行结果：
max=8


//aa工具类：
package a;

public class aa 
{
              public static int max()
              {
            	  int[] arr={2,1,3,4,6,5,8,7,0};
            	  int max=0;
            	  for(int i=0;i<arr.length-1;i++)
            	  {
            		  if(arr[i]>arr[max])
            		  {
            			  max=i;
            		  }
            	  }
                  return arr[max];
              }
}

（）静态代码块：

static{

静态代码块里的执行语句。

}

特点：随着类的加载而加载，只执行一次，优先于主函数执行，用于给类初始化的。

如下：首先创建一个类a，之后再创建另一个类aa.

package a;
public class a{
		public static void main(String [] args)
		{
			new aa();
			System.out.println("over");
		}
		static 
		{
			System.out.println("b");
		}
		static
		{
			System.out.println("a");
		}
}

/*
控制台输出结果：
b
a
ss
over

*/

package a;

public class aa 
{
             static{
            	 System.out.println("ss");
             }
}