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

1.Object类

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

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

piblicclassPerson{

}

等价于:

publicclassPersonextendsObject{

}

(1)toString方法:

a.Object类中定义有public.StringtoString()方法，其返回值是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）。

classDog{
publicStringtoString(){//注意:重写toString方法"publicStringtoString()"
return"I'macooldog";
}
}
publicclassTexttostring{
publicstaticvoidmain(String[]args){
Dogd=newDog();
System.out.println("d:"+d);//System.out.println("d:"+d);等价于System.out.println("d:"+d.toString());
}

}

输出结果:

d:I'macooldog

（2）equals方法:

（a）publicbooleanequals(Objectobj)方法，提供定义对象是否相等的逻辑。

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

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

classCat{
privateintcolor;
privateintheight;
privateintweight;
Cat(intcolor,intheight,intweight){
this.color=color;
this.height=height;
this.weight=weight;
}
publicbooleanequals(Objectobj){
if(obj==null)returnfalse;
else{
if(objinstanceofCat){//判断obj是不是Cat对象的引用
Catc=(Cat)obj;
if(c.color==this.color&&c.height==this.height&&c.weight==this.weight){
returntrue;
}
}
}
returnfalse;
}
}

publicclassTextEquals{
publicstaticvoidmain(String[]args){
Catc1=newCat(1,1,2);
Catc2=newCat(1,1,2);
System.out.println(c1==c2);//比较c1,c2的引用
System.out.println(c1.equals(c2));
Strings1=newString("Hello");
Strings2=newString("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）。

classAnimal{
publicStringname;
Animal(Stringname){
this.name=name;
}
}
classCatextendsAnimal{
publicStringeyecolor;
Cat(Stringname,Stringeyecolor){
super(name);
this.eyecolor=eyecolor;
}
}
classDogextendsAnimal{
publicStringfurcolor;
Dog(Stringname,Stringfurcolor){
super(name);
this.furcolor=furcolor;
}
}
publicclassTexttext{
publicstaticvoidmain(String[]args){
Texttexttext=newTexttext();
Animala=newAnimal("name");
Catc=newCat("catname","blue");
Dogd=newDog("dogname","black");
text.f(a);
text.f(c);
text.f(d);
}

publicvoidf(Animala){
System.out.println("name:"+a.name);
if(ainstanceofCat){
Catcat=(Cat)a;
System.out.println(cat.eyecolor+"\t"+"eyes");
}
elseif(ainstanceofDog){
Dogdog=(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父类对象指向子类对象。

classAnimal{
publicStringname;
Animal(Stringname){
this.name=name;
}
publicvoidenjoy(){
System.out.println("叫声.....");
}
}
classDogextendsAnimal{
privateStringfurcolor;
Dog(Stringname,Stringfurcolor){
super(name);
this.furcolor=furcolor;
}
publicvoidenjoy(){
System.out.println("狗叫声.....");
}
}
classBirdextendsAnimal{
privateStringfeathercolor;
Bird(Stringname,Stringfeathercolor){
super(name);
this.feathercolor=feathercolor;
}
publicvoidenjoy(){
System.out.println("鸟叫声......");
}

}
classCatextendsAnimal{
privateStringeyecolor;
Cat(Stringname,Stringeyecolor){
super(name);
this.eyecolor=eyecolor;
}
publicvoidenjoy(){
System.out.println("猫叫声....");
}

}
classLadyextendsAnimal{
privateAnimalmypet;
Lady(Stringname,Animalmypet){
super(name);
this.mypet=mypet;
}
publicvoidmypetenjoy(){
mypet.enjoy();
}

}
publicclassTextduotai{
publicstaticvoidmain(String[]args){
Catcat=newCat("shabi","yellow");
Dogdog=newDog("dashabi","pink");
Birdbird=newBird("xiaoshabi","purple");
Ladyl1=newLady("erbi",cat);
Ladyl2=newLady("daerbi",dog);
Ladyl3=newLady("xiaoerbi",bird);
l1.mypetenjoy();
l2.mypetenjoy();
l3.mypetenjoy();
}

输出结果:

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

4.抽象类（abstract）

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

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

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

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

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

abstractclassAnimal{
publicStringname;
Animal(Stringname){
this.name=name;
}
publicabstractvoidenjoy();
}
classDogextendsAnimal{
privateStringcolor;
Dog(Stringname,Stringcolor){
super(name);
this.color=color;
}
publicvoidenjoy(){
System.out.println("猫叫声....");
}
}
publicclassTextAbstract{
publicstaticvoidmain(String[]args){
//Animala=newAnimal();错误!抽象类不能被实例化;
Dogdog=newDog("abc","yellow");
dog.enjoy();
}
}

输出结果:

猫叫声....

5.Final关键字:

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

　　（a）final的成员变量；　　　　　　　publicvoidm（finalintj）　　//j的值不能在方法中赋值。

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

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

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

6.接口