精华内容
下载资源
问答
  • 通过反射初始化构造方法调用成员方法 package testPack; ​ public class Counter { double a; double b; public Counter() { super(); } ​ private Counter(double a, double b) { super()...

    通过反射初始化构造方法,调用成员方法

    package testPack;
    ​
    public class Counter {
        double a;
        double b;
        
        public Counter() {
            super();
        }
    ​
        private Counter(double a, double b) {
            super();
            this.a = a;
            this.b = b;
        }
        
        private double add(){
            return a+b;
        }
        
        protected double subtraction(){
            return a-b;
        }
        
        public double multiplication(){
            return a*b;
        }
        
        public double division(){
            return a/b;
        }
    ​
        @Override
        public String toString() {
            return "Counter [a=" + a + ", b=" + b + "]";
        }
    }
    
    package testPack;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Method;
    
    public class classTest {
    
    	public static void main(String[] args) throws Exception {
    		// TODO Auto-generated method stub
    		
    		Class<?> c = Class.forName("testPack.Counter");
    		Constructor<?> con = c.getDeclaredConstructor(double.class,double.class);
    //		使用私有构造方法需要打开权限
    		con.setAccessible(true);
    //		调用带参构造创建对象
    		Object ob = con.newInstance(5.0,5.0);
    //		确定要调用的方法,获取add方法
    		Method method = c.getDeclaredMethod("add");
    //		因为Counter中的add方法是私有的,所以要打开权限
    		method.setAccessible(true);
    		System.out.println(method);
    //		通过创建的对象调用add方法
    		Object invoke = method.invoke(ob);
    		System.out.println(invoke);
    		
    		System.out.println("==========");
    		Method newMethod = c.getDeclaredMethod("multiplication");
    		Object newInvoke = newMethod.invoke(ob);
    		System.out.println(newInvoke);
    	}
    }
    

    运行结果:

    private double testPack.Counter.add()
    10.0
    ==========
    25.0
    
    展开全文
  • 1.方法调用 2.变量的操作:声明 赋值 修改 3.程序结构:选择结构 循环结构……… return 返回值; } 具体如代码所示: public class ff { //方法的组成:修饰符、返回值、方法名、参数、

    方法

    1.方法的理解和语法格式:

    • 解决某一件事的功能实现。方法,是一段代码块的封装,方法中的代码应围绕某一功能的实现来写,目标明确,逻辑清晰。方法的语法格式如下:

    修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,......){
    执行语句
    1.方法的调用
    2.变量的操作:声明 赋值 修改
    3.程序结构:选择结构 循环结构………
    return 返回值;
    }

    • 具体如代码所示:
    public class ff {
        //方法的组成:修饰符、返回值、方法名、参数、方法体
        public void method(int a){
            //方法体
        }
    }
    
    

    2.方法的组成

    • 修饰符:分为两种,分别是访问权限修饰符(public公共的、private私有的)和静态修饰符(static)。
    • 返回值:可以可无,无返回值(void)和有返回值(基本数据类型、引用数据类型)。
      其中构造方法中的返回值是一个和类名相同的引用变量,在编写程序的时候省略写。
    • 方法名:采用驼峰命名法,第一个单词首字符小写,第二个及以后的单词首字符大写。
    • 参数列表:可以可无,定义类型和参数名字不进行赋值。
    • 方法体:1、定义变量(局部变量)。2、编写选择、循环结构。3、方法调用。 4、返回值语句 return。

    3.参数分形参和实参(参数的分类)

    • 形参:形式参数,在声明一个方法时,方法名后面的小括号中,就是形参, 格式:(参数数据类型 参数名)
    • 实参:实际参数,在调用一个方法时,方法名后面的小括号中,就是实参。 格式:(参数值或一个同类型的变量)
    • 补充:方法的状态:方法编写完成后,没有调用的状态叫作方法的声明,被其它方法调用时,叫调用状态。

    4.方法的返回值

    • 返回值指的是:根据实际的业务需求,对某一功能用程序实现后,需要有一定的产出。返回值:可以可无。
    • 和有返回值-------------------基本数据类型、引用数据类型
    • 无返回值--------------void

    5.方法的调用和传参

    1. 调用:方法分静态和非静态,同一个类中,静态方法直接调用静态方法,静态方法调用非静态,要先创建对象,然后再调用。因为静态方法是属于类的,非静态属于对象的。不同的类中:调用静态方法,直接是类名.方法名();调用非静态:创建对象,再调用。
      2.传参,调用有多个参数的方法时,传参的顺序一致,数据类型保持一致。

    同一个类中:

    主调方\被调方 3静态方法 实例方法
    静态 直接写方法名调 创建对象,再调
    实例 直接写方法名调 直接写方法名调(省略this)

    不同的类中:

    主调方\被调方 静态方法 实例方法
    静态 直接写类名.方法名()来调 创建对象,再调
    实例 直接写类名.方法名()来调 创建对象,再调

    6.构造方法

    1.构造方法的作用:开辟内存空间,生成对象,俗称类创建对象的过程叫实例化 特点:方法名和类名相同,没有返回值一说,连void也没有。

    2.构造方法分为有参构造和无参构造 无参构造:jvm虚拟机在加载类时会自动创建,每个类都默认有一个无参构造 有参构造:需要开发人员自己去编写,它的作用是:实例化对象的同时,为对象的成员 属性赋值。有参构造=无参构造+set方法

    注意:如果开发人员编写了有参构造,那么虚拟机就不会默认生成无参构造。如果仍要使用无参构造,需要手动编写。

    7.方法的重载

    1.一个类中,同名不同参数的两个或以上的方法叫做方法的重载。有参构造和无参构造就是典型的方法重载.
    2.如果类中只有有参构造,忘记了写无参构造 ,类中的有参构造会覆盖无参构造 .
    3.如果类中有参构造和无参构造都忘记了写 虚拟机在加载该类的时候会默认帮你生成一个无参构造有参构造会覆盖默认的无参构造。
    4.判断是否是重载只看两个因素:1.方法名相同,2.参数不同。
    5.this是谁调用this所在的方法,谁就是this的当前对象。

    8.成员变量和局部变量

    成员变量:类的成员,也叫全局变量,在类的里面都可以使用,在static中需先声明才能使用,有默认的初始值。
    局部变量:定义在方法体内部的变量,只有在定义的方法体内部才能使用,没有默认的初始值。

    展开全文
  • 在对对象成员变量初始化时,有输入时,通过有参构造方法进行赋值。当没有输入时,可以给个初始值,就通过无参写入默认的,无参调有参完成赋值。 // main方法中 new调用无参构造方法,再完成上面的无参调有参 new ...

    在对对象成员变量初始化时,有输入时,通过有参构造方法进行赋值。当没有输入时,可以给个初始值,就通过无参写入默认的,无参调有参完成赋值。
    在这里插入图片描述

    // main方法中 new调用无参构造方法,再完成上面的无参调有参

    new 类名();

    展开全文
  • Android开发中一般讲Java接口调用放在APP层,但是如果想对外隐藏Java接口调用,应该怎么办呢?我们可以将接口调用放在JNI层,通过反射调用所需接口,之后打包成.so库,这样既可对外隐藏所有调用细节。

    Android开发中一般讲Java接口调用放在APP层,但是如果想对外隐藏Java接口调用,应该怎么办呢?我们可以将接口调用放在JNI层,通过反射调用所需接口,之后打包成.so库,这样既可对外隐藏所有调用细节。下面开始讲解JNI怎么调用Java方法。

    首先模拟实现一个类,代表想隐藏的接口

    代码如下:

    package com.lb6905.jnidemo;
    
    import android.util.Log;
    
    public class TestClass {
        private final static String TAG = "TestClass";
    
        public TestClass(){
            Log.i(TAG, "TestClass");
        }
    
        public void test(int index) {
            Log.i(TAG, "test : " + index);
        }
    
        public static void testStatic(String str) {
            Log.i(TAG, "testStatic : " + str);
        }
    
        public static class InnerClass {
            private int num;
            public InnerClass() {
                Log.i(TAG, "InnerClass");
            }
    
            public void setInt(int n) {
                num = n;
                Log.i(TAG, "setInt: num = " + num);
            }
        }
    }
    

    这个类包一个构造方法、一个成员方法,一个静态方法,一个内部类,大多数的类都是由这三种方法组成的。下面要做的就是怎么在JNI调用这些方法。

    查看方法签名

    这里首先Make Project,否则不会生成Java文件对应的class文件

    进入到classpath目录下:
    命令: cd app/build/intermediates/classes/debug

    查看外部类的签名
    javap -s -p com.lb6905.jnidemo.TestClass

    查看内部类的签名
    javap -s -p com.lb6905.jnidemo.TestClass$InnerClass

    结果如下:

    F:\Apps\jniDemo\JNIDemo\app\build\intermediates\classes\debug>javap -s -p com.lb6905.jnidemo.TestClass
    Compiled from "TestClass.java"
    public class com.lb6905.jnidemo.TestClass {
      private static final java.lang.String TAG;
        descriptor: Ljava/lang/String;
      public com.lb6905.jnidemo.TestClass();
        descriptor: ()V
    
      public void test(int);
        descriptor: (I)V
    
      public static void testStatic(java.lang.String);
        descriptor: (Ljava/lang/String;)V
    }
    
    F:\Apps\jniDemo\JNIDemo\app\build\intermediates\classes\debug>javap -s -p com.lb6905.jnidemo.TestClass$InnerClass
    Compiled from "TestClass.java"
    public class com.lb6905.jnidemo.TestClass$InnerClass {
      private int num;
        descriptor: I
      public com.lb6905.jnidemo.TestClass$InnerClass();
        descriptor: ()V
    
      public void setInt(int);
        descriptor: (I)V
    }
    

    在JNI中反射调用上述方法

    JNIEXPORT void JNICALL Java_com_lb6905_jnidemo_MainActivity_JNIReflect
    (JNIEnv *env, jobject thiz)
    {
        //实例化Test类
        jclass testclass = (*env)->FindClass(env, "com/lb6905/jnidemo/TestClass");
        //构造函数的方法名为<init>
        jmethodID testcontruct = (*env)->GetMethodID(env, testclass, "<init>", "()V");
        //根据构造函数实例化对象
        jobject testobject = (*env)->NewObject(env, testclass, testcontruct);
    
        //调用成员方法,需使用jobject对象
        jmethodID test = (*env)->GetMethodID(env, testclass, "test", "(I)V");
        (*env)->CallVoidMethod(env, testobject, test, 1);
    
        //调用静态方法
        jmethodID testStatic = (*env)->GetStaticMethodID(env, testclass, "testStatic", "(Ljava/lang/String;)V");
        //创建字符串,不能在CallStaticVoidMethod中直接使用"hello world!",会报错的
        jstring str = (*env)->NewStringUTF(env, "hello world!");
        //调用静态方法使用的是jclass,而不是jobject
        (*env)->CallStaticVoidMethod(env, testclass, testStatic, str);
    
        //实例化InnerClass子类
        jclass innerclass = (*env)->FindClass(env, "com/lb6905/jnidemo/TestClass$InnerClass");
        jmethodID innercontruct = (*env)->GetMethodID(env, innerclass, "<init>", "()V");
        jobject innerobject = (*env)->NewObject(env, innerclass, innercontruct);
    
        //调用子类的成员方法
        jmethodID setInt = (*env)->GetMethodID(env, innerclass, "setInt", "(I)V");
        (*env)->CallVoidMethod(env, innerobject, setInt, 2);
    }
    

    生成.so文件

    ndk-build打包成.so库,之后只需要在Android中使用就可以了

    static {
        System.loadLibrary("hello-jni");
    }
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ......
        JNIReflect();
    }
    

    结果如下,达到预期效果

    10-17 11:00:29.685 26729-26729/com.lb6905.jnidemo I/TestClass: TestClass
    10-17 11:00:29.685 26729-26729/com.lb6905.jnidemo I/TestClass: test : 1
    10-17 11:00:29.685 26729-26729/com.lb6905.jnidemo I/TestClass: testStatic : hello world!
    10-17 11:00:29.686 26729-26729/com.lb6905.jnidemo I/TestClass: InnerClass
    10-17 11:00:29.686 26729-26729/com.lb6905.jnidemo I/TestClass: setInt: num = 2
    

    这种方法也可以调用Android的自带的接口,可以很大程度提高安全性,因为.so文件比较难破解。

    关于env,在C和C++语言中调用方式是不同的,如下,本例使用的C语言

    在C中:
    (*env)->方法名(env,参数列表)
    在C++中:
    env->方法名(参数列表)
    

    代码地址(顺手给个Star啊):点击查看源码

    作者:lb377463323
    出处:http://blog.csdn.net/lb377463323
    原文链接:http://blog.csdn.net/lb377463323/article/details/75303125
    转载请注明出处!

    展开全文
  • 构造方法是专门用来创建对象的,也就是在new对象时要调用构造方法。现在来看看如何调用构造方法。 class Person { // Person的成员属性age和name private int age; private String name; // ...
  • 3.在创建一个对象的时候,至少要调用一个构造方法(通过new调用) 4.构造方法名称必须和类同名 5.完成对象的构建 6.没有返回值 成员方法 1.除了构造方法(可以通过与类名相同判断),就是成员方法 2.通过"对象名.方法名...
  • 反射获取构造方法成员方法 注意: 获取class对象的方法 通过class对象调用构造方法getConstrutor的方法,返回Constructor对象接收 通过Constructor对象,调用newInstance(+//参数)实例化,使用向下转型接收带参...
  • 构造方法成员方法

    2018-08-22 21:42:15
    在java中构造方法是方法名称与类名相同的一种方法,构造方法可以有参也可以无参,如果创建的类中没有...构造方法在你新创建一个对象时就会调用,根据你创建对象时有无传入参数来调用带参构造方法或者无参构造方法。...
  • 建议95:避免在构造方法调用成员构造方法调用虚方法会带来一些意想不到的错误,虽然这种方法不常见,但还是需要注意这类陷阱。 static void Main() { American american = new American(); Console....
  • Java构造方法成员方法的区别

    千次阅读 2020-02-24 21:12:03
    构造方法成员方法的区别 A:格式区别 构造方法和类名相同,并且没有返回类型,也没有返回值。 普通成员方法可以任意起名,必须有返回类型,可以没有返回值。 B:作用区别 构造方法用于创建对象,并进行初始化值。 ...
  • 构造函数中调用成员方法尝试了很多次但是不成功,页面报错,虽然最后解决了,但是仍然很不明白,对构造函数的含义很模糊,如有大神还请指教, 首先声明一下:rootController是父类,其他所有的控制器都继承...
  • 问题是类的构造方法是否能调用成员方法? 百度后,找到了这样一张图片,代码为java的,很中我们可以很明确体会到这个问题。 解释 类的构造方法是可以调用成员方法的。 左图第一个方法是构造方法,而show方法是...
  • 调用成员变量 this 指正在执行的对象。this的另外一个用途就是当方法的局部变量与类成员变量重名时,在方法里面就隐藏了类的成员变量。此时可以通过this.成员变量的方式来访问,如下程序: //程序1: public class ...
  • public class Rectangle { public int length; public int width; public Rectangle(int length,int width){ } public int area(int length,int width){ this. length=length;... this.... return length
  • 构造方法成员方法的区别

    万次阅读 2017-08-02 20:32:25
    作用不同: 构造方法用于创建类的实例并对实例的成员变量进行初始化;成员方法实现对类中成员变量的操作,提供某些功能。调用方式不同: 构造方法通过new运算符调用成员方法通过对象调用
  • 构造方法其实就是在创建新对象的时候调用的,所以要想创建对象,就必须调用构造方法,那么构造方法有作用是什么呢? 完成对象的初始化,我们可以在构造方法的方法体中加入一些内容,使得对象在创建的时候就让对象...
  • java中构造方法成员方法的区别 ...成员方法则是类的一般方法,用来调用的。 例如: public class Users{ private String username; private String password; public Users(){ //Users的空构造方法 ...
  • 220:date类的构造方法以及成员方法 /** date类的构造方法以及成员方法 @date 2020年4月27日上午10:41:59 / import java.util.Date;//注意进行类包的调用 public class zixuejava { public static void main(String...
  • this调用构造方法

    2020-01-26 19:00:37
    在之前学习方法之间调用时,可以通过方法名进行调用。...1. 构造方法调用格式: this(参数列表); 2. 构造方法的调用 class Person { // Person的成员属性 private int age; private String nam...
  • 继承中构造方法调用问题 * 2.重写 * 3.构造方法的作用:初始化 * 对象一旦创建,成员变量会先进行默认初始化,在 * 构造方法中的super()执行结束后,再次初始化成员 * 变量的值. */ public class ...
  • // 统一调用成员方法 public class D { // 构造函数1 public void func1() { System.out.println("this is func1"); } // 构造函数2 public void func2(Integer m) { System.out.println("this is func2:...
  • 通过使用super关键字去显示调用父类的带参构造方法 在父类中自己提供一个无参构造方法 (推荐使用自己给出无参构造方法) 继承中成员方法的访问特征 先从子类范围找,如果没有在从父类范围找。(就近原则) .....
  • 会完成父类中拥有的成员变量的值的初始化操作,此时子类的成员变量并未初始化,java中基本类型都会使用JVM给定的默认值(如int为0),只有当父类构造方法调用结束,并到执行子类构造器时才会进行子类成员变量的初始...
  • 构造器中调用多态方法进行初始化,也许会产生不可预料的结果。 [java] view plaincopy import java.io.FileWriter;  import java.io.IOException;    /**   * Created by IntelliJ IDEA. ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,710
精华内容 4,284
关键字:

构造方法调用成员方法