base and subclass constructor issues

I have been experimenting with Classes in Java over the last few days, learning about them from "TheNewBoston" on youtube and from the java docs.

I have created the following scenario and seek your guys' (girls too) professional criticism and in depth knowledge regarding a few questions I have.

There are two classes, person and person_financial, a base class an开发者_运维技巧d sub class respectively.

person class:

public class person {

private String name;
private String sex;
private int age;
private double height;
private double weight;
private double intelligence;

// person constructor arguments order: name, height, weight, age, sex, intelligence
public person(){
    this("noname",0,0,0,"undefined",5);
}
public person(String n){
    this(n,0,0,0,"undefined",5);
}
public person(String n, double h){
    this(n,h,0,0,"undefined",5);
}
public person(String n, double h, double w){
    this(n,h,w,0,"undefined",5);
}
public person(String n, double h, double w, int a){
    this(n,h,w,a,"undefined",5);
}
public person(String n, double h, double w, int a, String s){
    this(n, h, w, a, filterSex(s), 5);
}
public person(String n, double h, double w, int a, String s, double i){
    name = n;
    height = h;
    weight = w;
    age = a;
    sex = filterSex(s);
    intelligence = i;
}

public void setName(String n){
    name = n;
}
public void setHeight(double h){
    height = h;
}
public void setWeight(double w){
    weight = w;
}
public void setAge(int a){
    age = a;
}
public void setSex(String s){
    sex = filterSex(s);
}
public void setIntel(double i){
    intelligence = i;
}

public String getName(){
    return name;
}
public double getHeight(){
    return height;
}
public double getWeight(){
    return weight;
}
public int getAge(){
    return age;
}
public String getSex(){
    return sex;
}
public double getIntel(){
    return intelligence;
}

public String getInfo(){
    return String.format("Name: %s,\nSex: %s,\nAge: %d,\nIntelligence: %.2f,"
            + "\nHeight: %.2f,\nWeight: %.2f\n", name, sex, age,
            intelligence, height, weight);
}

private static String filterSex(String s){
    return ((s.equalsIgnoreCase("male") ||
             s.equalsIgnoreCase("female")) ? s : "undefined");
}
}

person_financial class:

public class person_financial extends person {

private double monies = 0;

public void definePerson(String n, int a, String s, double i, double h, double w){
    setName(n);
    setAge(a);
    setSex(s);
    setIntel(i);
    setHeight(h);
    setWeight(w);
}

public person_financial() {
    this(0);
}

public person_financial(double m) {
    monies = m;
}

public void depositMonies(double m) {
    monies += m;
}

public void withdrawlMonies(double m) {
    if (m <= monies) {
        monies -= m;
    }
}

public double getBalance() {
    return monies;
}
}

and then in the main class I have this:

public class Main {

public static void main(String[] args) {

    person p1 = new person("I have no Name", 180, 72, 38, "Alien", 7.2);
    System.out.println(p1.getName());


    person_financial pf1 = new person_financial(100.00);
    pf1.depositMonies(50.02);
    System.out.printf("%s has %.2f monies.\n", pf1.getName(), pf1.getBalance());

    pf1.definePerson("some_name", 42, "male", 10, 180, 72);
    System.out.println(pf1.getInfo());
}
}

in the person_financial class, I have made a method called "definePerson()" which I use to define all the characteristics that would otherwise have been defined from the 'person()' constructor from the 'person' class. I'm sure there is a more professional way for assigning values to variables in a base class from a sub class, I just dont know of any...

Also, is there any way to call the constructor from the "person" class to define characteristics for 'pf1'? rather than having to, for example, manually set each attribute, i.e. pf1.setName("something"); , or pf1.setAge(1000000); etc... or have a method do it for me, as in 'definePerson()'.

Any help is much appreciated, Thanks =).

---

You use the super() call to call the constructor of the parent class. It has to be the first call in the constructor of the derived class, but you call it (and pass in arguments) like any other function and it will call the constructor that way.

---

It's common to declare a class 'abstract' to prevent creation of generic objects - based on your usage-code at the bottom you seem not to want that and that's fine. Just remember that you can declare declare a class abstract.

The best way to use class hierarchy is to ensure that (buzzword alert) any class in a useful hierarchy should be declarable as anythin in the hierarchy (i.e. you should be able to access any methods in your concrete object from the base-class (person in this case).

Your financial_person object extends person, but the ideal is to have a class that you can declare at a high level and call methods polymorphically. Consider for a minute that all people are able to draw and deposit money (different from your classes, but bear with me for a minute).

drawMoney method would exist in person, but be marked abstract - forcing the subclasses financial_person and regular_person to implement draw_money, deposit_money etc.

each class would have an implementation that suits their reality (financial person would have access to all kinds of special accounts, discounts etc., and regular_person would have a simpler set of - but still the same external behavior).

Then you could declare like this:

Person finPerson = new FinancialPerson(... etc.);
Person regPerson = new RegularPerson(....etc);

note now that you are able to do this code below:

finPerson.drawCash(12300.0);
regperson.drawCase(100.0);

The identical behavior.

You could have a List of thousands of people, and would not have to do if-then-else or switch statements to execute the finer-tuned behaviors of each.

The acid-test for class-hierarchy is this: "my (sub-class) really 'a kind of' (superclass)?"

In other words, "does my subclass have behaviors of the superclass?"

If not, you should think carefully about class hierarchy. There's a buzzword for this : Liskov Substitution Principle, and I cannot do a better job of this than Robert. C. Martin - one of the software-design gurus:

http://www.objectmentor.com/resources/articles/lsp.pdf

In this article he shows what happens when you have inadvisable hierarchy, using the "a square is a kind-of rectangle" example.

Google "template method pattern" for a summary of another aspect of effectively using inheritance. You will see that it is much more powerful than the simple inheritance that most people dismiss it as being.

Also remember that no single pattern is a silver-bullet for everything. Some people will call class-hierarchy evil and tell you to use interfaces only; others will say the reverse. There are choices to make, and sometimes they will not be obvious.

There are many pitfalls, and missing LSP is just one of them. Others are (examples only) overriding concrete methods, having concrete classes not marked final, enabling mutability of "identifying" fields (eg fields used in equals/hashcode, etc.) Imagine if "customer" objects at bank allowed resetting of first-name, or account-number at runtime, once these fields were already set).

My answer is more generally related to OO design, inheritance etc. than specific coding questions - hope it's of some use to you.