Java基础--面向对象3

1.方法的重写(OverWrite)

在子类中可以根据需要对从基类中继承来的方法进行重写。

重写方法必须和被重写方法具有相同方法名称，参数列表和返回类型

重写方法不能使用比被重写方法更严格的访问权限

public class Animal {    PRivate String name;    private int age;    public void setName (String name){        this.name = name;    }    public void setAge (int age){        this.age = age;    }    public String getName() {        return name;    }    public int getAge(){        return age;    }    public String getInfo(){        return "Name:"+name + "/n" +"age:" + age;    }}
public class Dog extends Animal{    private String color;    public void setColor(String school){        this.color = school;    }    public String getColor(){        return color;    }    public String getInfo(){                                                                                       //重写getInfo        return "Name:"+getName() + "/n"+ "age:" + getAge() + "/ncolor:"+ color;    }}
public class Test {    public static void main (String[] args){        Dog dog = new Dog();        Animal animal = new Animal();        animal.setAge(100);        animal.setName("coco");        dog.setAge(20);        dog.setName("coco1");        dog.setColor("black");        System.out.println(animal.getInfo());        System.out.println(dog.getInfo());    }}
结果为：
Name:cocoage:100Name:coco1age:20color:black
2.super关键字
在java类中使用suepr来引用基类的成分，this指的是当前对象的引用
super是当前对象的父类的引用
public class FatherClass {    public int value;    public void f(){        value = 100;        System.out.println("FatherClass.value="+value);    }}
public class ChildClass extends FatherClass{    public int value;    public void f(){        super.f();                                             //引用父类中的 f 方法        value = 200;        System.out.println("ChildClass.value="+value);        System.out.println(value);        System.out.println(super.value);                //父类中的value    }}
public class TestSuper {    public static void main (String agrs[]){        ChildClass c = new ChildClass();        c.f();    }}3.继承中的构造方法
有关构造方法的概念，参考面向对象1
子类的构造的过程中必须调用其基类的构造方法，可以使用 super(参数列表)  调用基类的构造方法，使用 this(参数列表)  调用本类的另外的构造方法，如果使用super，必须写在子类构造方法的第一行。
如果子类的构造方法中没有显示地调用基类构造方法，则系统默认调用基类无参数的构造方法。
如果子类的构造方法中既没有显式调用基类构造方法，而且基类中又没有无参的构造方法，则编译出错。
class SuperClass {    private int n;       SuperClass(){       System.out.println("SuperClass()");   }       SuperClass(int n) {       System.out.println("SuperClass(" + n + ")");       this.n = n;    }}
class SubClass extends SuperClass {    private int n;      SubClass(int n){                                                      //方法的重载      super();                                                                  //调用无参基类方法      System.out.println("SubClass(" + n + ")");      this.n = n;    }       SubClass(){     super(300);                                                             //调用基类方法     System.out.println("SubClass()");    }}
public class TestSuperSup {    public static void main(String arg[]) {       SubClass sc1 = new SubClass();       SubClass sc2 = new SubClass(400);    }}结果是：
SuperClass(300)SubClass()SuperClass()SubClass(400)4.JDK_API文件查询
http://tool.oschina.net/apidocs/
5.object类
Object类是所有Java类的根基类
如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类
toString方法
Object类定义有public  String toString()方法，其返回值是String类型，其描述当前对象的有关信息。
在进行String与其它类型数据的连接操作时(如：System.out.println("info"+person))，将自动调用该对象的toString()方法。
可以根据在用户自定义类型中重写toString()方法。
ToString的输出结果为hashcode： getClass().getName() +'@' +Integer.toHexString(hashCode())，hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值
例如：
public class TestToString {    public static void main(String agrs[]){        Mao dog = new Mao();        System.out.println(dog);    }}
class Mao{}结果为：学习.Mao@15db9742
因为不对tostring进行重写，返回的是哈希码，下面对tostring进行重写
class Mao{    public String toString(){        return "I'm a cool dog!";    }}结果是：I'm a cool dog!
equals方法
Object类中定义有：
public  boolean  equals(Objectobj)方法，提供定义对象是否相等的逻辑
Object的equals方法定义为：x.equala(y)当x和y是同一个对象的应用时返回true否则返回flase
J2SDK提供的一些类，如String，Date等，重写了Object的equals方法，调用这些类的equals方法，x.equals(y),当x和y所引用的对象是同一对象且属性内容相等时(并不一定是相同对象)，返回true否则返回false
可以根据需要在用户自定义类型中重写equals方法。
一种比较的方法：
public class Cat {    int color;    int height;    int weight;    public Cat (int color,int height,int weight){        this.color = color;        this.height = height;        this.weight = weight;    }}
public class TestEquals {    public static void main(String ages[]){        Cat c1 = new Cat(1,2,3);        Cat c2 = new Cat(1,2,3);        System.out.println(c1 == c2);        System.out.println(c1.equals(c2));    }}结果是：
flase 
flase         
对于"=="因为这种方法比较的方式是通过地址进行比较所以永远不会相同
对于equals的方法，其API是这样叙述的：for any non-null reference values x andy, this method returns true if and only if x and y refer to thesame object (x == y has the valuetrue).其实也是和等于的方式相同，必须是两个相同的对象，如果想是c1和c2相同，必须对equals进行重写
public class Cat {    int color;    int height;    int weight;    public Cat(int color, int height, int weight) {        this.color = color;        this.height = height;        this.weight = weight;    }    public boolean equals(Object obj) {        if (obj == null) return false;        else {            if (obj instanceof Cat) {                Cat c = (Cat) obj;                if (c.color == this.color && c.height == this.height && c.weight == this.weight) {                    return true;                }            }        }        return false;    }}
public class TestEquals {    public static void main(String ages[]){        Cat c1 = new Cat(1,2,3);        Cat c2 = new Cat(1,2,3);        System.out.println(c1.equals(c2));    }}结果是：true
另外的:
public class TestEquals {    public static void main(String ages[]){        String s1 = new String("hello");        String s2 = new String("hello");        System.out.println(s1 == s2);        System.out.println(s1.equals(s2));    }}结果是：
false 
 true