精华内容
下载资源
问答
  • Java方法之重写

    万次阅读 多人点赞 2019-07-14 21:38:57
      方法的重写是学习java面向对象过程中一个极其重要的知识点。那么什么叫方法的重写呢?举个例子(再次摆上使用了多次的老图): ...在博主更换轮胎配色的过程中,博主便执行了java方法中的重写操作...

      方法的重写是学习java面向对象过程中一个极其重要的知识点。那么什么叫方法的重写呢?举个例子(再次摆上使用了多次的老图):
                在这里插入图片描述
    博主毕业后,终于继承了家里面的一笔巨额财产:一辆奇瑞QQ。但是博主有一天发现,这辆奇瑞QQ的车轮胎很丑,不符合博主英俊潇洒的气质,所以博主决定将轮胎换成符合博主英俊潇洒气质的骚粉色。在博主更换轮胎配色的过程中,博主便执行了java方法中的重写操作。
      在java中方法的重写是建立在java类的三大特性之一:继承性的基础之上的,没有继承性也就不能谈方法的重写。方法的重写是当程序中父类的某一个方法并不能满足子类的需求时,子类可以重新定义该方法的内容与功能来满足子类的需求的一种操作。那么方法的重写具体是如何通过代码来实现的呢,下面博主就带大家一探究竟。
    (1)定义一个多边形类

    class Polygon{
    		//属性
    		private int number_side;
    		//构造器
    		public Polygon(int number_side) {
    			super();
    			this.number_side = number_side;
    		}
    		//方法
    		public int getNumber_side() {
    			return number_side;
    		}
    		public void setNumber_side(int number_side) {
    			this.number_side = number_side;
    		}
    		public void show(){
    			System.out.println("Number_side is " + this.number_side);
    		}
    }
    

      在这个类中除了get和set方法之外,还有一个可以输出多边形边数的show方法。
    (2)定义一个正方形类继承于多边形类

    class square extends Polygon{
    	//属性
    	private double length; 
    	//构造器
    	public square(double length, int number_side) {
    		super(number_side);
    		this.length = length;
    	}
    	//方法
    	public double getLength() {
    		return length;
    	}
    	public void setLength(double length) {
    		this.length = length;
    	}
    	//输出边数和边长
    	public void show(){
    		System.out.println("This is a square");
    		super.show();
    		System.out.println("Length is " + this.length);
    	}
    }
    

      可以看到,子类square中仍然有一个show方法,但是方法的功能和语句却与其父类中的show方法大相径庭。因为,在子类square中,子类square的show方法的功能不仅要能实现对边数的输出,更要实现对边长的输出,所以此时父类的show方法并不能满足子类的需求了,开发者应该重新编写一个show方法来满足子类的需求,这就是java中的方法重写。
      在实际的开发过程中,应用到方法重写的操作还有其他的很多种情况,接下来本文将列举几个比较常用的方法重写。
      在java的java.lang包下有一个类,名为Object。Object了是比较特殊的类,该类是所有类的父类。当我们创建一个类时,如果没有声明继承于我们自己创建的类,那么就继承于Object,只不过java里省略了extends Object关键字。Object类中有两个经常使用到的方法:1.toString()方法;2.equals()方法。这两种方法在开发者创建的类中经常被重写。

    1.toString()方法
      toString()方法的功能是将一个对象以字符串的形式返回。例如:

    Polygon p = new Polygon(3);
    System.out.println(p.toString());
    

    这里调用的toString()方法是Object类中的toString()方法。
    在这里插入图片描述
    输出为:
    在这里插入图片描述
    由此可见:当调用Object类中的toString()方法时返回的是一个字符串形式的对象,即该对象的地址。
      在实际的应用中通常重写toString()方法,为对象提供一个特定的字符串输出模式,例如:

    public class Test {
    	public static void main(String[] args) {
    		Polygon p = new Polygon(3);
    		System.out.println(p.toString());
    	}	
    }
    class Polygon{
    		//属性
    		private int number_side;
    		//构造器
    		public Polygon(int number_side) {
    			super();
    			this.number_side = number_side;
    		}
    		//..................................此处省略其他无关的方法
    		@Override
    		public String toString() {
    			return "Polygon [number_side=" + number_side + "]";
    		}
    		
    }
    

    在多边形类Polygon中重写了toString()方法,在main方法中我们创建一个Polygon的对象p并实例化,调用Polygon中重写的toString()方法。
    在这里插入图片描述
    此时系统输出字符串形式的Polygon类名和其属性。
    在这里插入图片描述
    2.equals()方法
      equals()方法在Object类中的具体体现是怎样的呢?它的功能又是什么呢?老规矩,直接上代码。

    	public boolean equals(Object obj) {
            return (this == obj);
        }
    

    这是源代码中Object类的equals()方法的具体实现,这样我们便知道,Object中equals()方法的功能是比较两个对象的引用是否相等。当我们调用Object类中的equals()方法时:

    public class Test {
    	public static void main(String[] args) {
    		square s1 = new square(5.2,4);
    		square s2 = new square(5.2,4);
    		System.out.println(s1.equals(s2));
    	}	
    }
    

    系统的输出为:

    在这里插入图片描述
      然后我们重写square类中的equals()方法

    public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		square other = (square) obj;
    		if (Double.doubleToLongBits(length) != Double
    				.doubleToLongBits(other.length))
    			return false;
    		return true;
    	}
    

    再次调用square类中的equals()方法时

    public class Test {
    	public static void main(String[] args) {
    		square s1 = new square(5.2,4);
    		square s2 = new square(5.2,4);
    		System.out.println(s1.equals(s2));
    	}	
    }
    

    系统的输出为:
    在这里插入图片描述
      相比之前的fasle,此时输出true是因为重写了equals()方法,而重写的equals()方法比较的是两个对象的实际内容,即两个对象的属性(注意:equals()方法并不比较两个对象的方法,因为无意义),相等就输出true。

      以上就是关于方法的重写的基本知识和一些常用的点。之前在多态性的那一章博主提到过:方法的重写也是多态性的一种体现,现在我们可以知道,同样都是toString()和equals()方法,在自定义类中重写之后和Object类中的功能完全不同,这也是同种事物的不同表现形式,符合多态性的本质。

    特殊声明:本人并不是大佬,只是说一说自己在学习Java过程中的理解,文章有不正确的地方欢迎大家批评指正。最后希望大家不喜勿喷,营造良好的学习环境。
    温馨提示:道路千万条,学习第一条。平时不学习,招聘两行泪!!!

    展开全文
  • java方法签名

    千次阅读 多人点赞 2017-08-04 12:46:42
    java方法签名,主要作用在于区分两个方法,即唯一确定一个方法,用于确定两个方法是否可以重载。 在java中,确定一个方法需要三个要素: 1. 调用者,也就是方法所属者,既可以是类,也可以是变量; 2. 方法名,...

    java方法签名,主要作用在于区分两个方法,即唯一确定一个方法,用于确定两个方法是否可以重载。
    在java中,确定一个方法需要三个要素:
    1. 调用者,也就是方法所属者,既可以是类,也可以是变量;
    2. 方法名,方法的标识;
    3. 形参列表,当调用方法时,系统将会根据传入的实参列表匹配。
    方法重载的要求就是两同一不同:同一个类中方法名相同,参数列表不同。所以方法签名就由方法名+形参列表构成。
    我们先看几个方法以及他们的方法签名:

    public void test1(){}      test1()V
    public void test2(String str)      test2(Ljava/lang/String;)V
    public int test3(){}       test3()I

    JVM为我们提供的方法签名实际上是由方法名(上下文的例子简单没有写出全类名)、形参列表、返回值三部分构成,基本形式就是:
    全类名.方法名(形参数据类型列表)返回值数据类型
    其中,签名中的特殊字符/字母含义:

    特殊字符数据类型特殊说明
    Vvoid一般用于表示方法的返回值
    Zboolean
    Bbyte
    Cchar
    Sshort
    Iint
    Jlong
    Ffloat
    Ddouble
    [数组以[开头,配合其他的特殊字符,表示对应数据类型的数组,几个[表示几维数组
    L全类名;引用类型 以 L 开头 ; 结尾,中间是引用类型的全类名

    可以使用javap命令生成方法签名,如:

    $ javap -s java.lang.String

    将会打印出String类里所有方法的方法签名。

    C:\Users\T>javap -s java.lang.String
    Compiled from "String.java"
    public final class java.lang.String implements java.io.Serializable, java.lang.Comparable<java.lang.String>, java.lang.CharSequence {
      public static final java.util.Comparator<java.lang.String> CASE_INSENSITIVE_ORDER;
        descriptor: Ljava/util/Comparator;
      public java.lang.String();
        descriptor: ()V
    
      public java.lang.String(java.lang.String);
        descriptor: (Ljava/lang/String;)V
    
      public java.lang.String(char[]);
        descriptor: ([C)V
    
      public java.lang.String(char[], int, int);
        descriptor: ([CII)V
    
      public java.lang.String(int[], int, int);
        descriptor: ([III)V
    
      public java.lang.String(byte[], int, int, int);
        descriptor: ([BIII)V
    
      public java.lang.String(byte[], int);
        descriptor: ([BI)V
    
      public java.lang.String(byte[], int, int, java.lang.String) throws java.io.UnsupportedEncodingException;
        descriptor: ([BIILjava/lang/String;)V
    
      public java.lang.String(byte[], int, int, java.nio.charset.Charset);
        descriptor: ([BIILjava/nio/charset/Charset;)V
    
      public java.lang.String(byte[], java.lang.String) throws java.io.UnsupportedEncodingException;
        descriptor: ([BLjava/lang/String;)V
    
      public java.lang.String(byte[], java.nio.charset.Charset);
        descriptor: ([BLjava/nio/charset/Charset;)V
    
      public java.lang.String(byte[], int, int);
        descriptor: ([BII)V
    
      public java.lang.String(byte[]);
        descriptor: ([B)V
    
      public java.lang.String(java.lang.StringBuffer);
        descriptor: (Ljava/lang/StringBuffer;)V
    
      public java.lang.String(java.lang.StringBuilder);
        descriptor: (Ljava/lang/StringBuilder;)V
    
      java.lang.String(char[], boolean);
        descriptor: ([CZ)V
    
      public int length();
        descriptor: ()I
    
      public boolean isEmpty();
        descriptor: ()Z
    
      public char charAt(int);
        descriptor: (I)C
    
      public int codePointAt(int);
        descriptor: (I)I
    
      public int codePointBefore(int);
        descriptor: (I)I
    
      public int codePointCount(int, int);
        descriptor: (II)I
    
      public int offsetByCodePoints(int, int);
        descriptor: (II)I
    
      void getChars(char[], int);
        descriptor: ([CI)V
    
      public void getChars(int, int, char[], int);
        descriptor: (II[CI)V
    
      public void getBytes(int, int, byte[], int);
        descriptor: (II[BI)V
    
      public byte[] getBytes(java.lang.String) throws java.io.UnsupportedEncodingException;
        descriptor: (Ljava/lang/String;)[B
    
      public byte[] getBytes(java.nio.charset.Charset);
        descriptor: (Ljava/nio/charset/Charset;)[B
    
      public byte[] getBytes();
        descriptor: ()[B
    
      public boolean equals(java.lang.Object);
        descriptor: (Ljava/lang/Object;)Z
    
      public boolean contentEquals(java.lang.StringBuffer);
        descriptor: (Ljava/lang/StringBuffer;)Z
    
      public boolean contentEquals(java.lang.CharSequence);
        descriptor: (Ljava/lang/CharSequence;)Z
    
      public boolean equalsIgnoreCase(java.lang.String);
        descriptor: (Ljava/lang/String;)Z
    
      public int compareTo(java.lang.String);
        descriptor: (Ljava/lang/String;)I
    
      public int compareToIgnoreCase(java.lang.String);
        descriptor: (Ljava/lang/String;)I
    
      public boolean regionMatches(int, java.lang.String, int, int);
        descriptor: (ILjava/lang/String;II)Z
    
      public boolean regionMatches(boolean, int, java.lang.String, int, int);
        descriptor: (ZILjava/lang/String;II)Z
    
      public boolean startsWith(java.lang.String, int);
        descriptor: (Ljava/lang/String;I)Z
    
      public boolean startsWith(java.lang.String);
        descriptor: (Ljava/lang/String;)Z
    
      public boolean endsWith(java.lang.String);
        descriptor: (Ljava/lang/String;)Z
    
      public int hashCode();
        descriptor: ()I
    
      public int indexOf(int);
        descriptor: (I)I
    
      public int indexOf(int, int);
        descriptor: (II)I
    
      public int lastIndexOf(int);
        descriptor: (I)I
    
      public int lastIndexOf(int, int);
        descriptor: (II)I
    
      public int indexOf(java.lang.String);
        descriptor: (Ljava/lang/String;)I
    
      public int indexOf(java.lang.String, int);
        descriptor: (Ljava/lang/String;I)I
    
      static int indexOf(char[], int, int, java.lang.String, int);
        descriptor: ([CIILjava/lang/String;I)I
    
      static int indexOf(char[], int, int, char[], int, int, int);
        descriptor: ([CII[CIII)I
    
      public int lastIndexOf(java.lang.String);
        descriptor: (Ljava/lang/String;)I
    
      public int lastIndexOf(java.lang.String, int);
        descriptor: (Ljava/lang/String;I)I
    
      static int lastIndexOf(char[], int, int, java.lang.String, int);
        descriptor: ([CIILjava/lang/String;I)I
    
      static int lastIndexOf(char[], int, int, char[], int, int, int);
        descriptor: ([CII[CIII)I
    
      public java.lang.String substring(int);
        descriptor: (I)Ljava/lang/String;
    
      public java.lang.String substring(int, int);
        descriptor: (II)Ljava/lang/String;
    
      public java.lang.CharSequence subSequence(int, int);
        descriptor: (II)Ljava/lang/CharSequence;
    
      public java.lang.String concat(java.lang.String);
        descriptor: (Ljava/lang/String;)Ljava/lang/String;
    
      public java.lang.String replace(char, char);
        descriptor: (CC)Ljava/lang/String;
    
      public boolean matches(java.lang.String);
        descriptor: (Ljava/lang/String;)Z
    
      public boolean contains(java.lang.CharSequence);
        descriptor: (Ljava/lang/CharSequence;)Z
    
      public java.lang.String replaceFirst(java.lang.String, java.lang.String);
        descriptor: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
    
      public java.lang.String replaceAll(java.lang.String, java.lang.String);
        descriptor: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
    
      public java.lang.String replace(java.lang.CharSequence, java.lang.CharSequence);
        descriptor: (Ljava/lang/CharSequence;Ljava/lang/CharSequence;)Ljava/lang/String;
    
      public java.lang.String[] split(java.lang.String, int);
        descriptor: (Ljava/lang/String;I)[Ljava/lang/String;
    
      public java.lang.String[] split(java.lang.String);
        descriptor: (Ljava/lang/String;)[Ljava/lang/String;
    
      public static java.lang.String join(java.lang.CharSequence, java.lang.CharSequence...);
        descriptor: (Ljava/lang/CharSequence;[Ljava/lang/CharSequence;)Ljava/lang/String;
    
      public static java.lang.String join(java.lang.CharSequence, java.lang.Iterable<? extends java.lang.CharSequence>);
        descriptor: (Ljava/lang/CharSequence;Ljava/lang/Iterable;)Ljava/lang/String;
    
      public java.lang.String toLowerCase(java.util.Locale);
        descriptor: (Ljava/util/Locale;)Ljava/lang/String;
    
      public java.lang.String toLowerCase();
        descriptor: ()Ljava/lang/String;
    
      public java.lang.String toUpperCase(java.util.Locale);
        descriptor: (Ljava/util/Locale;)Ljava/lang/String;
    
      public java.lang.String toUpperCase();
        descriptor: ()Ljava/lang/String;
    
      public java.lang.String trim();
        descriptor: ()Ljava/lang/String;
    
      public java.lang.String toString();
        descriptor: ()Ljava/lang/String;
    
      public char[] toCharArray();
        descriptor: ()[C
    
      public static java.lang.String format(java.lang.String, java.lang.Object...);
        descriptor: (Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
    
      public static java.lang.String format(java.util.Locale, java.lang.String, java.lang.Object...);
        descriptor: (Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
    
      public static java.lang.String valueOf(java.lang.Object);
        descriptor: (Ljava/lang/Object;)Ljava/lang/String;
    
      public static java.lang.String valueOf(char[]);
        descriptor: ([C)Ljava/lang/String;
    
      public static java.lang.String valueOf(char[], int, int);
        descriptor: ([CII)Ljava/lang/String;
    
      public static java.lang.String copyValueOf(char[], int, int);
        descriptor: ([CII)Ljava/lang/String;
    
      public static java.lang.String copyValueOf(char[]);
        descriptor: ([C)Ljava/lang/String;
    
      public static java.lang.String valueOf(boolean);
        descriptor: (Z)Ljava/lang/String;
    
      public static java.lang.String valueOf(char);
        descriptor: (C)Ljava/lang/String;
    
      public static java.lang.String valueOf(int);
        descriptor: (I)Ljava/lang/String;
    
      public static java.lang.String valueOf(long);
        descriptor: (J)Ljava/lang/String;
    
      public static java.lang.String valueOf(float);
        descriptor: (F)Ljava/lang/String;
    
      public static java.lang.String valueOf(double);
        descriptor: (D)Ljava/lang/String;
    
      public native java.lang.String intern();
        descriptor: ()Ljava/lang/String;
    
      public int compareTo(java.lang.Object);
        descriptor: (Ljava/lang/Object;)I
    
      static {};
        descriptor: ()V
    }
    展开全文
  • javascript调用java方法

    万次阅读 2017-08-17 16:30:27
    本文中所有的代码使用 JavaScript 编写...在 JavaScript 中访问对象的属性和方法的语法与 Java 语言相同。 本文包含如下几部分: 1、访问 Java 类 为了在 JavaScript 中访问原生类型或者引用 Java 类型,可以

    本文中所有的代码使用 JavaScript 编写,但你也可以用其他兼容 JSR 223 的脚本语言。这些例子可作为脚本文件也可以在交互式 Shell 中一次运行一个语句的方式来运行。在 JavaScript 中访问对象的属性和方法的语法与 Java 语言相同。

    本文包含如下几部分:

    1、访问 Java 类

    为了在 JavaScript 中访问原生类型或者引用 Java 类型,可以调用 Java.type() 函数,该函数根据传入的完整类名返回对应对象的类型。下面代码显示如何获取不同的对象类型:

    ?
    1
    2
    3
    4
    var ArrayList = Java.type("java.util.ArrayList");
    var intType = Java.type("int");
    var StringArrayType = Java.type("java.lang.String[]");
    var int2DArrayType = Java.type("int[][]");

    在 JavaScript 中使用 Java.type() 函数返回的类型对象的方法跟在 Java 的类似。

    例如你可以使用如下方法来实例化一个类:

    ?
    1
    var anArrayList = new Java.type("java.util.ArrayList");

    Java 类型对象可用来实例化 Java 对象。下面的代码显示如何使用默认的构造函数实例化一个新对象以及调用包含参数的构造函数:

    ?
    1
    2
    3
    var ArrayList = Java.type("java.util.ArrayList");
    var defaultSizeArrayList = new ArrayList;
    var customSizeArrayList = new ArrayList(16);

    你可以使用 Java.type() 方法来获取对象类型,可以使用如下方法来访问静态属性以及方法:

    ?
    1
    2
    var File = Java.type("java.io.File");
    File.createTempFile("nashorn", ".tmp");

    如果要访问内部静态类,可以传递美元符号 $ 给 Java.type() 方法。

    下面代码显示如何返回 java.awt.geom.Arc2D 的 Float 内部类:

    ?
    1
    var Float = Java.type("java.awt.geom.Arc2D$Float");

    如果你已经有一个外部类类型对象,那么你可以像访问属性一样访问其内部类,如下所示:

    ?
    1
    2
    var Arc2D = Java.type("java.awt.geom.Arc2D")
    var Float = Arc2D.Float

    由于是非静态内部类,必须传递的是外部类实例作为参数给构造函数。

    虽然在 JavaScript 中使用类型对象跟在 Java 中类似,但其与 java.lang.Class 对象还是有些区别的,这个区别就是 getClass() 方法的返回值。你可以使用 class 和 static 属性来获取这个信息。

    下面代码显示二者的区别:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    var ArrayList = Java.type("java.util.ArrayList");
    var a = new ArrayList;
     
    // All of the following are true:
    print("Type acts as target of instanceof: " + (a instanceof ArrayList));
    print("Class doesn't act as target of instanceof: " + !(a instanceof a.getClass()));
    print("Type is not the same as instance's getClass(): " + (a.getClass() !== ArrayList));
    print("Type's `class` property is the same as instance's getClass(): " + (a.getClass() === ArrayList.class));
    print("Type is the same as the `static` property of the instance's getClass(): " + (a.getClass().static === ArrayList));

    在语法和语义上,JavaScript 在编译时类表达式和运行时对象都和 Java 语义类似。不过在 Java 中 Class 对象是没有名为 static 这样的属性,因为编译时的类表达式不作为对象。

    2、导入 Java 包和类

    为了根据其简单的名称来访问 Java 类,我们可以使用 importPackage()  importClass() 函数来导入 Java 的包和类。这些函数存在于兼容性脚本文件 (mozilla_compat.js) 中。

    下面例子展示如何使用 importPackage()  importClass() 函数:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    // Load compatibility script
    load("nashorn:mozilla_compat.js");
    // Import the java.awt package
    importPackage(java.awt);
    // Import the java.awt.Frame class
    importClass(java.awt.Frame);
    // Create a new Frame object
    var frame = new java.awt.Frame("hello");
    // Call the setVisible() method
    frame.setVisible(true);
    // Access a JavaBean property
    print(frame.title);

    可以通过 Packages 全局变量来访问 Java 包,例如Packages.java.util.Vector 或者 Packages.javax.swing.JFrame。但标准的 Java SE 包有更简单的访问方式,如: java 对应 Packages.java, javax 对应 Packages.javax, 以及 org 对应 Packages.org。

    java.lang 包默认不需要导入,因为这会和 ObjectBooleanMath 等其他 JavaScript 内建的对象在命名上冲突。此外,导入任何 Java 包和类也可能导致 JavaScript 全局作用域下的变量名冲突。为了避免冲突,我们定义了一个 JavaImporter 对象,并通过 with 语句来限制导入的 Java 包和类的作用域,如下列代码所示:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    // Create a JavaImporter object with specified packages and classes to import
    var Gui = new JavaImporter(java.awt, javax.swing);
     
    // Pass the JavaImporter object to the "with" statement and access the classes
    // from the imported packages by their simple names within the statement's body
    with (Gui) {
     var awtframe = new Frame("AWT Frame");
     var jframe = new JFrame("Swing JFrame");
    };

    3、使用 Java 数组

    为了创建 Java 数组对象,首先需要获取 Java 数组类型对象并进行初始化。JavaScript 访问数组元素的语法以及 length 属性都跟 Java 一样,如下列代码所示:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    var StringArray = Java.type("java.lang.String[]");
    var a = new StringArray(5);
     
    // Set the value of the first element
    a[0] = "Scripting is great!";
    // Print the length of the array
    print(a.length);
    // Print the value of the first element
    print(a[0]);

    给定一个 JavaScript 数组 我们还可以用 Java.to() 方法将它转成 Java 数组。我们需要将 JavaScript 数组作为参数传给该方法,并指定要返回的数组类型,可以是一个字符串,或者是类型对象。我们也可以忽略类型对象参数来返回 Object[] 数组。转换操作是根据 ECMAScript 转换规则进行的。下面代码展示如何通过不同的 Java.to() 的参数将 JavaScript 数组变成 Java 数组:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    // 创建一个 JavaScript 数组
    var anArray = [1, "13", false];
     
    // 将数组转换成 java 的 int[] 数组
    var javaIntArray = Java.to(anArray, "int[]");
    print(javaIntArray[0]); // prints the number 1
    print(javaIntArray[1]); // prints the number 13
    print(javaIntArray[2]); // prints the number 0
     
    // 将 JavaScript 数组转换成 Java 的 String[] 数组
    var javaStringArray = Java.to(anArray, Java.type("java.lang.String[]"));
    print(javaStringArray[0]); // prints the string "1"
    print(javaStringArray[1]); // prints the string "13"
    print(javaStringArray[2]); // prints the string "false"
     
    // 将 JavaScript 数组转换成 Java 的 Object[] 数组
    var javaObjectArray = Java.to(anArray);
    print(javaObjectArray[0]); // prints the number 1
    print(javaObjectArray[1]); // prints the string "13"
    print(javaObjectArray[2]); // prints the boolean value "false"

    你可以使用 Java.from() 方法来将一个 Java 数组转成 JavaScript 数组。

    下面代码演示如何将一个包含当前目录下文件列表的数组转成 JavaScript 数组:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    // Get the Java File type object
    var File = Java.type("java.io.File");
    // Create a Java array of File objects
    var listCurDir = new File(".").listFiles();
    // Convert the Java array to a JavaScript array
    var jsList = Java.from(listCurDir);
    // Print the JavaScript array
    print(jsList);

    注意:

    大多数情况下,你可以在脚本中使用 Java 对象而无需转换成 JavaScript 对象。

    4、实现 Java 接口

    在 JavaScript 实现 Java 接口的语法与在 Java 总定义匿名类的方法类似。我们只需要实例化接口并用 JavaScript 函数实现其方法即可。

    下面代码演示如何实现 Runnable 接口:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // Create an object that implements the Runnable interface by implementing
    // the run() method as a JavaScript function
    var r = new java.lang.Runnable() {
     run: function() {
      print("running...\n");
     }
    };
     
    // The r variable can be passed to Java methods that expect an object implementing
    // the java.lang.Runnable interface
    var th = new java.lang.Thread(r);
    th.start();
    th.join();

    如果一个方法希望一个对象,这个对象实现了只有一个方法的接口,你可以传递一个脚本函数给这个方法,而不是传递对象。例如,在上面的例子中 Thread() 构造函数要求一个实现了 Runnable 接口的对象作为参数。我们可以利用自动转换的优势传递一个脚本函数给 Thread() 构造器。

    下面的例子展示如何创建一个 Thread 对象而无需实现 Runnable 接口:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    // Define a JavaScript function
    function func() {
     print("I am func!");
    };
     
    // Pass the JavaScript function instead of an object that implements
    // the java.lang.Runnable interface
    var th = new java.lang.Thread(func);
    th.start();
    th.join();

    你可以通过传递相关类型对象给 Java.extend() 函数来实现多个接口。

    5、扩展抽象 Java 类

    你可以实例化一个匿名的抽象类的子类,只需要给构造函数传递一个 JavaScript 对象,对象中包含了一些属性对应了抽象类方法实现的值。如果一个方法是重载的,JavaScript 函数将会提供所有方法变种的实现。下面例子显示如何初始化抽象类 TimerTask 的子类:

    ?
    1
    2
    var TimerTask = Java.type("java.util.TimerTask");
    var task = new TimerTask({ run: function() { print("Hello World!") } });

    除了调用构造函数并传递参数,我们还可以在 new 表达式后面直接提供参数。

    下面的例子显示该语法的使用方法(类似 Java 匿名内部类的定义),这比上面的例子要简单一些:

    ?
    1
    2
    3
    4
    5
    var task = new TimerTask {
     run: function() {
      print("Hello World!")
     }
    };

    如果抽象类包含单个抽象方法(SAM 类型),那么我们就无需传递 JavaScript 对象给构造函数,我们可以传递一个实现了该方法的函数接口。下面的例子显示如何使用 SAM 类型来简化代码:

    ?
    1
    var task = new TimerTask(function() { print("Hello World!") });

    不管你选择哪种语法,如果你需要调用一个包含参数的构造函数,你可以在实现对象和函数中指定参数。

    如果你想要调用一个要求 SAM 类型参数的 Java 方法,你可以传递一个 JavaScript 函数给该方法。Nashorn 将根据方法需要来实例化一个子类并使用这个函数去实现唯一的抽象方法。

    下面的代码显示如何调用 Timer.schedule() 方法,该方法要求一个 TimerTask 对象作为参数:

    ?
    1
    2
    var Timer = Java.type("java.util.Timer");
    Timer.schedule(function() { print("Hello World!") });

    注意:

    前面的语法假设所要求的 SAM 类型是一个接口或者包含一个默认构造函数,Nashorn 用它来初始化一个子类。这里是无法使用不包含默认构造函数的类的。

    6、扩展具体 Java 类

    为了避免混淆,扩展抽象类的语法不能用于扩展具体类。因为一个具体类是可以被实例化的,这样的语法会被解析成试图创建一个新的类实例并传递构造函数所需类的对象(如果预期的对象类型是一个接口)。为了演示这个问题,请看看下面的示例代码:

    ?
    1
    var t = new java.lang.Thread({ run: function() { print("Thread running!") } });

    这行代码被解析为扩展了 Thread 类并实现了 run() 方法,而 Thread 类的实例化是通过传递给其构造函数一个实现了 Runnable 接口的对象。

    为了扩展一个具体类,传递其类型对象给 Java.extend() 函数,然后返回其子类的类型对象。紧接着就可以使用这个子类的类型对象来创建实例并提供额外的方法实现。

    下面的代码将向你展示如何扩展 Thread 类并实现 run() 方法:

    ?
    1
    2
    3
    4
    var Thread = Java.type("java.lang.Thread");
    var threadExtender = Java.extend(Thread);
    var t = new threadExtender() {
     run: function() { print("Thread running!") }};

    Java.extend() 函数可以获取多个类型对象的列表。你可以指定不超过一个 Java 的类型对象,也可以指定跟 Java接口一样多的类型对象数量。返回的类型对象扩展了指定的类(或者是 java.lang.Object ,如果没有指定类型对象的话),这个类实现了所有的接口。类的类型对象无需在列表中排在首位。

    7、访问超类(父类)的方法

    想要访问父类的方法可以使用 Java .super() 函数。

    下面的例子中显示如何扩展 java.lang.Exception 类,并访问父类的方法。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    Example 3-1 访问父类的方法 (super.js)
     
    var Exception = Java.type("java.lang.Exception");
    var ExceptionAdapter = Java.extend(Exception);
     
    var exception = new ExceptionAdapter("My Exception Message") {
     getMessage: function() {
      var _super_ = Java.super(exception);
      return _super_.getMessage().toUpperCase();
     }
    }
     
    try {
     throw exception;
    } catch (ex) {
     print(exception);
    }

    如果你运行上面代码将会打印如下内容:

    ?
    1
    jdk.nashorn.javaadapters.java.lang.Exception: MY EXCEPTION MESSAGE

    8、绑定实现到类

    前面的部分我们描述了如何扩展 Java 类以及使用一个额外的 JavaScript 对象参数来实现接口。实现是绑定的具体某个实例上的,这个实例是通过 new 来创建的,而不是整个类。这样做有一些好处,例如运行时的内存占用,因为 Nashorn 可以为每个实现的类型组合创建一个单一的通用适配器。

    下面的例子展示不同的实例可以是同一个 Java 类,而其 JavaScript 实现对象却是不同的:

    ?
    1
    2
    3
    4
    5
    6
    var Runnable = java.lang.Runnable;
    var r1 = new Runnable(function() { print("I'm runnable 1!") });
    var r2 = new Runnable(function() { print("I'm runnable 2!") });
    r1.run();
    r2.run();
    print("We share the same class: " + (r1.class === r2.class));

    上述代码将打印如下结果:

    ?
    1
    2
    3
    I'm runnable 1!
    I'm runnable 2!
    We share the same class: true

    如果你想传递类的实例给外部 API(如 JavaFX 框架,传递 Application 实例给 JavaFX API),你必须扩展一个 Java 类或者实现了与该类绑定的接口,而不是它的实例。你可以通过传递一个 JavaScript 对象绑定实现类并传递给 Java.extend() 函数的最后一个参数。这个会创建一个跟原有类包含一样构造函数的新类,因为它们不需要额外实现对象参数。

    下面的例子展示如何绑定实现到类中,并演示在这种情况下对于不同调用的实现类是不同的:

    ?
    1
    2
    3
    4
    5
    6
    var RunnableImpl1 = Java.extend(java.lang.Runnable, function() { print("I'm runnable 1!") });
    var RunnableImpl2 = Java.extend(java.lang.Runnable, function() { print("I'm runnable 2!") });
    var r1 = new RunnableImpl1();var r2 = new RunnableImpl2();
    r1.run();
    r2.run();
    print("We share the same class: " + (r1.class === r2.class));

    上面例子执行结果如下:

    ?
    1
    2
    3
    I'm runnable 1!
    I'm runnable 2!
    We share the same class: false

    将实现对象从构造函数调用移到 Java.extend() 函数调用可以避免在构造函数调用中所需的额外参数。每一个 Java.extend() 函数的调用都需要一个指定类的实现对象生成一个新的 Java 适配器类。带类边界实现的适配器类仍可以使用一个额外的构造参数用来进一步重写特定实例的行为。因此你可以合并这两种方法:你可以在一个基础类中提供部分 JavaScript 实现,然后传递给 Java.extend() 函数,以及在对象中提供实例实现并传递给构造函数。对象定义的函数并传递给构造函数时将覆盖对象的一些函数定义。

    下面的代码演示如何通过给构造函数传递一个函数来覆盖类边界对象的函数:

    ?
    1
    2
    3
    4
    5
    6
    var RunnableImpl = Java.extend(java.lang.Runnable, function() { print("I'm runnable 1!") });
    var r1 = new RunnableImpl();
    var r2 = new RunnableImpl(function() { print("I'm runnable 2!") });
    r1.run();
    r2.run();
    print("We share the same class: " + (r1.class === r2.class));

    上面例子执行后打印结果如下:

    ?
    1
    2
    3
    I'm runnable 1!
    I'm runnable 2!
    We share the same class: true

    9、选择方法重载变体

    Java 的方法可以通过使用不同的参数类型进行重载。Java 编译器 (javac) 会在编译时选择正确的方法来执行。在 Nashorn 中对Java 重载方法的解析实在方法被调用的时候执行的。也是根据参数类型来确定正确的方法。但如果实际的参数类型会导致模棱两可的情况下,我们可以显式的指定具体某个重载变体。这会提升程序执行的性能,因为 Nashorn 引擎无需在调用过程中去辨别该调用哪个方法。

    重载的变种作为特别的属性暴露出来。我们可以用字符串的形式来引用它们,字符串包含方法名称、参数类型,两者使用圆括号包围起来。

    下面的例子显示如何调用  System.out.println() 方法带 Object 参数的变种,我们传递一个 “hello” 字符串给它:

    ?
    1
    2
    var out = java.lang.System.out;
    out["println(Object)"]("hello");

    上述的例子中,光使用 Object 类名就足够了,因为它是唯一标识正确的签名。你必须使用完整的类名的情况是两个重载变种函数使用不同的参数类型,但是类型的名称相同(这是可能的,例如不同包中包含相同的类名)。

    10、映射数据类型

    绝大多数 Java 和 JavaScript 之前的转换如你所期待的运行良好。前面的章节中我们提到过一些简单的 Java 和 JavaScript 之间的数据类型映射。例如可以显式地转换数组类型数据,JavaScript 函数可以在当成参数传递给 Java 方法时自动转换成 SAM 类型。每个 JavaScript 对象实现了 java.util.Map 接口来让 API 可以直接接受映射。当传递数值给 Java API 时,会被转成所期待的目标数值类型,可以是封装类型或者是原始数据类型。如果目标类型不太确定(如 Number),你只能要求它必须是 Number 类型,然后专门针对该类型是封装了 Double、Integer 或者是 Long 等等。内部的优化使得数值可以是任何封装类型。同事你可以传递任意 JavaScript 值给 Java API,不管是封装类型还是原始类型,因为 JavaScript 的 ToNumber 转换算法将会自动处理其值。如果 Java 方法要求一个 String 或者 Boolean 对象参数,JavaScript 将会使用 ToString 和 ToBoolean 转换来获得其值。

    注意:

    因为对字符串操作的内部性能优化考虑,JavaScript 字符串并不总是对应 java.lang.String 类型,也可能是 java.lang.CharSequence 类型。如果你传递一个 JavaScript 字符串给要求 java.lang.String 参数的 Java 方法,那么这个 JavaScript 字符串就是 java.lang.String 类型,但如果你的方法签名想要更加泛型化(例如接受的参数类型是 java.lang.Object),那么你得到的参数对象就会使一个实现了 CharSequence 类的对象,而不是一个 Java 字符串对象。

    转载内容详情点击打开链接

    展开全文
  • Java方法的定义和使用

    万次阅读 多人点赞 2018-01-27 17:29:57
    方法的最大好处是可以进行重复调用,但是至于说那些操作要形成方法,这些都要...在Java中要想进行方法的定义,则可以使用如下的语法完成。 public static 返回类型 方法名称([参数类型 变量, ......]) { 方法体代码;

    方法的最大好处是可以进行重复调用,但是至于说那些操作要形成方法,这些都要根据你的实际项目经验而自我总结的。
    ##方法的基本定义
    限制条件:在主类中定义,并且由主方法直接调用的方法形式。
    方法就是一段可以被重复调用的方法块。在Java中要想进行方法的定义,则可以使用如下的语法完成。

    public static 返回类型 方法名称([参数类型 变量, ......]) {
    	方法体代码;
    	[return [返回值];]
    }
    

    在定义方法的时候对于方法的返回值有一下的两类:

    • void:没有返回值;

    • 数据类型(基本类型,引用类型)。

    范例: 定义一个没有返回值,没有参数的方法

    public class TestDemo {
    	public static void main(String[] args) {
    		print();	//主方法里面直接调用方法
    	}
    	public static void print() {
    		System.out.println("Hello	World!"); //定义方法
    	}
    }
    

    范例: 定义一个有参数无返回值的方法

    public class TestDemo {
    	public static void main(String[] args) {
    		print("Hello");	//主方法里面直接调用方法
    		print("	world");
    		print("!");
    	}
    	public static void print(String msg) {	//定义方法
    		System.out.print(msg); 
    	}
    }
    

    范例: 有参数有返回值的方法

    public class TestDemo {
    	public static void main(String[] args) {
    		int result = add(10, 20);
    		System.out.println(result);
    		//既然方法有返回值,那么这些返回值也可以直接输出
    		System.out.println(add(100, 200));
    	}
    	public static int add(int x, int y) {	//定义方法
    		return x + y;
    	}
    }
    

    但是在定义方法的时候有一点特别要注意,如果某一个方法上使用了void定义,那么该方法可以直接用return来结束调用。一般而言,这种return的处理往往需要结合if判断来实现。

    public class TestDemo {
    	public static void main(String[] args) {
    		print(10);
    		print(20);
    	}
    	public static void print(int x) {	//定义方法
    		if(x == 20)		//表示的是方法结束的判断
    			return;		//此语句之后的代码不再执行
    		System.out.println("x = " + x);
    	}
    }
    

    对于第一次接触方法的人来讲,先将语法记住,至于怎么用,需要时间来消化。
    ##方法重载(重点)
    方法重载指的是:方法名称相同,参数的类型和个数不同。

    范例: 实现方法重载

    public class TestDemo {
    	public static void main(String[] args) {
    		//此时将根据参数的类型和个数的不同执行不同的方法体
    		System.out.println(add(10, 20));
    		System.out.println(add(30, 40, 50));
    		System.out.println(add(1.1, 2.1));
    	}
    	public static int add(int x, int y) {
    		return x + y;
    	}
    	//此时方法名称相同,参数的个数不同
    	public static int add(int x, int y, int z) {
    		return x + y + z;
    	}
    	public static double add(double x, double y) {
    		return x + y;
    	}
    }
    

    在进行方法重载的时候有一个重要的原则:要求方法的返回值类型一定要相同。

    范例: 观察如下程序

    public class TestDemo {
    	public static void main(String[] args) {
    		//此时将根据参数的类型和个数的不同执行不同的方法体
    		System.out.println("hello");   //输出字符串
    		System.out.println(1);			//输出整形
    		System.out.println(1.1);		//输出浮点型
    		System.out.println('A');		//输出字符
    		System.out.println(true);		//输出布尔
    	}
    }
    

    证明:System.out.println()是一个被重载的方法

    方法递归调用

    方法的递归调用指的是一个方法自己调用自己的形式。一般如果要进行方法的递归操作往往都具备有以下的特点:

    • 方法必须有一个递归的结束条件;

    • 方法在每次递归处理的时候一定要做出一些变更;

    范例: 实现1 ~ 100的累加操作

    public class TestDemo {
    	public static void main(String[] args) {
    		System.out.println(sum(100));
    	}
    	public static int sum(int num) {
    		if(num == 1)
    			return  1;
    		return num + sum(--num);
    	}
    }
    
    1. [main()调用] 第1次执行sum()方法 return 100 + sum(99);
    2. [sum()递归] 第2次执行sum()方法 return 99 + sum(98);
    3. [sum()递归] 第3次执行sum()方法 return 98 + sum(97);
    4. [sum()递归] 倒数第2次执行sum()方法 return 2 + sum(1);
    5. [sum()递归] 倒数第1次执行sum()方法 return 1;

    范例: 实现60!,这个结果太大,应该使用double。

    public class TestDemo {
    	public static void main(String[] args) {
    		System.out.println(mul(60));
    	}
    	public static double mul(int num) {
    		if(num == 1)
    			return  1;
    		return num * mul(--num);
    	}
    }
    

    通过代码可以发现使用while循环的操作其实大部分都可以更换为递归,之所以使用递归主要是一个方法可以执行的操作很多,而且结构要好。

    展开全文
  • C++调用Java方法

    万次阅读 多人点赞 2018-10-17 16:02:23
    最近在搞JNI那块,发现网上很多都是Java调用JNI,然后...另一种是Java调用了C++,然后在该调用的C++里又回调另外的一个Java方法。其实这两种方法(或其他方法),都是要用到 JNIEnv,有关JNI的讲解可查阅此文章http...
  • java 方法缺省参数

    千次阅读 2019-03-20 15:49:41
    今天介绍一下java8的方法缺省参数 public Void getAAAA(String A,String.. B){ *********************** } 调用这个方法的时候参数A是必需的! B 是可传可不传, 可以传多个, 保存在一个String数组中 以上 ...
  • JAVA类之间方法的调用

    万次阅读 多人点赞 2018-11-02 23:39:15
    JAVA方法的调用一、静态方法调用其他方法:1. 静态方法调用非静态方法2.静态方法调用静态方法二、非静态方法调用其他方法1.非静态方法在同一类内调用其他方法2.非静态方法在不同类之间调用其他方法 注:调用方法...
  • Java方法区、栈及堆

    万次阅读 多人点赞 2017-11-19 15:45:19
    Java方法区、栈及堆一 方法区(Method Area)1. 什么是方法区(Method Area)?《深入理解JVM》书中对方法区(Method Area)描述如下: 方法区(Method Area)与Java堆一样,是各个线程共享的内存区域。 2.方法区...
  • Java方法重载

    万次阅读 多人点赞 2018-06-03 23:56:35
    Java中,同一个类中的多个方法可以有相同的方法名称,但是有不同的参数列表,这就称为方法重载(method overloading)。参数列表又叫参数签名,包括参数的类型、参数的个数、参数的顺序,只要有一个不同就叫做参数...
  • 在主类中定义,并且由用主方法直接调用的方法形式 方法指的就是一段可以被重复调用的代码块。 public static 方法返回值 方法名称([参数类型 变量,......]){ 方法体代码; [ return[返回值]; ] } 在定义...
  • Java方法签名

    万次阅读 2016-10-24 13:27:56
    由于重载方法之间的方法名是相同的,那么我们势必要从构成方法的其他几个要素中找到另一个要素与方法名组成能够唯一标示方法的签名,方法体当然不予考虑。那么就是形参列表和返回值了,但是由于对于调用方法的人来说...
  • java 方法中的参数类型是类类型的

    千次阅读 2019-08-02 22:03:09
    今天做作业遇到方法中的参数类型是类类型的;有点懵。所以上网查了一些资料,并且和参数类型是基本数据类型的比较了一下。 1方法参数类型是基本数据类型的: public void test(int a) { a=6; System.err.println...
  • 全网最详细的Java方法解析

    万次阅读 多人点赞 2019-02-13 15:09:10
    Java语言中的“方法”(Method)在其他语言当中也可能被称为“函数”(Function)。对于一些复杂的代码逻辑,如果希望重复使用这些代码,并且做到“随时任意使用”,那么就可以将这些代码放在一个大括号“{}”当中,...
  • JAVA方法调用过程(最详细的解释)

    千次阅读 2018-10-29 22:28:53
    弄清楚方法的调用过程,对于我们学习java极为重要,下面是调用过程的详细描述: 1、编译器查看对象的声明类型和方法名。 编译器去寻找所有名字为f但参数类型不同的方法。例如可能存在方法f(int)和方法f(String),...
  • Java方法设置超时

    万次阅读 2017-10-17 10:14:56
    我们在开发过程中可能会遇到这样的场景:在执行一个耗时操作的时候,如果在规定的时间内处理完成了,则返回正确的结果...import java.util.Random; import java.util.concurrent.Callable; import java.util.concurren
  • java方法的重写

    万次阅读 多人点赞 2017-11-28 09:38:13
    方法的重写
  • java方法名,类名,命名规范

    千次阅读 2019-10-01 20:20:21
    Java包的名字都是由小写单词组成。 2、类的命名: 类名是以大写字母开头的名词。如果有多个单词组成,每个单词第一个字母应该大写(骆驼命名法)。不能使用Java保留字作为类名。 3、方法的命名: 方法的名字...
  • 为什么Java方法里面不能再嵌套方法?直接原因: 这是Java基本语法定义的,方法中不可以再次声明方法,只能调用其他的方法。个人理解: 1.方法栈是需要一个载体的,这个载体就是Class,如果一个方法的上一级不是一...
  • java方法的四种分类

    万次阅读 2016-09-12 17:39:36
    Java方法 定义:是语句的集合,它们在一起执行一个功能。 •方法是解决一类问题的步骤的有序组合 •方法包含于类或对象中 •方法在程序中被创建,在其他地方被引用 方法的格式: 修饰符+返回值类型+方法名+...
  • java7之前,方法区位于永久代(PermGen),永久代和堆相互隔离,永久代的大小在启动JVM时可以设置一个固定值,不可变; java7中,存储在永久代的部分数据就已经转移到Java Heap或者Native memory。但永久代仍存在...
  • Scala和Java方法的相互调用

    万次阅读 2019-08-07 14:08:27
    在Scala中调用java方法,很简单,直接导入传递参数就可以进行调用了. 但是在Java中调用Scala的方法呢? 经过测试,也是很简单,静态方法直接传递参数,就可以调用了,非静态的方法,使用对象也可以调用方法 具体如下:...
  • Java 方法的参数可以有默认值吗?

    万次阅读 2019-03-21 09:49:37
    Java 方法的参数可以有默认值吗? 例如 void method(String p1, int p2, bool p3=false); 复制代码回答 Java不支持这种特性, 如果你真的有需求,你可以 通过方法的重载间接的支持默认的参数值 使用工厂模式 重载 ...
  • 如何在jsp中写一个java方法

    万次阅读 2017-02-23 22:57:25
    一般用在jsp中写java方法 代码如下: try{ //得到要下载的文件名 String fileName = request.getParameter("filename"); fileName = new String(fileName.getBytes("iso8859-1"),"UTF-8"); //上传的文件都是...
  • java方法中开启一个线程

    万次阅读 2019-07-01 08:50:07
    很多业务场景下需要你在一个方法中去开启一个线程,去跑一些处理时间较长的代码,这样调用方就不必经过长时间的等待了.好了 话不多说 先上代码: package test; public class ThreadTest { public static void ...
  • 在写Java题目的时候,发现了一个比较重要的问题:Java的按值传递对数组的问题: 首先看这段话: ...对于对象来说,是将对象的引用也就是副本传递给了方法,在方法中只有对对象进行修改才能影响...
  • Java 方法中加void和不加void的 区别

    万次阅读 2018-11-30 11:44:27
    只要记住void即无返回值就OK了,如果不用void,那么这个地方一定是被一个其它的类型...你看main方法不也是void嘛! 具体的可以执行下面的代码debug一下就知道了。 package com.Thursday.one; public class Var...
  • Java 方法使用final 修饰参数的作用

    万次阅读 2018-03-14 17:29:55
    Java 方法使用final 修饰参数的作用 在方法参数前面加final关键字就是为了防止数据在方法体中被修改。 主要分两种情况: 第一,用final修饰基本数据类型; 第二,用final修饰引用类型。 第一种情况,修饰基本...
  • Java方法入参三个省略号...啥意思

    千次阅读 2019-06-03 21:23:54
    可以传入多个参数,也可以不传入参数 public void f1(Integer... arr) { System.out.println("进入f1方法..."); for (Integer a : arr) { System.out.println(a); } } Main main = n...
  • java 方法设置默认值

    万次阅读 2017-07-15 10:28:55
    因为“默认参数”和“方法重载”同时支持的话有二义性的问题,Java可能为了简单就不要“默认参数”了。使用“方法重载”可以间接实现”默认参数“的效果,而且避免了代码过于hack(乱)。 如: public class A{ ...
  • Java方法中通过传递参数改变变量的值

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,410,882
精华内容 2,164,352
关键字:

java方法

java 订阅