类中的方法

 一、类中的方法

        类中的方法描述事物的功能行为

1.实例方法
        格式：
             访问限制修饰符   方法返回的返回值类型   方法名称(参数列表){方法体}
        1.访问限制修饰符—public缺省【没有写】
        2.方法的返回值类型–就是方法执行结果类型
                  1.有返回值时，方法的返回值类型一定是方法执行结果的具体类型
                                           方法的返回值类型可以是基本数据类型，复合型
                                            方法体中的最后一句话一定是return  xxx;
                  2.没有返回值时，方法的返回值类型使用void代替。
        3.方法名称—合法的标识符批【首字母小写，从第二个单词开始首字母大写】
        4.(参数列表)—用来接收方法之外的数据进入本方法参与运算【找帮手】
                                参数实际上是变量，没有初始值，属于局部变量【数据类型  变量名称】 
        5.方法体—编写具体实现过程的地方。
        6.只能对象访问
例如：​​​​​

package com.wangxing.test;

/**
 * 实例方法 格式:访问限制修饰符 方法的返回值类型 方法名称(参数列表){方法体} 
 * 2.方法的返回值类型--就是方法的执行结果类型
 * 		1.有返回值时，方法的返回值类型一定是方法执行结果的具体类型 方法的返回值类型可以是基本类型，复合类型 方法体中的最后一句话一定是return xxxx;
 * 		2.没有返回值，方法的返回值类型使用void代替。
 * 3.方法名称--合法的标识符【首字母小写，从第二个单词开始首字母大写】
 * 4.(参数列表)--用来接收方法之外的数据进入本方法参与运算【找帮手】 数实际上是变量，没有初始值，属于局部变量【数据类型 变量名称】
 * 可以没有，也可以有，也可以有多个，多个参数之间用“,” 
 * 5.方法体--编写具体实现过程的地方。
 * 
 * @author 联想
 *
 */
public class shiLiFangFa {
	// 使用public限制修饰符有返回值无参数列表的实例对象
	// 有返回值时必须方法体最后return返回值
	public int method1() {
		System.out.println("有返回值无参数列表的实例对象");
		return 0;
	}

	// 使用public限制修饰符有返回值有参数的实例对象
	// 参数可以一个或者多个用,分割
	// 当返回值类型精度大于参数精度时返回的值自动转换为精度大的
	// 繁殖则报错
	public double method2(int dou) {
		System.out.println("有返回值有参数列表的实例对象dou=" + dou);
		return dou;
	}

	// 缺省的有返回值无参数的实例对象
	int method3() {
		System.out.println("缺省的有返回值有参数的实例对象");
		return 0;
	}

	// 缺省的有返回值无参数的实例对象
	int method4(short num) {
		System.out.println("缺省的有返回值有参数的实例对象num=" + num);
		return num;
	}

	//缺省的无返回值无参数的实例对象
	//没有返回值类型时使用void代替
	void method5(){
		System.out.println("缺省的无返回值无参数的实例对象");
	}
	
	//缺省的无返回值有参数的实例对象
	//没有返回值类型时使用void代替
	void method6(int num){
		System.out.println("缺省的无返回值有参数的实例对象");
	}
}

2.静态方法【类方法】
        使用static关键字修饰的实例方法就是静态方法【类方法】
        1.格式：
                访问限制修饰符   static 方法返回值类型   方法名称(参数列表){方法体}
        2.可以对象和类名访问
例如：

package com.wangxing.test;

/**
 * 静态方法 格式:访问限制修饰符 static 方法的返回值类型 方法名称(参数列表){方法体} 
 * 2.方法的返回值类型--就是方法的执行结果类型
 * 		1.有返回值时，方法的返回值类型一定是方法执行结果的具体类型 方法的返回值类型可以是基本类型，复合类型 方法体中的最后一句话一定是return xxxx;
 * 		2.没有返回值，方法的返回值类型使用void代替。 
 * 3.方法名称--合法的标识符【首字母小写，从第二个单词开始首字母大写】
 * 4.(参数列表)--用来接收方法之外的数据进入本方法参与运算【找帮手】 数实际上是变量，没有初始值，属于局部变量【数据类型 变量名称】
 * 可以没有，也可以有，也可以有多个，多个参数之间用“,” 
 * 5.方法体--编写具体实现过程的地方。
 * 
 * @author 联想
 *
 */
public class jingTaiFangFa {
	// 使用public修饰符有返回值无参数的静态方法
	public static int method1() {
		System.out.println("使用public修饰符有返回值无参数的静态方法");
		return 0;
	}

	// 使用public修饰符有返回值有参数的静态方法
	public static int method2(int num) {
		System.out.println("使用public修饰符有返回值有参数的静态方法=" + num);
		return num;
	}

	// 缺省的有返回值有参数的静态方法
	static int method3(int num) {
		System.out.println("缺省的有返回值有参数的静态方法=" + num);
		return num;
	}

	// 缺省的无返回值有参数的静态方法
	// 无返回值时使用void代替
	static void method4(int num) {
		System.out.println("缺省的无返回值有参数的静态方法=" + num);
	}

	// 缺省的无返回值无参数的静态方法
	// 无返回值时使用void代替
	static void method5() {
		System.out.println("缺省的无返回值无参数的静态方法");
	}
}

3.构造方法
        1.构造方法的作用就是为了创建对象
        2.我们创建好了一个java类之后，默认类体中就有一个默认的无参数的构造方法存在。只是没有显示出来。
       3. 格式：访问限制修饰符   类名(参数列表){方法体}
       4.只能对象访问
       5. 当类中出现的有参数的构造方法，默认无参数的构造方法会被覆盖，此时我们如果需要无参数的构造。
例如：

package com.wangxing.test;

/**
*1.构造方法的作用就是为了创建对象
*2.我们创建好了一个java类之后，默认类体中就有一个默认的无参数的构造方法存在。
*只是没有显示出来。
*3.格式：访问限制修饰符 类名(参数列表){方法体}
*4.只能对象访问
*5.当类中出现的有参数的构造方法，默认无参数的构造方法会被覆盖,
*此时我们如果需要无参数的构造方法时，就需要手动给出无参数构造方法
 * @author 联想
 *
 */
public class gouZaoFangFa {

	//这是无参数的构造函数
	public gouZaoFangFa(){
		System.out.println("这是无参数的构造函数");
	}
	//有参数的构造函数
	//当有参数的构造函数出现是覆盖无参数的构造函数
	//这是我们想要使用无参数逇构造函数需要声明无参数的构造函数
	public gouZaoFangFa(int num){
		System.out.println("有参数的构造函数="+num);
	}
	
	public gouZaoFangFa(String str){
		System.out.println("有参数的构造函数="+str);
	}
}

二、方法的重载

        在同一个类中，方法的名称相同，参数不同这种现象叫方法重载

注意:方法重载与方法的返回值类型没有关系，与方法的参数有关
方法的名称相同 ，方法的参数个数、参数类型
例如静态方法重载：

package com.wangxing.test;

/**
*在同一个类中，方法的名称相同，参数不同这种现象叫方法重载。
*注意:方法重载与方法的返回值类型没有关系，与方法的参数有关
*方法的名称相同 ，方法的参数个数、参数类型
 * @author 联想
 *
 */
public class fangFaChongZai {
	//静态方法的重载
	public static void method1() {
		System.out.println("使用public修饰符有返回值无参数的静态方法");
	}
	public static void method1(int num) {
		System.out.println("使用public修饰符有返回值无参数的静态方法="+num);
	}
}

三、同一个类中方法与变量的调用关系

        类中可以包含两个基本元素–变量和方法

1.方法里面调用变量
   构造方法中可以调用实例变量，默认this.实例变量,可以省略this
   构造方法中可以调用静态成员变量，默认类名.静态成员变量,也可以this.静态成员变量,可以省略类名/this
    构造方法中可以调用局部变量,局部变量名称访问

    实例方法中可以调用实例变量，默认this.实例变量,可以省略this
    实例方法中可以调用静态成员变量，默认类名.静态成员变量,也可以this.静态成员变量,可以省略类名/this
    实例方法中可以调用局部变量,局部变量名称访问

     静态方法中不可以调用实例变量
     静态方法中可以调用静态成员变量，默认类名.静态成员变量,可以省略类名
     静态方法中不能出现this
     静态方法中可以调用局部变量,局部变量名称访问
例如：

package com.wangxing.test;

/**
 * 同一个类中方法与变量的调用关系
 * 
 * @author 联想
 *
 */
public class guanXi {
	// 1.方法中调用变量
	// 创建实例变量和静态成员变量
	String str = "实例变量";
	static String str1 = "静态成员变量";

	// 创建构造方法
	public guanXi() {
		String str2 = "局部变量";
		// 构造方法中可以调用实例变量，默认this.实例变量,可以省略this
		System.out.println("构造方法中调用实例变量=" + str);
		System.out.println("构造方法中调用实例变量=" + this.str);
		// 构造方法中可以调用静态成员变量，默认类名.静态成员变量,也可以this.静态成员变量,可以省略类名/this
		System.out.println("构造方法中调用静态变量=" + str1);
		System.out.println("构造方法中调用静态变量=" + guanXi.str1);
		System.out.println("构造方法中调用静态变量=" + this.str1);
		// 构造方法中可以调用局部变量,局部变量名称访问
		System.out.println("构造方法中调用静态变量=" + str2);
	}

	//创建实例方法
	public void method1(){
		int int1=0;
		//实例方法中可以调用实例变量，默认this.实例变量,可以省略this
		System.out.println("实例方法中调用实例变量=" + str);
		System.out.println("实例方法中调用实例变量=" + this.str);
		// 构造方法中可以调用静态成员变量，默认类名.静态成员变量,也可以this.静态成员变量,可以省略类名/this
		System.out.println("实例方法中调用静态变量=" + str1);
		System.out.println("实例方法中调用静态变量=" + guanXi.str1);
		System.out.println("实例造方法中调用静态变量=" + this.str1);
		//实例方法中可以调用局部变量,局部变量名称访问
		System.out.println("实例造方法中调用局部变量=" +int1);
	}
	
	//创建静态方法
	public static void method2(){
		int int1=0;
		// 静态方法中不可以调用实例变量
		//System.out.println("静态方法中调用实例变量=" + str);
		//System.out.println("静态方法中调用实例变量=" + this.str);
		//静态方法中可以调用静态成员变量，默认类名.静态成员变量,可以省略类名
		//静态方法中不能出现this
		System.out.println("静态方法中调用静态变量=" + str1);
		System.out.println("静态方法中调用静态变量=" + guanXi.str1);
		//System.out.println("静态造方法中调用静态变量=" + this.str1);
		//静态方法中可以调用局部变量,局部变量名称访问
		System.out.println("静态造方法中调用局部变量="+int1);
	}
	
	
}

创建一个测试类

package com.wangxing.test;

public class testMain {
	public static void main(String args[]){
		//测试构造函数
		/*gouZaoFangFa gzff=new gouZaoFangFa();
		gouZaoFangFa gzf1=new gouZaoFangFa(12);
		gouZaoFangFa gzf2=new gouZaoFangFa("fxt");
		*/
		
		//测试方法与变量的关系
		guanXi gx=new guanXi();
		gx.method1();
		guanXi.method2();
	}
}

 2.方法中调用方法
      构造方法中可以访问其他的构造方法
      构造方法中可以访问实例方法,默认this.实例方法，可以省略this    
      构造方法中可以访问静态方法,默认类名.静态方法,也可以this.静态方法，可以省略类名/this

      实例方法中可以访问构造方法,new+构造方法
      实例方法中可以访问其他的实例方法,默认this.实例方法，可以省略this
      实例方法中可以访问静态方法,默认类名.静态方法,可以this.静态方法，可以省略类名/this

       静态方法中可以访问构造方法，new+构造方法();
       静态方法中不能访问实例方法
       静态方法中不能出现this
       静态方法中能访问其他的静态方法,默认类名.静态方法,可以省略类名
例如：

package com.wangxing.test;

/**
 * 方法里面调用方法
 * @author 联想
 *
 */
public class guanXiTow {
	//创建构造方法
	public guanXiTow(){
		System.out.println("----------------");
		//构造方法中可以访问其他的构造方法,new+构造方法
		System.out.println("无参数构造方法");
		new guanXiTow(12);
		//构造方法中可以访问实例方法,默认this.实例方法，可以省略this
		shiLi2();
		this.shiLi2();
		//构造方法中可以访问静态方法,默认类名.静态方法,也可以this.静态方法，可以省略类名/this
		jingTai2();
		guanXiTow.jingTai2();
		this.jingTai2();
	}
	//创造有参数的构造函数
	public guanXiTow(int num){
		System.out.println("有参数的构造函数="+num);
	}
	
	//创造实例方法
	void shiLi(){
		System.out.println("----------------");
		System.out.println("实例方法1");
		//实例方法中可以访问构造方法,new+构造方法
		new guanXiTow(13);
		//实例方法中可以访问其他的实例方法,默认this.实例方法，可以省略this
		shiLi2();
		this.shiLi2();
		//实例方法中可以访问静态方法,默认类名.静态方法,可以this.静态方法，可以省略类名/this
		jingTai2();
		guanXiTow.jingTai2();
		this.jingTai2();
	}
	void shiLi2(){
		System.out.println("实例方法2");
	}
	
	//创建静态方法
	static void jingTai(){
		System.out.println("----------------");
		//静态方法中可以访问构造方法，new+构造方法();
		System.out.println("无参数静态方法");
		new guanXiTow(14);
		//静态方法中不能访问实例方法
		//因为静态方法在调用之前就已经分配了存储空间，实例方法调用时才会分配
		//shiLi2();
		//this.shiLi2();
		// 静态方法中能访问其他的静态方法,默认类名.静态方法,可以省略类名
		jingTai2();
		guanXiTow.jingTai2();
		//this.jingTai2();
	}
	static void jingTai2(){
		System.out.println("静态方法2");
	}
}

测试类

package com.wangxing.test;

public class testMain {
	public static void main(String args[]){
		//测试构造函数
		/*gouZaoFangFa gzff=new gouZaoFangFa();
		gouZaoFangFa gzf1=new gouZaoFangFa(12);
		gouZaoFangFa gzf2=new gouZaoFangFa("fxt");
		*/
		//测试方法与变量的关系
		/*guanXi gx=new guanXi();
		gx.method1();
		guanXi.method2();
		*/
		//测试方法与方法的关系
		guanXiTow gxt=new guanXiTow();
		gxt.shiLi();
		guanXiTow.jingTai();
	}
}

总结:静态方法中不能访问实例元素【实例变量/实例方法】因为：静态方法是在运行时分配内存空间
         静态方法中不能出现this