Users Does Not Define No Argument Constructor

users does not define no argument constructor

JavaBeans require a no-argument constructor to be present.

When a Java class has no constructors at all, there is a default no-arg constructor automatically added to it by the compiler. The moment you define any constructor in the class, the default no-arg constructor goes away.

In your code, your users class defines such a constructor that contains arguments:

public users(String user_id, String address, String contact,String name) 
{}

As long as that constructor is present, and you don't define a no-arg constructor, that class will not have one.

To resolve this, you either need to remove that constructor from the class, or manually add a no-arg constructor to it:

public users() {}

....does not define a no-argument constructor?

In addition to @omodemilade-bamgbose's answer, you need to know basic fundamental of Java constructor.

Java basically provides default constructor(which takes no arguments) by default even if you did not define it.

However, in your case, you've already defined another constructor which takes some arguments. That causes you make JVM understand that you are not using default constructor.

Could not deserialize object. Class does not define a no-argument constructor.If you are using ProGuard, make sure these constructors are not stripped

First thing: It was not necessary to create the field (map type) called valorb. It was resolved with value.openPercent

As I have two documents (alarme and garagem) I created two POJO classes (FireFran and FireFranB)

https://github.com/neuberfran/JThingsFinal/blob/main/app/src/main/java/neuberfran/com/jfran/model/FireFranB.kt

The secret was to treat the value.on and value.openPercent fields as maps (as facts are):

Firebase Database: Getting No-Argument Constructor Error Despite Having It

The exception says your class is ozhan.climb.MainActivity$User - i.e., it is an inner class of MainActivity.

Inner classes require an instance of their outer class to construct. This won't work with Firebase Database, although the error message could definitely be improved.

Your User class should be a static class, which does not have the same requirement to exist only within the instance of a containing class:

static class User {
  ...
}

Class android.location.Location does not define a no-argument constructor

When the Firebase Realtime Database SDK deserializes objects coming from the database, it requires that any objects in use have a public no-argument constructor that it can use to instantiate the object. Fields in the objects are set by using setter methods or direct access to public members.

Android's Location object dosen't have a public no-arg constructor, so the SDK doesn't really know how to create an instance of it. In fact, most serialization libraries will have the same requirement. So, instead of using Android's Location object, use one of your own, copying data in and out of it as needed.

Firebase Realtime Database (Android-Java)- Class does not define a no-argument constructor

Finally it works by Using TestData as an independent class instead of an internal class. I made a new file TestData.java and moved its code there.

So finally DatabaseHelper loos like this:

public class DatabaseHelper {

private DatabaseReference mDatabase;
TestData result;

public DatabaseHelper() {
    mDatabase = FirebaseDatabase.getInstance().getReference();

    // We create a query
    Query query = mDatabase.child("TestData");

    //We recive query
    query.addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            for (DataSnapshot userSnapshot : dataSnapshot.getChildren()) {
                Log.w("datosdb", "Tenemos el resultado de la query.");
                try {
                    Log.w("datosdb", userSnapshot.toString());

                    // Deserializing only name
                    String name = userSnapshot.child("name").getValue(String.class);
                    Log.w("datosdb", "String is here!!!" + name);

                    // Deserializing only phone
                    long phone = userSnapshot.child("phone").getValue(Long.class);
                    Log.w("datosdb", "Long is here!!!" + phone);

                    // Deserializing into a TestData object
                    TestData result = userSnapshot.getValue(TestData.class);
                    Log.w("datosdb", "Parse success!!!");

                } catch (Exception e) {
                    Log.w("datosdb", "Parse failed", e);
                }
            }
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
            // Getting Post failed, log a message
            Log.w("datosdb", "loadPost:onCancelled", databaseError.toException());
            // ...
        }
    });

}

}

And TestData looks like this (on its own .java file now):

public class TestData {
private String name;
private long phone;

public TestData(){}

public TestData(String name, long phone){
    this.name = name;
    this.phone = phone;
}

public String getName() {
    return this.name;
}

public void setName(String name) {
    this.name = name;
}

public long getPhone() {
    return this.phone;
}

public void setPhone(long phone) {
    this.phone = phone;
}

}

---

Related Topics