精华内容
下载资源
问答
  • C++调用Java方法

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

    最近在搞JNI那块,发现网上很多都是Java调用JNI,然后再调用C++的方法。而当C++函数里调用Java的方法,网上的文章可以说是少之又少,所以写此篇文章共勉。。。。

    本文介绍两种方法,一是C++主动调用Java的情况;另一种是Java调用了C++,然后在该调用的C++里又回调另外的一个Java方法。其实这两种方法(或其他方法),都是要用到 JNIEnv,有关JNI的讲解可查阅此文章https://blog.csdn.net/tom_221x/article/details/69215286   在此感谢原文作者。

    首先讲解本文介绍的第二种方法:Java调用C++,然后C++再回调另一个Java方法,直接上代码吧:

    JavaVM* jvm = NULL;
    jclass myClass = NULL;
    jclass global_class = NULL;
    jmethodID mid_method;
    JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm,void* reserved){
        if (vm == NULL)
        {
            return JNI_ERR;
        }
    
        JNIEnv *env = NULL;
        jvm = vm;
    
        if(vm->GetEnv((void**)&env,JNI_VERSION_1_4)!=JNI_OK){
            return JNI_ERR;
        }
    
        myClass = (env)->FindClass("com/shizhuangyuan/mycpp/MainActivity");
    
        global_class = (jclass)env->NewGlobalRef(myClass);
    
        mid_method = (env)->GetMethodID(global_class,"cpp2JavaTest","(I)V");
    
        return JNI_VERSION_1_4;
    }

    这里讲解下JNI_OnLoad这个函数:

    当Android的VM(Virtual Machine)执行到C组件(即*so档)里的System.loadLibrary()函数时,首先会去执行C组件里JNI_OnLoad()函数。
    它的用途有二: 
    1、告诉VM此C组件使用那一个JNI版本。
          如果你的*.so档没有提供JNI_OnLoad()函数,VM会默认该*.so档是使用最老的JNI 1.1版本。
          由于新版的JNI做了许多扩充,如果需要使用JNI的新版功能,
          例如JNI 1.4的java.nio.ByteBuffer,就必须藉由JNI_OnLoad()函数来告知VM。

    2、由于VM执行到System.loadLibrary()函数时,就会立即先呼叫JNI_OnLoad(),
          所以C组件的开发者可以藉由JNI_OnLoad()来进行C组件内的初期值之设定(Initialization) 。

    在JNI_OnLoad函数里,首先通过FindClass把Java里的类找出来,接着GetMethodID找到需要调用的Java方法。第二个参数是该Java方法名。这里解析下第三个参数"(I)V"的含义:表示形参为int型,返回值为Void型的一个Java方法,详细的类型符号对照表如下所示:

    Java类型 对应签名符号
    Integer I
    Short S
    Char C
    Long J
    Float F
    Double D
    Byte B
    Boolean Z
    Void V
    数组 [内部类型
    Object对象 L开头,包名/类名,”;”结尾,$标识嵌套类

    下面举几个例子吧:

    void javaDemo1(int a, int b)            //(II)V
    
    double javaDemo2(string a, int b)       //(Ljava/lang/String;I)D
    
    void javaDemo3()                        //()V
    
    string javaDemo4(string[] a, boolean b) //([java/lang/String;Z)Ljava/lang/String;

     

    当虚拟机释放该C库时,则会调用JNI_OnUnload()函数来进行善后清除动作。代码如下:

    JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved) {
        JNIEnv *env = NULL;
        if (jvm->GetEnv((void **) &env, JNI_VERSION_1_4) != JNI_OK) {
            return;
        }
        env->DeleteGlobalRef(global_class);
        return;
    }

    接着便是C++调用Java方法的核心代码了:

    void cpp2jni(int msg){
        JNIEnv *env = NULL;
    
        if (jvm->AttachCurrentThread(&env, NULL))将当前线程注册到虚拟机中
        {
            return;
        }
        //实例化该类
        jobject jobject = env->AllocObject(global_class);//分配新 Java 对象而不调用该对象的任何构造函数。返回该对象的引用。
        //调用Java方法
        (env)->CallVoidMethod(jobject, mid_method,msg);
    
        jvm->DetachCurrentThread();
    }

    开开心运行代码,但是会出现一个运行时错误:

    Thread[1,tid=9643,Native,Thread*=0x7f7ec96a00,peer=0x74e4ea30,"main"] attempting to detach while still running code

    这是因为本例子是直接通过Java调用JNI里的函数,然后在JNI里调用C++函数,最后在该C++函数里调Java,即Java---JNI---C++---Java。

    上述出现错误的原因是DetachCurrentThread()时报的错,调用DetachCurrentThread函数的地方在java线程中,即在java调用C++代码时在C++代码中调用了AttachCurrentThread方法来获取JNIEnv,此时JNIEnv已经通过参数传递进来,你不需要再次AttachCurrentThread来获取。在释放时就会报错。 

    所以上述方便适用于:C++直接调用Java方法。

    但如果通过Java调用了C++,接着直接利用C++回调Java方法,代码可以修改成这样:

    void cpp2jni(int msg){
        JNIEnv *env = NULL;
        int status;
        bool isAttached = false;
        status = jvm->GetEnv((void**)&env, JNI_VERSION_1_4);
        if (status < 0) {
            if (jvm->AttachCurrentThread(&env, NULL))将当前线程注册到虚拟机中
            {
                return;
            }
            isAttached = true;
        }
        //实例化该类
        jobject jobject = env->AllocObject(global_class);//分配新 Java 对象而不调用该对象的任何构造函数。返回该对象的引用。
        //调用Java方法
        (env)->CallVoidMethod(jobject, mid_method,msg);
    
        if (isAttached) {
            jvm->DetachCurrentThread();
        }
    }

    其实就是在第一种方法加些判断就可以了。

    本文最后,直接附上本项目的Demo代码吧:

    github地址:https://github.com/Liangzhuhua/MyCPP.git

    CSDN地址:https://download.csdn.net/download/toyauko/10726905

    展开全文
  • JAVA方法和本地方法

    千次阅读 2016-09-10 18:36:51
    JAVA中有两种方法:JAVA方法和本地方法JAVA方法是由JAVA编写的,编译成字节码,存储在class文件中本地方法是由其它语言编写的,编译成和处理器相关的机器代码本地方法保存在动态链接库中,即.dll(windows系统)文件中...

    JAVA中有两种方法:JAVA方法和本地方法

    JAVA方法是由JAVA编写的,编译成字节码,存储在class文件中

    本地方法是由其它语言编写的,编译成和处理器相关的机器代码

    本地方法保存在动态链接库中,即.dll(windows系统)文件中,格式是各个平台专有的

    JAVA方法是与平台无关的,但是本地方法不是

    运行中的JAVA方法调用本地方法时,虚拟机装载包含这个本地方法的动态库的,并调用这个方法

    通过本地方法,JAVA程序可以直接访问底层操作系统的资源,如果你这样用,你的程序就变成平台相关了,因为本地方法的动态库是与平台相关的,此外使用本地方法还可能把程序变得和特定的JAVA平台实现相关

    一个本地方法接口——JAVA本地接口JNI——使得本地方法可以在特定主机系统的任何一个JAVA平台实现上运行

    JAVA给人们提供了选择的机会

    如果希望使用特定主机上的资源,它们又无法从JAVA API访问,那么可以写一个平台相关的JAVA程序来调用本地方法

    如果希望保证程序的平台无关性,那么只能通过JAVA API来访问底层系统资源

    展开全文
  • 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
    }
    展开全文
  • 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方法重写与重载的区别

    万次阅读 多人点赞 2018-08-23 10:26:39
    Java方法重写与重载 一、方法重写(0veriding) 在Java程序中,类的继承关系可以产生一个子类,子类继承父类,它具备了父类所有的特征,继承了父类所有的方法和变量。 子类可以定义新的特征,当子类需要修改父类...
  • 在js调用java方法并取回返回值

    万次阅读 2017-09-09 17:08:34
    我在写项目的时候需要js和java在WebView进行交互,并且需要js调用java方法并返回参数给js,找了几个文档感觉写的不怎么详细,我就想了个办法试了试成功之后我就将细节写成文档记录一下,方便日后查看,也请各位大佬...
  • Java方法区、栈及堆

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

    万次阅读 2018-09-12 15:29:53
    前段时间看了笨神的 从一起GC血案谈到反射原理一本,就把Java方法的反射机制实现撸了一遍。 方法反射实例 public class ReflectCase { public static void main(String[] args) throws Exception { Pro...
  • Java方法的详细介绍

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

    万次阅读 2017-04-21 16:45:00
    java方法返回json数据
  • Java方法重载

    万次阅读 多人点赞 2018-06-03 23:56:35
    Java中,同一个类中的多个方法可以有相同的方法名称,但是有不同的参数列表,这就称为方法重载(method overloading)。参数列表又叫参数签名,包括参数的类型、参数的个数、参数的顺序,只要有一个不同就叫做参数...
  • java方法入栈和出栈

    千次阅读 2016-08-31 21:05:12
    java方法入栈和出栈
  • Java方法重写注意事项

    千次阅读 2016-11-13 13:59:43
    系原创,只为需要它的人Java方法重写的几个要求 重写的方法与父类方法签名(方法名称和参数列表)相同; 子类重写的方法访问修饰符范围不能低于父类; 父类的私有方法不能被重写; static修饰的方法不能被重写 返回值...
  • Java 方法的参数可以有默认值吗?

    万次阅读 2019-03-21 09:49:37
    Java 方法的参数可以有默认值吗? 例如 void method(String p1, int p2, bool p3=false); 复制代码回答 Java不支持这种特性, 如果你真的有需求,你可以 通过方法的重载间接的支持默认的参数值 使用工厂模式 重载 ...
  • 为什么Java方法里面不能再嵌套方法?直接原因: 这是Java基本语法定义的,方法中不可以再次声明方法,只能调用其他的方法。个人理解: 1.方法栈是需要一个载体的,这个载体就是Class,如果一个方法的上一级不是一...
  • JDK1.7 及之后版本的 JVM 已经将运行时...JDK1.8开始,取消了Java方法区,取而代之的是位于直接内存的元空间(metaSpace)。 已知: String A="abc"; String B="abc"; String C=new String("abc"); String D=new Str...
  • Java方法containsAll学习

    万次阅读 2016-11-17 12:58:39
    有时候我们需要判断B链表是不是A链表的子集,我们可以使用A.containsAll(B)来判断,当返回值是true的时候就表明B链表是A链表的子集,当...import java.util.ArrayList;public class Cationsall { public static voi
  • Java方法的不固定参数

    千次阅读 2016-04-21 01:47:16
    java方法的不固定参数
  • Java方法的可变参数个数

    万次阅读 多人点赞 2014-08-29 10:00:37
    原文:Java方法的可变参数类型许多Java新人在看到下面的这段代码的时候,都会问一个问题:dealArray方法里那三个小点点是什么啊?[java] view plaincopyprint?public class TestVarArgus { public static ...
  • Java方法的定义和使用

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

    万次阅读 2018-11-07 13:13:21
    Java方法的可选参数 可变参数
  • java方法的四种分类

    万次阅读 2016-09-12 17:39:36
    Java方法 定义:是语句的集合,它们在一起执行一个功能。 •方法是解决一类问题的步骤的有序组合 •方法包含于类或对象中 •方法在程序中被创建,在其他地方被引用 方法的格式: 修饰符+返回值类型+方法名+...
  • Scala和Java方法的相互调用

    万次阅读 2019-08-07 14:08:27
    在Scala中调用java方法,很简单,直接导入传递参数就可以进行调用了. 但是在Java中调用Scala的方法呢? 经过测试,也是很简单,静态方法直接传递参数,就可以调用了,非静态的方法,使用对象也可以调用方法 具体如下:...
  • JAVA方法名称获取类名访问痕迹  在实际编程中,我们或许会在代码量比较大的情况下,给我们的代码做一些调用痕迹的东西 比如当前调用的是哪个类,类得哪个方法: 一、获得当前类名: Java代码 ...
  • Java 方法使用final 修饰参数的作用

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

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

    千次阅读 2009-10-15 22:49:00
    JNI调用Java方法 JNI 调用java类的方法与反射代码类似。先得到object的类。-->jobject obj;jclass cls = env->GetObjectClass(obj);然后查找方法:jmethodID mgetZoom = env->GetMethodID(cls,"getZoom","()I");...
  • Java方法中通过传递参数改变变量的值
  • Macox lion 卸载JAVA方法

    千次阅读 2012-05-14 20:53:48
    Macox lion 卸载JAVA方法   Flashback 一种专门感染mac OS X的后门程序,感染数量超过60万,甚至打入苹果的总部。 此程序用java编写,伪装成Flash播放器更新程序,从主控机下载恶意代码并且传播,据称不需要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 870,339
精华内容 348,135
关键字:

java方法

java 订阅