黑马程序员-面向对象（继承与多态）

classPerson{
privateintage;

publicvoidsetAge(inta){
if(a>0&&a<130){
age=a;
speak();
}else
System.out.println("feifaage");
}

publicintgetAge(){
returnage;
}

privatevoidspeak(){
System.out.println("age="+age);
}
}

classPersonDemo{
publicstaticvoidmain(String[]args){
Personp=newPerson();

//p.age=-20;
p.setAge(-40);
//p.speak();
}
}

classMainDemo{
publicstaticvoidmain(String[]args){
main(1);
}

publicstaticvoidmain(intargs)

{
System.out.println(args);
}
}

这个算不算重载呢，或者会不会发生重载？

当句子执行时候，虚拟机的内部的运行执行机制是如何的？

继承extends

Instancedof关键字：

classCat
{
publicvoideat()
{
System.out.println("吃鱼");
}
publicvoidcatchMouse()
{
System.out.println("抓老鼠");
}
}

classDog
{
publicvoideat()
{
System.out.println("吃骨头");
}
publicvoidkanJia()
{
System.out.println("看家");
}
}
//观察以上两个类，作为动物，都具有吃的本能，所以这个功能可以抽取出来，封装成抽象类，然后再进行继承
abstractclassclassAnimal
{
abstractvoideat();
}

多态的编译和运行的结果情况分析

classFu
{
staticintnum=5;
staticvoidmethod1()
{
System.out.println("fumethod_1");
}
staticvoidmethod2()
{
System.out.println("fumethod_2");
}
staticvoidmethod4()
{
System.out.println("fumethod_4");
}
}
classZiextendsFu{
staticintnum=8;
staticvoidmethod1()
{
System.out.println("zimethod_1");
}
staticvoidmethod3()
{
System.out.println("zimethod_3");
}
staticvoidmethod4()
{
System.out.println("zimethod_4");
}
}

classDuoTaiDemo4
{
publicstaticvoidmain(String[]args)
{
Fuf=newZi();//用父类的引用接收子类对象
f.method1();
f.method2();
f.method3();
}
}

那是为什么会出现这个情况呢（重点理解记忆）

重点注意，关于向上转型和向下转型：

在多态中成员函数的特点：（需要区分静态函数和非静态函数）

classFu
{
staticintnum=5;
}
classZiextendsFu
{
staticintnum=8;
}
classDuoTaiDemo4
{
publicstaticvoidmain(String[]args)
{
Fuf=newZi();//父类引用接收子类对象
System.out.println(f.num);//输出结果为父类的nun值
Ziz=newZi();
System.out.println(z.num);
}
}

其实这里是多态需要注意一下的地方

结论：

classA
{
voidshow()
{
System.out.println("a");
}
}
classB
{
voidshow()
{
System.out.println("b");
}
}
classCextendsA,B
{}

Cc=newC();
c.show();
//如果java允许支持这个多继承的话，上面的代码会让虚拟机出错，因为并不知道C中的show()是继承哪一个类，所以会报错
//下面说到多层继承，把以上代码修改一下
classA
{
voidshow()
{
System.out.println("a");
}
}
classBextendsA
{
voidmianPrint()
{
System.out.println("b");
}
}
classCextendsB
{}

Cc=newC();
c.show();

事物间的关系

重写(覆盖)

示例：

classCar

{

StringMyColor;

Car(){}//此处可能需要定义一个空参的构造方法，否则下面子类创建对象时可能会编译不通过

Car(StringMyColor)//有参数的构造方法

{

this.MyColor=MyColor;

}

publicvoidrun()

{

System.out.println("模型开动");

}

}

classBaoMaCarextendsCar

{

BaoMaCar(StringMyColor)

{

this.MyColor=MyColor;//如果用这一句，则对象初始化的时候会调用父类的空参构造方法，因为父类中已经定义了有参的构造方法，所以在编译的时候，编译器不会自动添加空参构造方法，所以必须要给父类定义一个空参的构造方法，否则编译报错

//super(MyColor);//可以如果用这一句，父类中可以没有空参的构造方法

}

publicvoidrun()

{

System.out.println("宝马开动");

}

}

classMyCarDemo

{

publicstaticvoidmain(String[]args)

{

Carc=retCar(1);

c.run();

}

publicstaticCarretCar(intnum)

{

if(num==1)

returnnewBaoMaCar("白色宝马");

if(num==2)

returnnewBaoShiJieCar("红色保时捷");

elsereturnnewCar("白色模型车");

}

}