Java学习之面向对象(1.Object类，(1)toString方法，（2）equals方法，2.对象转型（casting），3.动态绑定与多态，4.抽象类(abstract)，5.Final关键字)

1.Object类

Object类是所有Java类的根基类;

如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类。

piblic class Person{

}

等价于:

public class Person extends Object{

}

(1)toString方法:

a.Object类中定义有public.String toString()方法，其返回值是String类型，描述当前对象的有关信息。

b.在运行String与其它类型数据的连续操作时（如：System.out.println("info"+person)），将自动调用该对象类的toString（）方法。

c.可以根据需要在用户自定义类型中重写toString()方法。

什么情况下要重写toString，object类里的toString只是把字符串的直接打印，数字的要转化成字符再打印，而对象，则直接打印该对象的hash码。所以当你要想按照你想要的格式去字符串一些对象的时候，就需要重写toString了。比如一个Student对象，直接toString肯定是一个hash码。然而你想得到的比如是：name：***，age：***。这时就重写toString就是在toString里写：System.out.println（“name:”+student.getName）；
System.out.println（“age:”+student.getAge）。

class Dog{
public String toString(){                                             //注意:重写toString方法 "public String toString()"
return "I'm a cool dog";
}
}
public class Texttostring {
public static void main(String[] args){
Dog d=new Dog();
System.out.println("d:"+d);                                       //System.out.println("d:"+d);等价于System.out.println("d:"+d.toString());
}

}

输出结果:

d:I'm a cool dog

（2）equals方法:

（a）public boolean equals(Object obj)方法，提供定义对象是否相等的逻辑。

（b）Object的equals方法定义为：x.equals(y)，当x和y是同一个对象的应用时返回true否则返回false。

（c）可以格局需要在用户自定义类型中重写object方法。

class Cat{
    private int color;
    private int height;
    private int weight;
    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){                                     //判断obj是不是Cat对象的引用
                Cat c=(Cat)obj;
                if(c.color==this.color&&c.height==this.height&&c.weight==this.weight){
                    return true;
                }
            }
        }
        return false;    
    }
}

public  class TextEquals {
public static void main(String[] args){
    Cat c1=new Cat(1,1,2);
    Cat c2=new Cat(1,1,2);
    System.out.println(c1==c2);                                      //比较c1,c2的引用
    System.out.println(c1.equals(c2));
    String s1=new String("Hello");
    String s2=new String("Hello");
    System.out.println(s1==s2);　　　　　　　　　　　　　　　　　　　　　　//比较s1,s2的引用
    System.out.println(s1.equals(s2));
    }
}

 输出结果:

false
true
false
true

2.对象转型（casting）：

（a）一个基类的引用类型变量可以“指向”其子类的对象。

（b）一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）。

（c）可以使用变量instanceof类名，来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。

（d）子类的对象可以当作基类的对象来使用称作向上转型（upcasting），反之称为向下转型（downcasting）。

class Animal{
    public String name;
    Animal(String name){
        this.name=name;
    }
}
class Cat extends Animal{
    public String eyecolor;
    Cat(String name,String eyecolor){
        super(name);
        this.eyecolor=eyecolor;
    }
}
class Dog extends Animal{
    public String furcolor;
    Dog(String name,String furcolor){
        super(name);
        this.furcolor=furcolor;
    }
}
public class Texttext {
public static void main(String[] args){
    Texttext text=new Texttext();
    Animal a=new Animal("name");
    Cat c=new Cat("catname","blue");
    Dog d=new Dog("dogname","black");
    text.f(a);
    text.f(c);
    text.f(d);
}

    public void f(Animal a){
        System.out.println("name:"+a.name);
        if(a instanceof Cat){
            Cat cat=(Cat)a;
            System.out.println(cat.eyecolor+"\t"+"eyes");
        }
            else if(a instanceof Dog){
                Dog dog=(Dog)a;
                System.out.println(dog.furcolor+"\t"+"fur");
                
            }
        }
    }
    

输出结果：

name:name
name:catname
blue eyes
name:dogname
black fur

3.动态绑定与多态

（a）动态绑定是指在执行期间（而非编译期）判断所引用对象的实际类型，根据其实际的类型调用相应的方法。

（b）多态的存在有3个必要条件：1.要有继承；2.要有重写；3父类对象指向子类对象。

class Animal{
    public String name;
    Animal(String name){
        this.name=name;
    }
    public void enjoy(){
        System.out.println("叫声.....");
    }
}
class Dog extends Animal{
    private String furcolor;
    Dog(String name,String furcolor){
        super(name);
        this.furcolor=furcolor;
    }
    public void enjoy(){
        System.out.println("狗叫声.....");
    }
}
class Bird extends Animal{
    private String feathercolor;
    Bird(String name,String feathercolor){
        super(name);
        this.feathercolor=feathercolor;
    }
    public void enjoy(){
        System.out.println("鸟叫声......");
    }
    
}
class Cat extends Animal{
    private String eyecolor;
    Cat(String name,String eyecolor){
        super(name);
        this.eyecolor=eyecolor;
    }
    public void enjoy(){
        System.out.println("猫叫声....");
    }
    
}
class Lady extends Animal{
    private Animal mypet;
    Lady(String name,Animal mypet){
        super(name);
        this.mypet=mypet;
    }
    public void mypetenjoy(){
        mypet.enjoy();
    }
    
}
public class Textduotai {
public static void main(String[] args){
    Cat cat=new Cat("shabi","yellow");
    Dog dog=new Dog("dashabi","pink");
    Bird bird=new Bird("xiaoshabi","purple");
    Lady l1=new Lady("erbi",cat);
    Lady l2=new Lady("daerbi",dog);
    Lady l3=new Lady("xiaoerbi",bird);
    l1.mypetenjoy();
    l2.mypetenjoy();
    l3.mypetenjoy();
}

输出结果:

猫叫声....
狗叫声.....
鸟叫声.....

 4.抽象类（abstract）

 （a）用abstract关键字来修饰一个类时，这个类叫做抽象类；

　　　用abstract来修饰一个方法时，这个方法叫做抽象方法。

（b）含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。

（c）抽象类不能被实例化；

（d）抽象方法只需声明，而不需实现。

abstract class Animal{
    public String name;
    Animal(String name){
        this.name=name;
    }
    public abstract void enjoy();
}
class Dog extends Animal{
    private String color;
    Dog(String name,String color){
        super(name);
        this.color=color;
    }
    public void enjoy(){
        System.out.println("猫叫声....");
    }
}
public class TextAbstract {
public static void main(String[] args){
    // Animal a=new Animal(); 错误! 抽象类不能被实例化;
    Dog dog=new Dog("abc","yellow");
    dog.enjoy();
}
}

输出结果:

猫叫声....

5.Final关键字:

（1）final的变量的值不能够被改变。       

　　（a）final的成员变量；　　　　　　　public void m（final int j）　　   //j的值不能在方法中赋值。

　　（b）final的局部变量（形参）；　　　　　　  final int i=0；　　　　//i的值不能改变。

（2）final的方法不能够被重写。　　　　  public  final void m(){};            //m方法不能被重写。

（3）final的类不能够被继承。　　　　　　final clas T｛｝　　       　　 //　　T不能被继承。

6.接口