Design

The problem with getName is already mentioned in the comments. firstName + lastName is at least missing a space. Note that there are multiple ways of creating a full name - you may want to leave the construction of a full name to the caller. For instance, Germans are a bit more formal and may prefer "lastname, firstname". Usually initials are also an important part of a name (and then there is title, junior/senior etc.).

Second is the age. An age is a property of a person, but it is not one that keeps constant in time. You generally store the birthday of a person. Usually the precise day is stored (YYYY-MM-DD), or in more complex systems just the month (YYYY-MM) or even just the year (YYYY) if the other information is unknown. This may seem strange, but not everybody knows their exact birthday. The age can then be calculated from that using comparison with the current date.

Related, using 0 to signify that no age is known is choosing a bad magic value (or sentinel). Magic values are already not recommended, but choosing a valid age for a baby as magic value is not a good idea at all.

Returning return NO_ADDRESS; is dangerous, especially if you don't have any method to indicate that NO_ADDRESS is indeed not an address. It is generally up to the caller to choose what to insert as string if no address is known, otherwise you may get packages posted to NO_ADDRESS. A hasAddress method would solve this. If you have an unknown address then you may use an Optional value instead. Accepting and returning an Optional<String> would remove the issue altogether and may bring down the number of methods and constructors. Storing the address as optional is not recommended because it cannot be serialized; probably best to use null, but make sure that you don't return null.

As you may notice, currently your Person instances can change completely by calling the setters. That's no good if you want to keep track of a person. This is why almost all organizations will create a unique ID for each person. That way any property can change without them becoming someone else. The ID can then represent the person in e.g. a transaction system.

Code

The code is generally well formed.

However there are some remarks to be made:

• fields default to false so there is no need to initialize them to that value; it might be a good idea to set all fields in the various constructors so that they are not forgotten;
• the if statement does not use braces; always use braces to subsequent changes do not result in unmaintainable code;
• similarly, you will probably use class instances in collections, so you need to implement the hashCode and equals methods;
• implementing toString is recommended for any class really.

Ideas

Using set methods is generally not a good idea. Having immutable objects often makes more sense. Other variants you may consider is having a Map of properties or having a factory / factory methods to create Person instances.

In Java, you may want to implement Serializable for data classes (and the static serializable UID - Eclipse will warn you about this) - that way you can more easily communicate data over a binary connection / stream. This is contended in the comments. In general, I would however try and keep in mind that you may want to be able to serialize a class in the future and - therefore - try and use serializable fields.

Someone else already discussed this, but I would get rid of the boolean members hasAge and hasAddress. They don't really provide any information that the fields themselves don't provide.

An issue regarding the boolean flags is that you never update them, so they will be invalid once you use the setters. This is just a good demonstration of why you would be better off without them: they will eventually become inconsistent from the actual field state.

Instead of setting the address to a string saying no address available, just set it to an empty string or null and let the caller decide how to handle it. You could also add a hasAddress method that checks if the string is empty/null. An empty age could be signified as -1, assigned to a constant.

Also, instead of several different constructors, you could use the fluent builder pattern:

public class Person {

    private static final int EMPTY_AGE = -1;
    private static final String EMPTY_ADDRESS = "";

    private String firstName, lastName, address;
    private int age;

    public static class PersonBuilder {
        private String firstName = null, lastName = null, address = EMPTY_ADDRESS;
        private int age = EMPTY_AGE;
        public PersonBuilder firstName(String firstName) {
            this.firstName = firstName;
            return this;
        }
        public PersonBuilder lastName(String lastName) {
            this.lastName = lastName;
            return this;
        }
        public PersonBuilder address(String address) {
            this.address = address;
            return this;
        }
        public PersonBuilder age(int age) {
            this.age = age;
            return this;
        }
        public Person build() {
            Objects.requireNonNull(firstName);
            Objects.requireNonNull(lastName);
            return new Person(firstName, lastName, address, age);
        }
    }

    public static PersonBuilder builder() {
        return new PersonBuilder();
    }

    private Person(String firstName, String lastName, String address, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.address = address;
    }

    public String getName() {
        return firstName + lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public String getAddress() {
        return address;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setAddress(String address) {
        this.address = address;
    }

}

Now, you can build a Person like this:

Person.builder().firstName("John").lastName("Doe").age(25).address("1234 Some Road").build();

This is especially helpful when the class has more fields.

Besides being easier to read when constructing it, the builder pattern

• Removes the possibility of mixing up constructor fields
• Allows specifying the fields in any order
• Guarantees the Person object returned will be valid. The build method will refuse to construct the object when required fields are missing. (This checking could alternatively be done in Person's constructor.)

Instead of adding a boolean to check if the value is set, I suggest that you set the values with a default value; so if the value is not set, it will return it.

public class Person {
  private String firstName;
  private String lastName;
  private String address = "No address defined";
  private int age = 0;

//Constructors

  //Minimum information required
  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  //All possible info
  public Person(String firstName, String lastName, int age, String address) {
    this(firstName, lastName);
    this.age = age;
    this.address = address;
  }

  //No address defined
  public Person(String firstName, String lastName, int age) {
    this(firstName, lastName);
    this.age = age;
  }

  //No age defined
  public Person(String firstName, String lastName, String address) {
    this(firstName, lastName);
    this.address = address;
  }

//Methods

  //Get-methods
  public String getName() {
    return firstName + lastName;
  }

  public String getFirstName() {
    return firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public int getAge() {
    return age;
  }

  public String getAddress() {
    return address;
  }

  //Set-methods
  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public void setAddress(String address) {
    this.address = address;
  }
}

If you want to keep the same logic, put -1 as the age and null to the address and compare the value in the getter.

public class Person {
   private String firstName;
   private String lastName;
   private String address = null;
   private int age = -1;
   private static final String NO_ADDRESS = "No address defined";

//Constructors

   //Minimum information required
   public Person(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }

   //All possible info
   public Person(String firstName, String lastName, int age, String address) {
      this(firstName, lastName);
      this.age = age;
      this.address = address;
   }

   //No address defined
   public Person(String firstName, String lastName, int age) {
      this(firstName, lastName);
      this.age = age;
   }

   //No age defined
   public Person(String firstName, String lastName, String address) {
      this(firstName, lastName);
      this.address = address;
   }

//Methods

   //Get-methods
   public String getName() {
      return firstName + lastName;
   }

   public String getFirstName() {
      return firstName;
   }

   public String getLastName() {
      return lastName;
   }

   public int getAge() {
      if (age > 0)
         return age;
      else
         return 0; //Return 0 if no age is defined
   }

   public String getAddress() {
      if (address != null)
         return address;
      else
         return NO_ADDRESS;
   }

   //Set-methods
   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }

   public void setLastName(String lastName) {
      this.lastName = lastName;
   }

   public void setAge(int age) {
      this.age = age;
   }

   public void setAddress(String address) {
      this.address = address;
   }
}

I'm adding just some thoughts to explain how I would solve the problem: assuming in the simplest scenario you have two fields firstName and lastName that must be always compiled when you create a Person object then the simplest way is have to have a constructor that takes them as parameters:

public class Person {
    private String firstName;
    private String lastName; 

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName  = lastName;
    }
    //getters and setters omitted for brevity
}

After you have two fields address and age that in one or more moments of the life of your objects can be null, to signal this situation to the user of your Person class you chose to return the values "No address defined" and 0 like the code below:

private static final String NO_ADDRESS = "No address defined";
public int getAge() {
    if (hasAge)
           return age;
    else
           return 0; //Return 0 if no age is defined
}
public String getAddress() {
    if (hasAddress)
           return address;
    else
           return NO_ADDRESS;
}

I disagree with your choice because the user of your class Person is obliged to know the value of String "No address defined" to identify which address is valid and which not with String.equals method and for me 0 is a valid value for age. My possible solution is the use of Optional and OptionalInt for address and age like my code below:

public class Person {
    private String firstName;
    private String lastName; 
    private String address;
    private Integer age; //<-- better use int age, see note for details

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public Optional<String> getAddress() {
        return Optional.ofNullable(address);
    }

    public OptionalInt getAge() {
        return OptionalInt.of(age);
    }

   //others setters and getters omitted for brevity
}

In this way the user of your class Person is forced to check if the fields address and age are set before using them:

Person person = new Person("firstName", "lastName");
person.setAddress("address");
person.setAge(10);
Optional<String> optAddress = person.getAddress();
if (optAddress.isPresent()) {
    System.out.println(optAddress.get());
}
OptionalInt optAge = person.getAge();
if (optAge.isPresent()) {
    System.out.println(optAge.getAsInt());
}

Note: following @Nathan's comment below, instead of use Integer for age field it is better to use directly int to avoid boxing and unboxing operations.

As well as a missing separator, there's a missing null check here:

public String getName() {
    return firstName + lastName;
}

Don't fall into the trap of assuming that all people have a first name and a last name; some have only one of those. And some have different names in different contexts (e.g. pen-name/stage-name as well as a formal (passport) name).

Other code may be making assumptions that first name (or last name) is a "family name", but that's not certain either - read Falsehoods Programmers Believe About Names to pick up some other assumptions that might not be true.

Something the other answer(s) haven't touched on.

Ternary Operators

getAge() and getAddress() can both be simplified using ternary operators:

public int getAge() {
    return age > 0 ? age : 0;
}

public String getAddress() {
    return address != null ? address : NO_ADDRESS;
}

Ternary works as following (in this case):

return (boolean condition) ? (value if true) : (value if false);

It's a shorter way to write the same code, and it looks a bit neater.

Also, always use brackets, even in a one line if/else. It made everything easier to read and understand, especially since you switch between the two in multiple places in your code.