黑马程序员_面向对象_继承多态

/**
 * 面向对象_继承多态
 * 面向对象中对于类之间存在单继承，并不存在多继承，但可以多层继承
 * 子类继承父类的所有非私有化成员，调用时使用super调用，子类可以重写父类的方法
 * 构造方法：
 * 子类的所有构造方法必须访问父类的构造方法，子类的构造方法中第一行默认给出super()
 * 若父类没有空参构造方法，子类需要用super手动给出父类的构造方法的调用
 *
 * 重写：
 * 子类重写父类方法时，方法名要相同,子类的权限修饰符要大于或等于父类的权限修饰符，
 * 当返回值类型为类类型时，子类的返回值类型需要是父类返回值类型的子类
 * 子类重写父类方法的目的是为了程序的扩展性
 */
public class Demo3 {
String name;
Demo3(){}
Demo3(String name){
this.name=name;
}
public void eat(){
System.out.println("父类");
}
}
class Demo4 extends Demo3{
int age;
Demo4(){

}
Demo4(String name){
super(name);
}
Demo4(int age, String name){
super(name);
this.age=age;
}
public void eat(){
System.out.println("子类");
}
}
/**
 * 抽象类：
 * 抽象类需要用abstract声明
 * 抽象类中可以没有抽象方法，但是如果有的话，需要子类重写这个方法
 * 抽象类有构造方法，但是不能创建对象，构造方法是用来进行属性初始化的
 * 
 */
abstract class Person{
String name;
Person(){}
Person(String name){
this.name=name;
}
abstract void eat();
}
class Student extends Person{
void eat(){
System.out.println("重写了父类的方法");
}
}
/**
 * 接口：
 * 接口可以看做是抽象的更加彻底的抽象类
 * 接口中必须全部是抽象方法，子类必须重写接口的全部抽象方法
 * 接口中的属性和方法有固定格式
 * 属性：      public  static  final  数据类型  变量名  =值;
 * 方法：      public  abstract  返回值类型     方法名(参数列表....);
 * 类与接口之间的关系是实现关系  可以多实现  class A  implements interface  B,c,d
 * 接口与接口间是继承关系      可以多继承     interface B extends C,D
 * 
 */
class A implements B,C,D{
public void eat(){
System.out.println("重写");
}
public void drink(){
System.out.println("重写");
}
public void speak(){
System.out.println("重写");
}
}
interface B extends C,D{
void eat();

}
interface C{
void drink();
}
interface D{
void speak();
}
/**
 * 多态：
 * 继承的出现使类与类之间产生了关系，为多态提供了前提
 * 父类的引用指向了子类的对象          父类引用  变量名=new 子类对象();
 * 编译的时候看父类，运行的时候属性看父类，方法看子类，若子类重写了父类的方法，则执行子类的方法
 * 若没有则执行父类的方法
 * 父类  变量  =  new 子类();   子类类型自动提升为父类类型
 * 子类 变量 =  (子类) 提升为父类的变量       强制类型转换   向下转型
 * 向下进行类型的强转时，只能把父类类型的子类变量强转为子类提升为父类前的子类类型 
 * 如： Animal  animanl=new Cat();
 * Cat cat=(Cat)animal;
 * 否则会出现类型转换异常
 * 
 * 
 * 
 * 
 */
class Test3 
{
public static void main(String[] args) 
{
Fu f=new Zi();   //自动类型提升
f.show(); //执行子类方法
f.show2(); //执行父类方法
Zi z=(Zi)f; //强制类型转换，向下转型
z.show3(); //执行子类方法
}
}
class Fu
{
void show()
{
System.out.println("Fu show");
}
void show2(){
System.out.println("父类特有方法");
}

}
class Zi extends Fu
{

void show()
{
System.out.println("Zi show");
}
void show3(){
System.out.println("子类特有方法");
}

}