详解Java面向对象编程中方法的使用

一个 Java 方法是为了执行某个操作的一些语句的组合。举个例子来说,当你调用 System.out.println 方法时,系统实际上会执行很多语句才能在控制台上输出信息。

现在你将学习怎么创建你自己的方法,他们可以有返回值也可以没有返回值,可以有参数,也可以没有参数,重载方法要使用相同的方法名称,并在程序设计中利用抽象的方法。

创建方法
我们用下面的例子来解释方法的语法:

public static int funcName(int a, int b) {
 // body
}

在这里

  • public static:修饰符
  • int:返回值类型
  • funcName:函数名称
  • a,b:形式参数
  • int a,int b:参数列

方法也包含过程或函数。

  • 过程:他们不返回值
  • 函数:他们返回值

方法的定义包含方法头和方法体。如下所示:

modifier returnType nameOfMethod (Parameter List) {
 // method body
}

以上的语法包括

  • modifier:他定义了方法的访问类型,它是可选的。
  • returnType:方法是可能返回一个值的。
  • nameOfMethod:这是方法的名称。方法签名包括方法名称和参数列表。
  • Parameter List:参数列表,它是参数的次序,类型,以及参数个数的集合。这些都是可选的,当然方法也可以没有参数。
  • 方法体:方法体定义了这个方法是用来做什么的。

示例

这是上面定义的方法max(),该方法接受两个参数num1和num2返回两者之间的最大值。

/** the snippet returns the minimum between two numbers */
public static int minFunction(int n1, int n2) {
  int min;
  if (n1 > n2)
   min = n2;
  else
   min = n1;

  return min;
}

方法调用
要想使用一个方法,该方法必须要被调用。方法调用有两种方式,一种是有返回值的,一种是没有返回值的。

调用方法很简单,当程序需要调用一个方法时,控制程序转移到被调用的方法,方法将会返回两个条件给调用者:

  • 返回一条执行语句
  • 执行到方法结束

将返回void的方法作为一个调用语句,让我看下面的例子:

System.out.println("wiki.jikexueyuan.com!");

该方法的返回值可以通过下面的例子被理解:

int result = sum(6, 9);

示例

下面的例子表明了怎么定义方法和怎么调用它:

public class ExampleMinNumber{

  public static void main(String[] args) {
   int a = 11;
   int b = 6;
   int c = minFunction(a, b);
   System.out.println("Minimum Value = " + c);
  }

  /** returns the minimum of two numbers */
  public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
     min = n2;
   else
     min = n1;

   return min;
  }
}

将会产生如下的结果

Minimum value = 6

关键字 void
关键字 void 允许我们创建一个没有返回值的方法。这里我们在下一个例子中创建一个 void 方法 methodRankPoints。这个方法是没有返回值类型的。调用 void 方法必须声明 methodRankPoints(255.7); Java 语句以分号结束,如下所示:

public class ExampleVoid {

  public static void main(String[] args) {
   methodRankPoints(255.7);
  }

  public static void methodRankPoints(double points) {
   if (points >= 202.5) {
     System.out.println("Rank:A1");
   }
   else if (points >= 122.4) {
     System.out.println("Rank:A2");
   }
   else {
     System.out.println("Rank:A3");
   }
  }
}

这将产生如下的结果:

Rank:A1

通过值来传递参数
在调用函数时参数是必须被传递的。并且他们的次序必须和他们创建时的参数次序是一样的。参数可以通过值或引用来传递。

通过值传递参数意味着调用方法的参数,通过参数值来传递给参数。

示例

下面的程序给出了一个例子来显示通过值来传递参数。在调用方法后参数值是不会发生变化的。

public class swappingExample {

  public static void main(String[] args) {
   int a = 30;
   int b = 45;

   System.out.println("Before swapping, a = " +
             a + " and b = " + b);

   // Invoke the swap method
   swapFunction(a, b);
   System.out.println("\n**Now, Before and After swapping values will be same here**:");
   System.out.println("After swapping, a = " +
             a + " and b is " + b);
  }

  public static void swapFunction(int a, int b) {

   System.out.println("Before swapping(Inside), a = " + a
              + " b = " + b);
   // Swap n1 with n2
   int c = a;
   a = b;
   b = c;

   System.out.println("After swapping(Inside), a = " + a
              + " b = " + b);
  }
}

这将产生如下的结果:

Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45

方法的重载
当一个方法有两个或者更多的方法,他们的名字一样但是参数不同时,就叫做方法的重载。它与覆盖是不同的。覆盖是指方法具有相同的名字,类型以及参数的个数。

让我们来考虑之前的找最小整型数的例子。如果我们要求寻找浮点型中最小的数时,我们就需要利用方法的重载来去创建函数名相同,但参数不一样的两个或更多的方法。

下面的例子给予解释:

public class ExampleOverloading{

  public static void main(String[] args) {
   int a = 11;
   int b = 6;
   double c = 7.3;
   double d = 9.4;
   int result1 = minFunction(a, b);
   // same function name with different parameters
   double result2 = minFunction(c, d);
   System.out.println("Minimum Value = " + result1);
   System.out.println("Minimum Value = " + result2);
  }

 // for integer
  public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
     min = n2;
   else
     min = n1;

   return min;
  }
  // for double
  public static double minFunction(double n1, double n2) {
   double min;
   if (n1 > n2)
     min = n2;
   else
     min = n1;

   return min;
  }
}

这将产生如下结果:

Minimum Value = 6
Minimum Value = 7.3

重载方法使程序易读。在这里,两种方法名称相同但参数不同。产生整型和浮点类型的最小数作为程序运行结果。

使用命令行参数
有时你想要在程序运行之前传递参数。这可以通过给 main 函数传递命令行参数来实现。

在命令行中,当要执行程序文件时,一个命令行参数是紧接着文件名字后面的出现的。要接受命令行参数在 Java 程序中是十分容易的。它们传递到 main 函数字符数组内。

示例

下面的例子展示了将所有命令行参数输出的程序:

public class CommandLine {

  public static void main(String args[]){
   for(int i=0; i<args.length; i++){
     System.out.println("args[" + i + "]: " +
                      args[i]);
   }
  }
}

通过以下方法来执行该程序:

java CommandLine this is a command line 200 -100

这将产生如下的结果:

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

构造函数
这是一个简单的使用构造函数的例子:

// A simple constructor.
class MyClass {
  int x;

  // Following is the constructor
  MyClass() {
   x = 10;
  }
}

你可以通过以下方法来调用构造函数来实例化一个对象:

public class ConsDemo {

  public static void main(String args[]) {
   MyClass t1 = new MyClass();
   MyClass t2 = new MyClass();
   System.out.println(t1.x + " " + t2.x);
  }
}

通常,你将需要用构造函数来接受一个或多个参数。参数的传递和以上介绍的普通方法的参数传递是一样的,就是在构造函数的名字后面列出参数列表。

示例

这是一个简单的使用构造函数的例子:

// A simple constructor.
class MyClass {
  int x;

  // Following is the constructor
  MyClass(int i ) {
   x = i;
  }
}

你可以通过以下方法来调用构造函数来实例化一个对象:

public class ConsDemo {

  public static void main(String args[]) {
   MyClass t1 = new MyClass( 10 );
   MyClass t2 = new MyClass( 20 );
   System.out.println(t1.x + " " + t2.x);
  }
}

这将产生如下的结果:

10 20

可变长参数
JDK1.5 能够允许你传递可变长的同一类型的参数。用如下方法进行声明:

typeName... parameterName

方法声明时,你要在省略号前明确参数类型,并且只能有一个可变长参数,并且可变长参数必须是所有参数的最后一个。

示例

public class VarargsDemo {

  public static void main(String args[]) {
   // Call method with variable args
   printMax(34, 3, 3, 2, 56.5);
   printMax(new double[]{1, 2, 3});
  }

  public static void printMax( double... numbers) {
  if (numbers.length == 0) {
   System.out.println("No argument passed");
   return;
  }

  double result = numbers[0];

  for (int i = 1; i < numbers.length; i++)
   if (numbers[i] > result)
   result = numbers[i];
   System.out.println("The max value is " + result);
  }
}

这将产生如下的结果:

The max value is 56.5
The max value is 3.0

finalize() 方法
你可以定义一个方法,仅在被垃圾收集器销毁之前才会被调用。这个方法叫做 finalize() 方法,它也可以用来确保一个对象被干净清除了。

举个例子,你也许用 finalize() 来确保被一个对象打开的文件已经关闭了。

为了给类添加一个终结器,你只需定义 finalize() 方法。Java要回收该类的一个对象时,会调用该方法。

在 finalize() 方法中,你将指定一些必须在对象销毁之前要做的行为。

finalize()方法一般是如下形似:

protected void finalize( )
{
  // finalization code here
}

这里,关键字 protected 是为了保证在类外的代码不能访问 finalize() 方法。

这意味着你不能知道 finalize() 什么时候执行。举个例子,如果你的程序在垃圾收集器发生之前就结束了,finalize() 方法将不会被执行。

泛型方法:
java泛型方法在方法返回值是容器类对象时广泛使用。

public static List<T> find(Class<T> clazz,String userId){
   ....
}

一般来说编写java泛型方法时,返回值类型和至少一个参数类型应该是泛型,而且类型应该是一致的,如果只有返回值类型或参数类型之一使用了泛型,这个泛型方法的使用就大大的限制了,基本限制到跟不用泛型一样的程度。

下面主要介绍两种十分相似的java泛型方法的使用以及它们之间的区别。
第一种:

  public static <T extends CommonService> T getService(Class<T> clazz) {
    T service = (T) serviceMap.get(clazz.getName());
    if (service == null) {
      service = (T) ServiceLocator.getService(clazz.getName());
      serviceMap.put(clazz.getName(), service);
    }
    return service;
  }

第二种:

  public static <T> T getService(Class<? extends CommonService> clazz) {
    T service = (T) serviceMap.get(clazz.getName());
    if (service == null) {
      service = (T) ServiceLocator.getService(clazz.getName());
      serviceMap.put(clazz.getName(), service);
    }
    return service;
  }

下面是泛型方法所在的类:

public abstract class CommonService {
  private static HashMap<String, CommonService> serviceMap = new HashMap<String, CommonService>();
  //这里是泛型方法定义
  .
  .
  .
}

这两个泛型方法只有方法的签名不一样,方法体完全相同,那它们有什么不一样呢?
我们来使用一下它们,就知道它们的区别了。
对第一种泛型方法使用:

public class Main {
  public static void main(String[] args) {
    NoticeService noticeService=CommonService.getService(NoticeService.class);//正确的使用第一种泛型方法,不会出现编译错误。
    NoticeService noticeService=CommonService.getService(UserService.class);//不正确的使用第一种泛型方法,会出现编译错误。

  }
}

对第二种泛型方法使用:

public class Main {
  public static void main(String[] args) {
    NoticeService noticeService=CommonService.getService(NoticeService.class);//正确的使用第二种泛型方法,不会出现编译错误,逻辑也正确,运行时不会出现异常。
    NoticeService noticeService=CommonService.getService(UserService.class);//不正确的使用第二种泛型方法,不会出现编译错误,但逻辑不正确,运行时会出现异常,危险!

  }
}

现在知道了这两种极其相似的泛型方法的区别了吧?

  • 第一种泛型方法:返回值和参数值的类型是一致,推荐使用;
  • 第二种泛型方法:返回值和参数值的类型不是一致,请谨慎或避免使用。
(0)

相关推荐

  • Java基础教程之Hello World到面向对象

    Java是完全面向对象的语言.Java通过虚拟机的运行机制,实现"跨平台"的理念.我在这里想要呈现一个适合初学者的教程,希望对大家有用. "Hello World!" 先来看一个HelloWorld.java程序.这个程序在屏幕上打印出一串字符"Hello World!": 复制代码 代码如下: public class HelloWorld {     public static void main(String[] args)     {  

  • Java语言面向对象编程思想之类与对象实例详解

    在初学者学Java的时候,面向对象很难让人搞懂,那么今天小编就来为大家把这个思想来为大家用极为简单的方法理解吧. 首先我们来简单的阐述面向对象的思想. 面向对象: 官方的语言很抽象,我们把官方的解释和定义抛开.想想,自己有什么,对!!我们自己有手脚眼口鼻等一系列的器官.来把自己所具有的器官就可以看作我们的属性,自己是不是可以喜怒哀乐和嬉笑怒骂,这些是不是我们的行为,那么自己的具有的属性加自己有的行为就称为一个对象. 注意!!我们自己,一个个体是一个对象,因为,你是你,我是我,我们虽然有相同的,但

  • java面向对象基础_final详细介绍

    final: 继承的弊端:打破了代码的封装性,final的出现正好弥补了这一弊端 final关键字: 1-final是一个修饰符,可以修饰类,方法,变量; 2-final修饰的类不能被继承 3-final修饰的方法不可以被覆盖 4-final修饰的变量是一个常数,只能被赋值一次并且要在定义时就将其赋予某值 规则: 被定义final的常量要用大写字母表示,各单词之间用下划线_来隔开. 实例一: class Father01{ final String FATHER01_NAME = "张三&quo

  • 全方位讲解Java的面向对象编程思想

    什么是面向对象? Object 对象,Oriendted 以-为导向的, Programming 程序设计 面向对象就是使用对象进行程序设计,简写成OOP. SP和OOP对比 面向对象的三大原则      封装  继承   多态 对象 对象是面向对象编程的核心部分,是实际存在的具体实体,具有明确定义的状态和行为: 对象其实就是"数据"和"函数"的封装体,其中: 数据表示自身的状态,也称作"属性"或"成员数据": 函数表示自身的

  • Java面向对象编程中final关键字的使用方法详解

    在Java中通过final关键字来声明对象具有不变性(immutable),这里的对象包括变量,方法,类,与C++中的const关键字效果类似. immutable指对象在创建之后,状态无法被改变 可以从三个角度考虑使用final关键字: 代码本身:不希望final描述的对象所表现的含义被改变 安全:final对象具有只读属性,是线程安全的 效率:无法修改final对象本身,对其引用的操作更为高效 final 变量 定义final Object a,则a只能被初始化一次,一旦初始化,a的数据无法

  • java 面向对象面试集锦

    java  面向对象:这里整理了面向对象的基础知识,帮助大家学习理解,希望能帮助到大家,这里是 根据公司面试资料整理的相关知识: Overload和Override的区别.Overloaded的方法是否可以改变返回值的类型? Overload是重载的意思,Override是覆盖的意思,也就是重写.重载Overload表示同一个类中可以有多个名称相同的方法,但这些方法的参数列表各不相同(即参数个数或类型不同). 重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同,通过子

  • 详解Java面向对象编程中方法的使用

    一个 Java 方法是为了执行某个操作的一些语句的组合.举个例子来说,当你调用 System.out.println 方法时,系统实际上会执行很多语句才能在控制台上输出信息. 现在你将学习怎么创建你自己的方法,他们可以有返回值也可以没有返回值,可以有参数,也可以没有参数,重载方法要使用相同的方法名称,并在程序设计中利用抽象的方法. 创建方法 我们用下面的例子来解释方法的语法: public static int funcName(int a, int b) { // body } 在这里 pub

  • 详解Java设计模式编程中的策略模式

    定义:定义一组算法,将每个算法都封装起来,并且使他们之间可以互换. 类型:行为类模式 类图: 策略模式是对算法的封装,把一系列的算法分别封装到对应的类中,并且这些类实现相同的接口,相互之间可以替换.在前面说过的行为类模式中,有一种模式也是关注对算法的封装--模版方法模式,对照类图可以看到,策略模式与模版方法模式的区别仅仅是多了一个单独的封装类Context,它与模版方法模式的区别在于:在模版方法模式中,调用算法的主体在抽象的父类中,而在策略模式中,调用算法的主体则是封装到了封装类Context中

  • 详解Java多线程编程中的线程同步方法

    1.多线程的同步: 1.1.同步机制: 在多线程中,可能有多个线程试图访问一个有限的资源,必须预防这种情况的发生.所以引入了同步机制:在线程使用一个资源时为其加锁,这样其他的线程便不能访问那个资源了,直到解锁后才可以访问. 1.2.共享成员变量的例子: 成员变量与局部变量: 成员变量: 如果一个变量是成员变量,那么多个线程对同一个对象的成员变量进行操作,这多个线程是共享一个成员变量的. 局部变量: 如果一个变量是局部变量,那么多个线程对同一个对象进行操作,每个线程都会有一个该局部变量的拷贝.他们

  • 详解Java多线程编程中CountDownLatch阻塞线程的方法

    直译过来就是倒计数(CountDown)门闩(Latch).倒计数不用说,门闩的意思顾名思义就是阻止前进.在这里就是指 CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程. CountDownLatch是一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待. CountDownLatch 的作用和 Thread.join() 方法类似,可用于一组线程和另外一组线程的协作.例如,主线程在做一项工作之前需要一系列的准备工作,只有这些准备工

  • 详解Swift面向对象编程中的方法(method)

    struct Point { var x:Double var y:Double mutating func move(x:Double,y:Double) { self = Point(x: self.x+x,y: self.y+y) } static func name(){ print("Point") } } Point.name() 一.引言 方法只是一个术语,其实就是将函数与特定的类型结合,类.结构体.枚举都可以定义方法,方法又分为实例方法和类型方法,类型方法类似于Obje

  • 详解Java设计模式编程中的访问者模式

    定义:封装某些作用于某种数据结构中各元素的操作,它可以在不改变数据结构的前提下定义作用于这些元素的新的操作. 类型:行为类模式 类图: 例子: 例如,思考一下添加不同类型商品的购物车,当点击结算的时候,它计算出所有不同商品需付的费用.现在,计算逻辑即为计算这些不同类型商品的价格.或者说通过访问者模式我们把此逻辑转移到了另外一个类上面.让我们实现这个访问者模式的例子. 为了实现访问者模式,最先需要做的是创建能够被添加到购物车中代表不同类型商品(itemElement)的类. ItemElement

  • 详解Java设计模式编程中的Flyweight享元模式的开发结构

    享元(Flyweight)模式:通过共享技术以便有效的支持大量细粒度的对象. 享元模式在阎宏的<java与模式>中分为单纯享元模式和复合享元模式,复合模式的复合享元是不可以共享的,享元对象能做到共享的关键是区分内蕴态(Internal State)和外蕴态( External State).这两个"蕴态"翻译的太难懂,我不是说翻译的不好,可能是我理解能力差,还是<Design Pattern Elements of Reusable Object-Oriented S

  • 详解Java设计模式编程中的依赖倒置原则

    定义: 高层模块不应该依赖低层模块,二者都应该依赖其抽象:抽象不应该依赖细节:细节应该依赖抽象. 问题由来:类A直接依赖类B,假如要将类A改为依赖类C,则必须通过修改类A的代码来达成.这种场景下,类A一般是高层模块,负责复杂的业务逻辑:类B和类C是低层模块,负责基本的原子操作:假如修改类A,会给程序带来不必要的风险. 解决方案:将类A修改为依赖接口I,类B和类C各自实现接口I,类A通过接口I间接与类B或者类C发生联系,则会大大降低修改类A的几率.          依赖倒置原则基于这样一个事实:

  • 详解Java多线程编程中线程的启动、中断或终止操作

    线程启动: 1.start() 和 run()的区别说明 start() : 它的作用是启动一个新线程,新线程会执行相应的run()方法.start()不能被重复调用. run() : run()就和普通的成员方法一样,可以被重复调用.单独调用run()的话,会在当前线程中执行run(),而并不会启动新线程! 下面以代码来进行说明. class MyThread extends Thread{ public void run(){ ... } }; MyThread mythread = new

  • 详解Java设计模式编程中的里氏替换原则

    定义1:如果对每一个类型为 T1的对象 o1,都有类型为 T2 的对象o2,使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 T1 的子类型. 定义2:所有引用基类的地方必须能透明地使用其子类的对象. 问题由来:有一功能P1,由类A完成.现需要将功能P1进行扩展,扩展后的功能为P,其中P由原有功能P1与新功能P2组成.新功能P由类A的子类B来完成,则子类B在完成新功能P2的同时,有可能会导致原有功能P1发生故障. 解决方

随机推荐