Java_方法(函数)

Posted 小企鹅推雪球!

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java_方法(函数)相关的知识，希望对你有一定的参考价值。

文章目录

Java_方法

方法的概念

  1. 方法(method、函数): 是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。在Java中,方法是语句的集合,方法是解决一类问题的步骤的有序组合
  2. 方法包含于类或者对象中,同时方法在程序中被创建,在其他地方被引用

方法的优点

  1. 方法使程序简洁清晰,有利于程序的维护
  2. 使用方法提高了代码的重用性,提高了程序开发效率

方法的命名规则

  1. 方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。
  2. 定义方法名要做到见名知意

方法的定义:

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

public class Person{
	private int age;
		public int getAge() { //声明方法getAge()
		return age;
	}
	public void setAge(int i) { //声明方法setAge
		age = i; //将参数i的值赋给类的成员变量age
	}
}
  1. 方法包含方法头和方法体,
  2. 修饰符：public,private, protected等,告诉编译器如何调用该方法。定义了该方法的访问类型。
  3. 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型,有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。
  4. 方法名:是方法的实际名称。方法名和参数名。属于标识符，命名时遵循标识符命名规则和规范，“见名知意
  5. 参数类型: 参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。
    参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
  6. 方法体：方法体包含具体的语句，定义该方法的功能。

方法调用:

  1. Java 支持两种调用方法的方式，根据方法是否返回值来选择。
  2. 方法通过方法名调用,且方法只有被调用才会执行
public class TestMax {
   /** 主方法 */
   public static void main(String[] args) {
      int i = 5;
      int j = 2;
      int k = max(i, j);
      System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
   }
 
   /** 返回两个整数变量较大的值 */
   public static int max(int num1, int num2) {
      int result;
      if (num1 > num2)
         result = num1;
      else
         result = num2;
 
      return result;
   }
}

Java_方法的使用注意

  1. 方法被调用一次,就会执行一次
  2. 在没有具体返回值的情况,返回值类型用关键字void表示,那么方法体中可以不必使用return,如果使用return,仅用来结束方法
  3. 定义方法时,方法的结果应该返回给调用者,交由调用者处理
  4. 方法中只能调用方法或属性,不可以在方法内部定义方法

Java_void关键字

  1. 下列方法是个void类型的方法,没有返回值
  2. 一个一个void方法的调用一定是一个语句。 所以， printGrade(78.5);在main方法语句形式调用。就像任何以分号结束的语句一样。
public class TestVoidMethod {
  public static void main(String[] args) {
    printGrade(78.5);
  }
 
  public static void printGrade(double score) {
    if (score >= 90.0) {
       System.out.println('A');
    }
    else if (score >= 80.0) {
       System.out.println('B');
    }
    else if (score >= 70.0) {
       System.out.println('C');
    }
    else if (score >= 60.0) {
       System.out.println('D');
    }
    else {
       System.out.println('F');
    }
  }
}

Java_方法的重载

  1. 重载的概念:在同一个类中,允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
  2. 重载的特点:与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

重载方法的实例

package com.company;
public class PrintStream {
	public static void print(int i) {
		
	}
	public static void print(float f) {……}
	public static void print(String s) {……}
	public static void main(String[] args) {
		print(3);
		print(1.2f);
		print("hello!");
	}
}

Java_构造器（构造方法）

构造器的特征：

  1. 构造器具有与类相同的名称
  2. 构造器不声明返回值类型。（与声明为void不同）
  3. 构造器不能被static、final、synchronized、abstract、native修饰，不能有
    return语句返回值

构造器的作用：创建对象；给对象进行初始化

构造器的语法格式：修饰符 类名 (参数列表) { 初始化语句； }

package com.company;
public class Java_GouZaoQi_test_01 {
    private int legs;
    // 构造器
    public Java_GouZaoQi_test_01() {
        legs = 4;
        System.out.println("构造器中的:"+legs);
    }
    public void setLegs(int i) {
        legs = i;
        System.out.println("我们传入的:"+i);
    }
    public int getLegs() {
        return legs;
    }
    public static void main(String[] args) {
        Java_GouZaoQi_test_01 j = new Java_GouZaoQi_test_01();
        j.setLegs(5);
    }
}

运行结构

构造器的分类：

  1. 隐式无参构造器（系统默认提供）
  2. 显式定义一个或多个构造器（无参、有参）

构造器的注意要点：

  1. Java语言中，每个类都至少有一个构造器
  2. 默认构造器的修饰符与所属类的修饰符一致
  3. 一旦显式定义了构造器，则系统不再提供默认构造器
  4. 一个类可以创建多个重载的构造器
  5. 父类的构造器不可被子类继承

Java_构造器的重载

  1. 构造器一般用来创建对象的同时初始化对象
  2. 构造器重载使得对象的创建更加灵活，方便创建各种不同的对象
package com.company;

public class Java_GouZaoQi_02 {

    public Java_GouZaoQi_02() {
        String name = "Java";
        int age = 100;
        System.out.println("无参数构造器:name="+name );
        System.out.println("无参数构造器:age="+age );
    }
    public Java_GouZaoQi_02(String n , int a){
        String name;
        int age;
        name=n; age=a;
        System.out.println("有参数构造器:name="+name );
        System.out.println("有参数构造器:age="+age );
    }
    public static void main(String[] args) {
        String n = "dahj";
        int a = 100;
        Java_GouZaoQi_02 j1 = new Java_GouZaoQi_02();
        Java_GouZaoQi_02 j2 = new Java_GouZaoQi_02(n,100);

    }

}

运行结果

Java_属性赋值过程

  1. 默认初始化
  2. 显式初始化
  3. 构造器中初始化
  4. 通过“对象.属性“或“对象.方法”的方式赋值

Java_JavaBean

  1. JavaBean是一种Java语言写成的可重用组件。

所谓javaBean，是指符合如下标准的Java类：

  1. 类是公共的
  2. 有一个无参的公共的构造器
  3. 有属性，且有对应的get、set方法
  4. 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以
    用Java代码创造的对象进行打包
  5. 可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关
    心任何改变。

JavaBean样例

	package com.company;
	
	public class Java_JavaBean_01 {
	    private String name; // 属性一般定义为private
	    private int age;
	    public Java_JavaBean_01() {
	    }
	    public int getAge() {
	        return age;
	    }
	    public void setAge(int a) {
	        age = a;
	    }
	    public String getName() {
	        return name;
	    }
	    public void setName(String n) {
	        name = n;
	    }
	}

Java_this简介

  1. 在Java中：this在方法内部使用，即这个方法所属对象的引用；
  2. 在Java中：this在构造器内部使用，表示该构造器正在初始化的对象
  3. this 可以调用类的属性、方法和构造器
  4. 当在方法内需要用到调用该方法的对象时，就用this。
  5. 我们可以用this来区分属性和局部变量。比如：this.name = name;

Java_this使用情况

  1. 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性,不过，通常我们都习惯省略this。
  2. 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量
  3. 使用this访问属性和方法时，如果在本类中未找到，会从父类中查找
  4. 当前正在操作本方法的对象称为当前对象。

this样例一

class Person{ // 定义Person类
    private String name ;
    private int age ;
    public Person(String name,int age){
        this.name = name ;
        this.age = age ; }
    public void getInfo(){
        System.out.println("姓名：" + name) ;
        this.speak();
    }
    public void speak(){
        System.out.println("年龄:" + this.age);
    }
}

this样例二

package com.company;

class Person_01{ // 定义Person类
    String name;
    Person_01(String name){
        this.name = name;}
    public void getInfo(){
        System.out.println("Person类 --> " + this.name) ;
    }
    public boolean compare(Person_01 p){
        return this.name==p.name;
    }
}
public class Java_Person{
    public static void main(String args[]){
        Person_01 per1 = new Person_01("张三") ;
        Person_01 per2 = new Person_01("李四") ;
        per1.getInfo() ; // 当前调用getInfo()方法的对象是per1
        per2.getInfo() ; // 当前调用getInfo()方法的对象是per2
        boolean b = per1.compare(per2);
    }
}

使用this调用本类的构造器：

class Person{ // 定义Person类
	private String name ;
	private int age ;
	public Person(){ // 无参构造器
		System.out.println("新对象实例化") ;
	}
	public Person(String name){
		this(); // 调用本类中的无参构造器
		this.name = name ;
	}
	public Person(String name,int age){
		this(name) ; // 调用有一个参数的构造器
		this.age = age;
	}
	public String getInfo(){
		return "姓名：" + name + "，年龄：" + age ;
	}
}

Java_this注意事项

  1. 可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其
    他的构造器！
  2. 构造器中不能通过"this(形参列表)"的方式调用自身构造器
  3. 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了
    “this(形参列表)”
  4. "this(形参列表)"必须声明在类的构造器的首行！
  5. 在类的一个构造器中，最多只能声明一个"this(形参列表)"

Java_可变个数的形参简介

  1. JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。
  2. 从而，可以用一种更简单的方式，来传递个数可变的实参。这就简化了重载的使用
  3. 在JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量：public static void test(int a ,String[] books);
  4. 在JDK5.0以后：采用可变个数形参来定义方法，传入多个同一类型变量：public static void test(int a ,String…books);

Java_可变个数形参注意

  1. 声明格式：方法名(参数的类型名 ...参数名)
  2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
  3. 可变个数形参的方法与同名的方法之间，彼此构成重载
  4. 可变参数方法的使用与方法参数部分使用数组是一致的
  5. 方法的参数部分有可变形参，需要放在形参声明的最后
  6. 在一个方法的形参位置，最多只能声明一个可变个数形参
package com.company;

public class Change_test {
    public void test(String[] msg){
        System.out.println("含字符串数组参数的test方法 ");
    }
    public void test1(String book){
        System.out.println("****与可变形参方法构成重载的test1方法****");
    }
    public void test1(String ... books){
        System.out.println("****形参长度可变的test1方法****");
    }
    public static void main(String[] args){
        Change_test te = new Change_test();
        //下面两次调用将执行第二个test方法
        te.test1();
        te.test1("aa" , "bb");
        //下面将执行第一个test方法
        te.test(new String[]{"aa"});
    }
}

Java_方法参数的值传递机制

  1. 方法必须由其所在类或对象调用才有意义。
  2. 若方法含有参数：形参：方法声明时的参数，实参：方法调用时实际传给形参的参数值

Java的实参值传入方法：

  1. Java里方法的参数传递方式只有一种：值传递，即将实际参数值的副本
    （复制品）传入方法内，而参数本身不受影响。
  2. 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
  3. 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

Java_基本数据类型参数传递样例

	package com.company;
	
	public class Join_parma_01 {
	//    基本数据类型的参数传递
	    public static void main(String[] args) {
	
	        int x = 5;
	        System.out.println("修改之前x = " + x);// 5
	        // x是实参
	        change(x);
	        System.out.println("修改之后x = " + x);// 5
	    }
	    public static void change(int x) {
	        System.out.println("change:修改之前x = " + x);// 5
	        x = 3;
	        System.out.println("change:修改之后x = " + x); // 3
	    }
	}

运行结果如下：

Java_引用数据类型传递样例

package com.company;

public class Join_parma_02 {
    public static class Person{
        int age;
    }
    public static void main(String[] args) {

        Person obj = new Person();
        obj.age = 5;
        System.out.println("修改之前age = " + obj.age);// 5
// x是实参
        change(obj);
        System.out.println("修改之后age = " + obj.age);// 3
    }
    public static void change(Person obj) {

        System.out.println("change:修改之前age = " + obj.age); // 5
        obj.age = 3;
        System.out.println("change:修改之后age = " + obj.age); // 3
    }
}

运行结果如下：

Java_将对象作为参数传递给方法

package com.company;

public class join_parma_03 {
    public static void main(String[] args){
        Num n1 = new Num();
        Num n2 = n1; // n1和n2引用同一对象，即它们有相同的引用值
        n1.i = 0;
        int x = 10;
        System.out.println("调用方法method1前：n1.i = "+n1.i+"\\tn2.i = "+n2.i+"\\tx = "+x);
        method1(n1,x);
        System.out.println("调用方法method1后：n1.i = "+n1.i+"\\tx = "+x);
        System.out.println((n1 == n2) ? "n1和n2引用同一对象" : "n1和n2引用不同对象");
        method2(n2);
        System.out.println("调用method2后：n1.i = "+n1.i+"        n2.i = "+n2.i);
        System.out.println((n1 == n2) ? "n1和n2引用同一对象" : "n1和n2引用不同对象");

    }
    static void method1(Num num,int y){
        num.i += y;
        y --;
        System.out.println("在退出method方法时：num.i = "+num.i+"\\ty = "+y);
    }
    static void method2(Num num){
        num = new Num();
        num.i += 100;
        System.out.println("退出method方法时: num.i = "+num.i);
    }
   public static class Num{
        int i;
    }
}

运行结果

  1. 首先创建 class Num 的对象 n1,并创建 Num n2 = n1，所以n1和n2有着相同的引用值，n1,n2都引用同一对象
  2. 对于method1方法来说，将n1的·值传递给了形参num，与n2和n1一样
  3. 在method1方法中对象num成员内容的任何改动，都会引起n1的内容改动。同时n1的变动也会引起n2的变动。
  4. 但是x传给y是值传递，所以y的变化则不会引起x的变化
  5. 对于method2来说，在它的函数体内重新申请了num的引用值，所以说对象num’的内容变动就不会再引起n2中内容的变化。

Java_方法的return

return的作用

  1. 返回方法指定类型的值（前提是方法的返回值类型不是void）。
  2. 结束方法,会导致正在执行的方法提前退出

有返回值类型的方法

public class Java_01 {
    static int add(int a,int b){
        int temp;
        temp =  a+b;
        return temp;
    }
    public static void main(String[] args) {
        System.out.println(add(10,5));
        System.out.println(add(5,10));
        System.out.println(add(5,5));

    }
}

没有返回值类型的方法

static void test(
以上是关于Java_方法(函数)的主要内容，如果未能解决你的问题，请参考以下文章
 

 编写高质量代码:改善Java程序的151个建议(第3章:类对象及方法___建议36~40)


 创建片段而不从 java 代码实例化它


 JAVA方法的定义


 VSCode 配置 用户自定义代码片段 自定义自动代码补充


 Java方法


 UseOfMethods - 方法的使用 - Java