Class.getDeclaredMethods() 返回继承的默认方法

Question

The method getDeclaredMethods , when called on a class object, is supposed to return an array of Method objects representing the methods that are declared directly as part of that class. It's not supposed to return any inherited methods.

This works fine when I install my app directly via Android Studio, regardless of the active build variant . Switching to a release build is not sufficient to trigger the problem.

The problem arises when compiling an APK or App Bundle (.aab) and installing the app that way. (Either directly by copying the APK onto a device, or rolling out the bundle on the Google Play Store and installing the app from there.)

Here's my test scenario, in a fresh Android Studio project, using SDK 33, minSdk 21 (Android 5.0), minifyEnabled false , and the default proguardFiles statement deleted, to make sure this isn't caused by R8 / ProGuard.

The interface:

// TestInterface.java

package com.example.testapp;

public interface TestInterface {
    default String methodWithDefault() {
        return "default";
    }

    String methodWithoutDefault();
}

The implementing class:

// TestClass.java

package com.example.testapp;

public class TestClass implements TestInterface {
    @Override
    public String methodWithoutDefault() {
        return "non-default";
    }
}

The test case:

// MainActivity.java

package com.example.testapp;

import android.os.Bundle;
import android.widget.TextView;

import androidx.appcompat.app.AppCompatActivity;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TestClass test = new TestClass();
        StringBuilder sb = new StringBuilder("Methods:\n");
        for (Method m : TestClass.class.getDeclaredMethods()) {
            sb.append('\n').append(m.toString()).append('\n');
            try {
                String s = (String) m.invoke(test);
                sb.append("Result: ").append(s).append('\n');
            } catch (InvocationTargetException e) {
                sb.append("Target exception: ").append(e.getTargetException()).append('\n');
            } catch (IllegalAccessException e) {
                sb.append("Illegal access.\n");
            }
        }

        System.out.println(sb);

        TextView textView = findViewById(R.id.textView);
        textView.setText(sb.toString());
    }
}

Contents of app/build.gradle :

plugins {
    id 'com.android.application'
}

android {
    namespace 'com.example.testapp'
    compileSdk 33

    defaultConfig {
        applicationId "com.example.testapp"
        minSdk 21
        targetSdk 33
        versionCode 1
        versionName "1.0"
    }

    buildTypes {
        release {
            minifyEnabled false
        }
    }
    compileOptions {
        sourceCompatibility 11
        targetCompatibility 11
    }
}

dependencies {
    implementation 'androidx.appcompat:appcompat:1.5.1'
    implementation 'com.google.android.material:material:1.7.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
}

Output when running directly from Android Studio:

Methods:

public java.lang.String com.example.testapp.TestClass.methodWithoutDefault()
Result: non-default

Output when building an APK and installing it on the device:

Methods:

public java.lang.String com.example.testapp.TestClass.methodWithDefault()
Result: default

public java.lang.String com.example.testapp.TestClass.methodWithoutDefault()
Result: non-default

Questions:

1. Why does this happen?
2. What's the best way to work around it?

Answer 1

In typical rubber-duck debugging fashion, I found out some important details and how to work around this while improving the test-case before posting it on StackOverflow...

First, let's have some properties of the methods printed as well. We can modify MainActivity as follows:

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TestClass test = new TestClass();
        StringBuilder sb = new StringBuilder("Methods:\n");
        for (Method m : TestClass.class.getDeclaredMethods()) {
            sb.append('\n').append(m.toString()).append('\n');
            sb.append("Synthetic: ").append(m.isSynthetic()).append('\n');
            sb.append("Bridge: ").append(m.isBridge()).append('\n');
            sb.append("Default: ").append(m.isDefault()).append('\n');
            try {
                String s = (String) m.invoke(test);
                sb.append("Result: ").append(s).append('\n');
            } catch (InvocationTargetException e) {
                sb.append("Target exception: ").append(e.getTargetException()).append('\n');
            } catch (IllegalAccessException e) {
                sb.append("Illegal access.\n");
            }
        }

        System.out.println(sb);

        TextView textView = findViewById(R.id.textView);
        textView.setText(sb.toString());
    }
}

This makes Android Studio complain, because isDefault() is only available starting from SDK 24, but our minSdk is 21.

Let's increase minSdk to 24 and check the output:

Methods:

public java.lang.String com.example.testapp.TestClass.methodWithoutDefault()
Synthetic: false
Bridge: false
Default: false
Result: non-default

Oh, the inherited method is gone, If you play around with minSdk. you'll realize the issue appears with any value <= 23, So: we make the first important realization:

1. The problem only arises if minSdk is less than 24.

(Note that the actual SDK version of the Android device on which you're installing the APK doesn't seem to matter; I'm testing this all on an SDK 25 / Android 7.1.1 device.)

Let's switch back to minSdk 21, and make the call to isDefault conditional on an SDK version check, like so:

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TestClass test = new TestClass();
        StringBuilder sb = new StringBuilder("Methods:\n");
        for (Method m : TestClass.class.getDeclaredMethods()) {
            sb.append('\n').append(m.toString()).append('\n');
            sb.append("Synthetic: ").append(m.isSynthetic()).append('\n');
            sb.append("Bridge: ").append(m.isBridge()).append('\n');
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                sb.append("Default: ").append(m.isDefault()).append('\n');
            }
            try {
                String s = (String) m.invoke(test);
                sb.append("Result: ").append(s).append('\n');
            } catch (InvocationTargetException e) {
                sb.append("Target exception: ").append(e.getTargetException()).append('\n');
            } catch (IllegalAccessException e) {
                sb.append("Illegal access.\n");
            }
        }

        System.out.println(sb);

        TextView textView = findViewById(R.id.textView);
        textView.setText(sb.toString());
    }
}

This yields the following output when installing the new APK on a device with SDK version 24 or newer:

Methods:

public java.lang.String com.example.testapp.TestClass.methodWithDefault()
Synthetic: true
Bridge: false
Default: false
Result: default

public java.lang.String com.example.testapp.TestClass.methodWithoutDefault()
Synthetic: false
Bridge: false
Default: false
Result: non-default

Confusingly, the method is not marked as default. But it's marked as synthetic, so:

2. We can filter out the inherited methods via Method.isSynthetic() .

So, to answer our questions:

1. Why does this happen?

I suppose the synthetic method is being generated when minSdk is less than 24 because the APK could be installed on an older Android device which doesn't have "direct" support for default interface methods in its JVM.

When installing the app directly via Android Studio, I guess the minSdk value is ignored, since Android Studio can check what the actual version of the device is.

If anyone has more exact information, please share.

2. What's the best way to work around it?

The inherited default methods can be filtered out by calling isSynthetic() on them, which will return true .

If you want to keep some other synthetic methods and only filter out these ones, I don't know how to achieve that, but that should be an exceedingly rare situation.