静态方法与成员方法

定义方法的时候，有static和没有static有什么区别？
1.有static的方法，叫静态方法。
2.没有static的方法，叫成员方法（实例方法）。

定义静态方法的格式：

public static 返回值类型 方法名称（参数类型 参数名称）｛
		//方法体
｝

定义成员方法的格式：

public 返回值类型 方法名称（参数类型 参数名称）｛
		//方法体
｝

调用静态方法的格式：

	方法名（参数值）;		//直接调用本类当中的静态方法
	类名称.方法名（参数值）;	//调用另一个类中的静态方法

调用成员方法的格式：

	类名称 对象名 = new 类名称();    //首先创建对象
	对象名.成员方法名(参数值);       //通过对象名调用成员方法

1.如果不创建对象，那么通过类名称只能调用静态方法。
2.如果创建了对象，那么可以通过对象名调用成员方法。
3.通过对象名也可以调用静态方法，但是不推荐这么做。

public class StaticVsInstance {
	public static void main(String[] args) {
		
		method1();	//调用本类当中的静态方法
		
		//1.本类中的静态方法也可以通过类名称进行调用
		StaticVsInstance.method1();
		
		//2.调用另一个类当中的静态方法
		MyClass.method2();	
		
		//3.需要调用成员方法，就必须借助对象
		MyClass obj = new MyClass();  //一定要先创建对象
		obj.method3(); //然后才能通过对象去调用成员方法
		
		obj.method2();// 这种写法也可以，但是不推荐
		//应该以静态方式访问类型 MyClass 中的静态方法 method2（）
	}
	
	public static void method1() {
		System.out.println("静态方法method1执行");
	}
}

public class MyClass {	
	//静态方法
	public static void method2() {
		System.out.println("静态方法method2执行");
	}
	
	//成员方法（实例方法：Instance Method），没有static
	public void method3() {
		System.out.println("成员方法method3执行");
	}
}

静态方法的调用举例：

public class Cook {
	//这是一个静态方法，可以通过类名称进行调用
	public static void makeFood(String food) {
		System.out.println(food);
	}
}

public class StaticInovoke {
	public static void main(String[] args) {
		//希望调用cook这个类当中的静态方法makeFood
		//类名称.静态方法名（参数值）
		Cook.makeFood("西红柿");
	}
}

• 前言

       在Java中声明类的成员变量和方法时，可以使用static关键字把成员声明为静态成员。静态变量也叫类变量，非静态变量也叫实例变量；静态方法也叫类方法，非静态方法也叫实例方法。静态成员最主要的特点是它不属于任何一个类的对象，它不保存在任意一个对象的内存空间中，而是保存在类的公共区域中，所以任何一个对象都可以直接访问该类的静态成员，都能获得相同的数据值，修改时，也在类的公共区域进行修改。下面将介绍静态成员、包含静态方法、变量和常量，以及一些特殊的静态方法，如main方法和factory方法。

• 静态变量和常量

在Java中没有一个直接的修饰符来实现常量，而是通过静态成员变量的方式来实现的，如下代码：

public static final int x=10;
static public final int y=20;
final static public int z=40;

       static表示属于类，不必创建对象就可以使用，因为常量应该不依赖任何对象，final表示值不能改变。一般用作常量的静态成员访问权限都设置为public，因为常量应该允许所有类或对象访问。

另外需要注意的是，static可以与其他修饰符组合使用，且顺序可以任意调换。

在Java中，静态成员变量的的初始化要求在静态语句块结束之前必须完成，即Java中静态成员变量的初始化时机有两个，在声明的同时进行初始化或在静态语句中初始化。例如：

public class Sample3_14 
{
	public static final int const1=11;
	public static final int const2;
	static //静态语句
	{
		const2=22;
	}
	
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		System.out.print(const1 +" " +const2);
	}

}

• 静态成员的访问

静态成员是属于类的，因此对其访问不需要创建对象，可以使用<类名> . <静态成员名>的语法调用静态成员变量。

1、静态方法访问非静态成员

首先参考以下代码：

public class Sample3_16 
{
	static int staticVar=13;
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		System.out.println("成员变量staticVar的值为："+ staticVar +".");
	}

}

       静态成员的生命周期比非静态的长，即使访问时存在非静态成员，静态方法也不知道访问的是哪一个对象的成员，因为静态方法属于类，非静态方法属于对象，所以静态方法将不知道关于其所属类的对象信息。

       main方法之所以被定义为静态也因为如此，其只是程序开始执行的入口，不需要依赖任何对象，若要在静态方法中访问非静态成员只要使用指定特定对象的引用即可。而静态方法访问访问静态成员时，自然是任何时候都没有问题，静态成员都属于类，只要类关系存在，静态成员都将村在。

       同样的道理，在静态方法中是不能使用this预定义对象的引用的，即使其后边所操作的也是静态成员也是不行，因为this代表指向自己对象的引用，而静态方法是属于类的，不属于对象，其成功加载后，对象还不一定存在，即使存在，也不知道this指向的是哪一个对象。

2、非静态方法访问静态成员

       非静态方法访问静态成员的时候，规则就比较简单，非静态成员的生命周期被静态成员所包含，因此非静态成员存在的时候，静态成员一定存在，故非静态成员任何时候都可以访问静态成员。

public class Sample3_18 
{
	static int s=1000;
	
	//在非静态方法中调用静态成员
	public void showStatic()
	{
		System.out.println("非静态方法getStatic（）成功调用静态成员s，其值为："+Sample3_18.s);
	}
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		Sample3_18 sa=new Sample3_18();
		sa.showStatic();
	}

}

• main() 方法

       main方法是Java程序的入口方法，也就是说，程序在运行的时候，第一个执行的方法就是main方法，这个方法与其他方法有很大不同，比如方法的名字必须是main，方法必须是public static void 类型的，方法必须接收一个字符串数组的参数等等。

        因为main方法是由Java虚拟机调用的，所以必须为public，虚拟机调用main方法不需要产生任何对象，所以main方法声明为static，且不需要返回值，所以声明为void。既然是类，Java允许类不加public关键字作为约束，当然类的定义只能限制为public或者无限制关键字。为什么要这么定义，这和JVM的运行有关。main方法中还有一个输入参数，类型为String[] ，这个也是Java的规范，main方法中必须有一个入参，类型必须为String[] ,至于字符串数组的名字，这个是可以自己设定的，根据习惯，这个字符串数组的名字一般和Sun Java规范范例main的参数名保持一致，取名为args。而main方法不准抛出异常，因此main方法中的异常要么处理要么不处理，不能继续抛出。

        当一个类中由main方法时，则执行命令“Java 类名” 则会启动虚拟机执行该类中的main方法，由于JVM在运行这个Java程序的时候，首先会调用main方法，调用时不实例化这个类的对象，而是通过类名直接调用，因此需要限制其为public static。

• Factory 方法

       Java的静态方法有一种常见的用途，就是使用 Factory方法产生不同风格的对象，例如NumberFormat类使用 Factory方法产生不同风格的格式对象。 Factory Method是最常用的模式了，Factory方法在Java程序系统中可以说是随处可见。Factory方法就相当于创建实例对象的new，我们经常要根据类 Class生成实例对象，如A a= new A( )， Factory Method也是用来创建实例对象的，所以以后new时可以考虑实用工厂模式,虽然这样做，可能多做一些工作，但会给系统带来更大的可扩展性和尽量少的修改量。
下面以类 Sample为例，如果要创建 Sample的实例对象。
Sample sample-new Sample();

       但实际情况是，通常用户都要在创建 sample实例时做初始化的工作，例如赋值、查询数据库等。首先想到的是，可以使用 Sample I的构造函数，这样生成实例就写成:
Sample sample- new Sample(参数)

       但是，如果创建 sample实例时所做的初始化工作不是像赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那么代码就很难看了。初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有悖于Jaa面向对象的原则的，面向对象的封装( Encapsulation)和分派( Delegation)告诉我们，尽量将长的代码“切割”成段，将每段再“封装”起来(减少段和段之间耦合性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。

        所以，首先需要将创建实例的工作与使用实例的工作分开，也就是说，让创建实例所需要的大量初始化工作从 Sample的构造函数中分离出去。这时就需要使用 Factory方法来生成对象了，不能再用上面的" new Sample(参数) "了。还有，如果 Sample有个继承如 MySample，如按照面向接口编程，则需要将 Sample抽象成一个接口。现在 Sample是接口，有两个子类 MySample和 HisSample，要实例化它们：
（1） Sample mysample=new Mysample();

（2）Sample hissample=new Hissample();

       上面所示的 Sample类可能还会“生出很多儿子出来”(继承)，那么要对这儿子一个个实例化，而且可能还要对以前的代码进行修改，加入到后来生出的儿子的实例中下面是一个简单的 Factory例子：
 

interface Fruit
{
	void plant();//种植
	void grow();//生长
	void harvest();//收割
}

class Apple implements Fruit
{
	private int treeAge;
	public void plant()
	{
		System.out.println("苹果已种植");
	}
	public void grow()
	{
		System.out.println("苹果正在生长中。。。。");
	}
	public void harvest()
	{
		System.out.println("苹果已经收获");
	}
	
	public void setTreeAge(int treeAge)//设置树的年龄
	{
		this.treeAge=treeAge;
	}
}

class AppleGardeber
{
	public static Apple factory()
	{
		Apple f=new Apple();
		System.out.println("水果工厂成功创建一个水果：苹果！");
		return f;
	}
}

public class Sample3_20 
{
	private void test()
	{
		Apple a=AppleGardeber.factory();
	}
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		Sample3_20 test=new Sample3_20();
		test.test();
	}

}

       在上面的例子中，苹果实现了水果接口。苹果的生产由专门的苹果Factory负责，这样，在不涉及苹果的具体子类的情况下，达到了封装效果，也减少了错误；

静态方法只能访问静态成员是常见的java知识点，这个知识点是针对于静态方法在本类中只能直接访问静态成员，而不能访问直接访问非静态成员变量。
原因：
静态的内容是随着类的加载而加载，所以当类加载时，静态方法和静态成员是先进入内存的，而此时的非静态成员变量是不在内存里的，因此静态方法找不到其他非静态成员。

例子：
1.静态方法访问静态成员和非静态成员时：

2.创建本类对象访问（即非静态成员变量也加载时）:

由此也可以看出静态内容是比其他非静态内容先进入内存的。