java中类中的方法调用对象 java类中的方法

转载

智慧编织者 2023-09-19 08:02:02

文章标签 java中类中的方法调用对象 java 开发语言后端实例方法 文章分类 Java 后端开发

1.类中的方法

（1）实例方法

格式：访问限制修饰符方法的返回值数据类型方法名称(参数列表){方法体}

解释：

访问限制修饰符------public / 缺省的
方法的返回值数据类型------就是方法的执行结果类型

有返回值时，方法的返回值数据类型一定是方法执行结果的具体类型；

方法的返回值类型可以是基本类型，也可以是复合数据类型；

最后一句话一定要是return xxx;

Xxx不能直接写数据类型的符号，写变量的名称或者值

没有返回值时，方法的返回值类型使用void代替。

方法名称------合法的标识符【首字母小写，从第二个单词开始首字母大写】
（参数列表）------用来接收方法之外的数据进入本方法参与运算【找帮手】

参数实际上是变量，在这没有初始值，属于局部变量【数据类型变量名称】

参数列表可以没有，就是空的（），也可以有多个，多个参数之间用“,”

方法体------编写具体实现过程的地方，具体执行代码

例：

public class ShiLiFangFa {
		//没有返回值，没有参数的实例方法，用void代替返回值
		public void method1(){
			
		}
		//访问限制符也可以缺省，没有返回值，有一个int参数的实例方法
		void method2(int a){
			
		}
		//访问限制符也可以缺省
		//方法返回值类型是基本类型，最后一句话一定是return xxx;
		//返回值为int，没有参数的实例方法
		int method3(){
			return 100;
		}
		//返回值为double，有参数的实例方法
		public double method4(double num){
			System.out.println("返回值为double型，有一个double型参数的实例方法");
			return num;
		}
		//返回值为int，有2个参数的实例方法
		public int method5(int num1,int num2){
			System.out.println("返回值为int型，有2个int型参数的实例方法");
			return num1+num2;//返回值类型要和前面相符合
		}
		//错误，返回值为int型，但是return后的类型是double型，精度比int高
		/*	
		 	public int method6(int num1,double num2){
			System.out.println("");
			return num1+num2;
			}
		*/
		//改正方法，强制类型转换
	 	public int method6(int num1,double num2){
		System.out.println("");
		return (int)(num1+num2);
		}
	 	//修饰的返回值为字符数组的有一个参数的实例方法
	 	public char[] chararray(int size){
	 		char chararray[]=new char[size];
	 		return chararray;
	 	}
}

（2）静态方法【类方法】

static关键字修饰的实例方法就是静态方法【类方法】

格式：

访问限制修饰符 static方法的返回值数据类型方法名称(参数列表){方法体}

例：

public class JingTaiFangFa {

      //没有返回值，没有参数的静态方法，用void代替返回值

      public static void method1(){

         

      }

      //访问限制符也可以缺省，没有返回值，有一个int参数的静态方法

      static void method2(int a){

         

      }

      //访问限制符也可以缺省

      //方法返回值类型是基本类型，最后一句话一定是return xxx;

      //返回值为int，没有参数的静态方法

      static int method3(){

          return 100;

      }

      //返回值为double，有参数的静态方法

      public static double method4(double num){

          System.out.println("返回值为double型，有一个double型参数的静态方法");

          return num;

      }

      //返回值为int，有2个参数的静态方法

      public static int method5(int num1,int num2){

          System.out.println("返回值为int型，有2个int型参数的静态方法");

          return num1+num2;//返回值类型要和前面相符合

      }

      //错误，返回值为int型，但是return后的类型是double型，精度比int高

      /*

         public static int method6(int num1,double num2){

          System.out.println("");

          return num1+num2;

          }

      */

      //改正方法，强制类型转换

      public static int method6(int num1,double num2){

      System.out.println("");

      return (int)(num1+num2);

      }

      //修饰的返回值为字符数组的有一个参数的静态方法

      public static char[] chararray(int size){

         char chararray[]=new char[size];

         return chararray;

      }

}

（3）实例方法和静态方法【类方法】区别

实例方法没有static关键字，静态方法【类方法】有static关键字
实例方法只能用对象访问，静态方法可以对象访问，也可以类名访问
实例方法只在方法调用时分配运行空间，静态方法在方法调用前已经分配好运行空间

测试类：

public class TestMain { 

   public static void main(String[] args) {    

      //测试实例方法访问

      //创建ShiLiFangFa类对象

      ShiLiFangFa slff=new ShiLiFangFa();

      //实例方法只能对象访问

      slff.method1();

      slff.method2(2);

      slff.method3();

      slff.method4(1.0);

      slff.method5(5,5);

      slff.method6(6,6);

      //ShiLiFangFa.method1();类名访问报错



     //测试静态方法访问

      //创建JingTaiFangFa对象

      JingTaiFangFa jtff=new JingTaiFangFa();

      //静态方法【类方法】可以对象访问，也可以类名访问

      jtff.method1();

      JingTaiFangFa.method1();

   }

}

（4）构造方法

去掉方法的返回值数据类型，方法的名称是类名这种方法就是构造法。

格式:访问限制修饰符类名(参数列表){方法体}

构造方法的作用就是为了创建对象用的。
我们创建好一个java类之后，默认类体中就有一个默认的无参数构造方法存在，只是没有显示出来
当类中出现的有参数的构造方法时，默认无参数的构造方法会被覆盖，此时我们如果需要无参数的构造方法时，就需要手动给出无参数构造方法，显示出来。

例：

public class GouZaoFangFa {

   public GouZaoFangFa(){

      System.out.println("无参数构造方法");

   }

   //当类中出现的有参数的构造方法时，默认无参数的构造方法会被覆盖，

   //此时我们如果需要无参数的构造方法时，就需要手动给出无参数构造方法

   public GouZaoFangFa(String name){

      System.out.println("有参数构造方法");

   }

}

2.方法重载

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

方法重载与方法的返回值数据类型没有关系，与方法的参数有关；

方法的名称相同，方法的参数个数、参数类型不同

例：

public class FangFaChongZai {

   //实例方法重载

   public void method1(){}

   public int method1(int num){return 100;}

   public char method1(int num,char ch){return 'a';}

   public char method1(char ch,int num){return 'a';}

  

   //静态方法重载

   public static void staticmethod1(){}

   public static int  staticmethod1(int num){return 100;}

   public static char staticmethod1(int num,char ch){return 'a';}

   public static char staticmethod1(char ch,int num){return 'a';}

   //构造方法重载

   public FangFaChongZai(){}

   public FangFaChongZai(String name){}

   public FangFaChongZai(int age){}

}

3. 同一个类中方法与变量的调用关系

类中包含两个基本元素------变量和方法

（1）构造方法与变量调用关系

构造方法可以访问实例变量，静态变量【类变量】，局部变量

构造方法访问实例变量：默认this.实例变量，this可以被省略。

构造方法访问类变量：默认类名.类变量，也可以this.类变量，类名和this都可以被省略

构造方法访问局部变量：直接变量名称

（2）实例方法与变量调用关系

实例方法中：可以访问实例变量，类变量，局部变量

实例方法中访问实例变量: 默认this.实例变量, this可以被省略。

实例方法中访问类变量: 默认类名.类变量, 也可以this.类变量, 类名/this可以被省略

实例方法中访问局部变量: 直接变量名称

（3）静态方法与变量调用关系

静态方法中:可以访问类变量，局部变量，不可以访问实例变量

静态方法中访问类变量: 默认类名.类变量, 类名可以被省略

静态方法中不能有this

静态方法中访问局部变量: 直接变量名称

例：

//同一个类中方法里面调用变量 java程序=对象+消息

public class FangFaGetBianLiang {

   //实例变量

   public int number=1001;

   //静态成员变量

   public static String name="zhangsan";

  

   //构造方法访问变量

   public FangFaGetBianLiang(){

      //局部变量

      String address="西安";

      //构造方法中可以调用实例变量，默认this.实例变量,可以省略this

      System.out.println("实例变量--number="+this.number);

      System.out.println("实例变量--number="+number);

     

      //构造方法中可以调用静态成员变量

      //默认类名.静态成员变量,也可以this.静态成员变量,可以省略类名/this

      System.out.println("静态成员变量-name=" + FangFaGetBianLiang.name);

      System.out.println("静态成员变量-name=" + this.name);

      System.out.println("静态成员变量-name=" + name);

     

      //构造方法中可以调用局部变量，直接变量名称

      //System.out.println("局部变量-address="+FangFaGetBianLiang.address); 报错

      //System.out.println("局部变量-address="+this.address);报错

      System.out.println("局部变量-address=" + address);

   }

  

   // 实例方法中访问变量

   public void testMethod() {

      // 局部变量

      String address = "西安"; 

      // 实例方法中可以调用实例变量，默认this.实例变量,可以省略this

      System.out.println("实例变量-number=" + this.number);

      System.out.println("实例变量-number=" + number);

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

      System.out.println("静态成员变量-name=" + FangFaGetBianLiang.name);

      System.out.println("静态成员变量-name=" + this.name);

      System.out.println("静态成员变量-name=" + name);

      // 实例方法中可以调用局部变量,局部变量名称访问

      // System.out.println("局部变量-address="+FangFaGetBianLiang.address);

      // System.out.println("局部变量-address="+this.address);

      System.out.println("局部变量-address=" + address);

   }

  

   // 静态方法方法中访问变量

   public static void testStatic() {

      // 局部变量

      String address = "西安";

      // 静态方法方法中不可以调用实例变量

      //System.out.println("实例变量-number=" + this.number);

      //System.out.println("实例变量-number=" + number);

      // 静态方法中可以调用静态成员变量，默认类名.静态成员变量,可以省略类名

      System.out.println("静态成员变量-name=" + FangFaGetBianLiang.name);

      // 静态方法中不能出现this

      //System.out.println("静态成员变量-name=" + this.name);

      System.out.println("静态成员变量-name=" + name);

      // 静态方法中可以调用局部变量,局部变量名称访问

      // System.out.println("局部变量-address="+FangFaGetBianLiang.address);

      // System.out.println("局部变量-address="+this.address);

      System.out.println("局部变量-address=" + address);

   }

}

测试类：

public class TestMain { 

   public static void main(String[] args) {

     //测试构造方法访问变量

FangFaGetBianLiang ffgbl=new FangFaGetBianLiang();

     ffgbl.testMethod();

     FangFaGetBianLiang.testStatic();

   }

}

4. 同一个类中方法与方法的调用关系

（1）构造方法与方法调用关系

构造方法可以访问实例方法，静态方法【类方法】，其他实例方法

构造方法访问实例方法：默认this.实例方法，this可以被省略。

构造方法访问类方法：默认类名.类方法，也可以this.类方法，类名和this都可以被省略

构造方法访问构造方法：new 构造方法；

（2）实例方法与方法调用关系

实例方法中：可以访问实例方法，类方法，构造方法

实例方法中访问实例方法: 默认this.实例方法, this可以被省略。

实例方法中访问类方法: 默认类名.实例方法, 也可以this.类方法, 类名/this可以被省略

实例方法中访问构造方法: new 构造方法

（3）静态方法与方法调用关系

静态方法中:可以访问其他类方法，不可以访问实例方法

静态方法中访问类方法: 默认类名.类方法, 类名可以被省略

静态方法中不能有this

静态方法中访问构造方法: new 构造方法

总结：

静态的都不能访问实例的，因为静态内存分配实际早于实例内存分配，静态访问实例的时候，实例还不存在。

静态不能使用this：

例：

public class FangFaGetFangFa {

   //构造方法中访问方法

      public FangFaGetFangFa(){

          System.out.println("无参数构造方法");

          //构造方法中可以访问其他的构造方法，new+构造方法

          new FangFaGetFangFa("hello");

          //构造方法中可以访问实例方法,默认this.实例方法，可以省略this

          this. testMethod1();

          testMethod1();

          //构造方法中可以访问静态方法,默认类名.静态方法,也可以this.静态方法，可以省略类名/this

          FangFaGetFangFa.staticMethod1();

          this.staticMethod1();

          staticMethod1();

      }

     

   //有参数的构造方法

      public FangFaGetFangFa(String name){

          System.out.println("有参数构造方法-参数name="+name);

      }

     

   //实例方法

      public  void  testMethod1(){

          //实例方法中可以访问构造方法,new+构造方法

          new FangFaGetFangFa("hello");

          new FangFaGetFangFa();

          //实例方法中可以访问其他的实例方法,默认this.实例方法，可以省略this

          this.testMethod2();

          testMethod2();

          //实例方法中可以访问静态方法,默认类名.静态方法,可以this.静态方法，可以省略类名/this

          FangFaGetFangFa.staticMethod1();

          this.staticMethod1();

          staticMethod1();

      }

     

      public  void  testMethod2(){

          System.out.println("实例方法");

      }

  

   //静态方法访问方法

      public static  void  staticMethod1(){

          //静态方法中可以访问构造方法，new+构造方法();

          new FangFaGetFangFa("hello");

          //静态方法中不能访问实例方法

          //testMethod2();

          //静态方法中不能出现this

          //this.testMethod2();

          //静态方法中能访问其他的静态方法,默认类名.静态方法,可以省略类名

          FangFaGetFangFa.staticMethod2();

          staticMethod2();

      }

     

      public static  void  staticMethod2(){

          System.out.println("静态方法");

      }

}

最后总结：

java中类中的方法调用对象 java类中的方法_java中类中的方法调用对象