对于上次小结的补充
我又来啦！想我了没？这次继续上次多态的分享嗷！
一、多态的好处和弊端
好处：提高了程序的扩展性；
定义方法时，使用父类作为参数，由子类具体实现；
弊端：不能使用子类的特有功能；
举例：
//测试类
public class user
{
public static void main(String[] args)
{
user u=new user();
animal a=new animal();
u.ss(a);
}
}
//实用类
public class user
{
user u=new user();
public void ss(animal a)
{
a.show();
}
}
//父类
public class animal
{
public void show()
{
cat c=new cat();
c.eat();
dog d=new dog();
d.eat();
pig p=new pig();
p.eat();
}
}
//子类-猫
public class cat extends animal
{
public void eat()
{
System.out.println("猫吃鱼");
}
}
//子类-狗
public class dog extends animal
{
public void eat()
{
System.out.println("狗吃骨头");
}
}
//子类-猪
public class pig
{
public void eat()
{
System.out.println("猪吃白菜");
}
};
二、多态中的转型
分为：向上转型和向下转型
animal a=new cat();//向上转型---不可以调用不输于animal中的成员方法
cat c=(cat)a;//强转为cat类，向下转型
举例：
//猫和狗案例
//测试类
public class test
{
public static void main(String[] args)
{
//猫--向上转型
animal a=new cat();
a.setname("加菲猫");
a.setage(5);
System.out.println(a.getname()+","+a.getage());
a.eat();
//狗--向下转型
animal b=new dog();
b.setname("史努比");
b.setage(3);
System.out.println(b.getname()+","+b.getage());
b.eat();
}
}
//父类
public class animal
{
private String name;
private int age;
public animal(){}
public animal(String name,int age)
{
this.name=name;
this.age=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 void eat()
{
System.out.println("动物吃东西");
}
}
//猫类
public class cat extends animal
{
public cat(){}
public cat(String name,int age)
{
super(name,age);
}
public void eat()
{
System.out.println("猫吃鱼");
}
}
//狗类
public class dog extends animal
{
public dog(){}
public dog(String name,int age)
{
super(name,age);
}
public void eat()
{
System.out.println("狗吃骨头");
}
}
三、抽象类
关键词：abstract--定义抽象类
若是一个类中存在抽象成员方法，那么该类为抽象类（不能够实例化），需要加上abstract关键字；
若某抽象类被继承，那么，它的子类需要继承父类的抽象成员函数，否则会报错；
在测试类中，不能直接调用抽象父类，它需要通过子类、多态进行调用；
举例：
//测试类
public class test
{
public static void main(String[] args)
{
animal a=new cat();//向下转型
a.eat();
a.sleep();
}
}
//抽象父类
public abstract class animal
{
public abstract void eat();
public void sleep()//抽象类中也可以有非抽象方法
{
System.out.println("睡觉");
}
}
//子类
public class cat extends animal
{
public void eat()
{
System.out.println("猫吃鱼");
}
}
四、接口--一种公共的规范准则
接口用interface定义；类需要用implements阐明它继承于一个接口；
而接口同样是一个抽象类，不能够直接调用，需要子类间接调用（接口不能实现实例化）;
(多态包括：具体类多态、抽象类多态、接口多态);
举例：
//测试类
public class test
{
public static void main(String[] args)
{
animal a=new cat();
a.jump();
}
}
//父类--动物类
public class interface animal
{
public abstract void jump();
}
//子类--猫类
public class cat implements animal
{
public void jump()
{
System.out.println("猫猫跳得很高！");
}
}
注意：
接口中的成员变量，默认被final和static修饰（即public static final为默认修饰符）
若某个类没有父类，则默认继承自Object类
接口不能有构造方法；（public class cat implements animal<==>public class cat implements animal)
接口中，不能有非抽象方法（接口中的成员方法，默认带有public abstract的修饰符）；
五、类与接口的关系
1类与类：继承关系-->单继承和多继承
2类与接口的关系：实现关系-->单实现和多实现，也可以在继承一个类时，使用多个接口；
public class test implements inter1,inter2,inter3{}//一个类对应多个接口
public class test extends Object implements inter1,inter2,inter3{}//一个类对应多个接口和类
3接口与接口的关系：继承关系-->单继承和多继承
public class interface inter1 extends inter2,inter3{}
注意：
抽象类是对于事物的抽象；
接口是对于行为的抽象；
举例：
已知有乒乓球运动员、篮球运动员、乒乓球教练和篮球教练，为了出国交流，与乒乓球有关的人员均需要学习英语，对此案例进行分析，并敲出相应的代码。
//测试类
public class test
{
public static void main(String[] args)
{
//乒乓球运动员
ppy p=new ppy();
p.setname("lily");
p.setage(19);
System.out.println(p.getname()+","+p.getage());
p.eat();
p.learn();
p.learne();
//篮球运动员
ly l=new ly();
l.setname("wangwu");
l.setage(21);
System.out.println(l.getname()+","+l.getage());
l.eat();
l.learn();
//篮球教练
basj b=new basj();
b.setname("lisi");
b.setage(23);
System.out.println(b.getname()+","+b.getage());
b.eat();
b.teach();
//乒乓球教练
pp a=new pp();
a.setname("liuqing");
a.setage(13);
System.out.println(a.getname()+","+a.getage());
a.eat();
a.teach();
a.learne();
}
}
//总抽象类--人
public abstract class person
{
private String name;
private int age;
person(){}
person(String name,int age)
{
this.name=name;
this.age=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 abstract void eat();
}
//次抽象类--运动员
public abstract class ydy extends person
{
ydy(){}
ydy(String name,int age)
{
super(name,age);
}
public abstract void learn();
}
//次抽象类--教练
public abstract class jl extends person
{
jl(){}
jl(String name,int age)
{
super(name,age);
}
public abstract void teach();
}
//接口
public interface studye
{
public abstract void learne();
}
//篮球教练类
public class basj extends jl
{
basj(){}
basj(String name,int age)
{
super(name,age);
}
public void teach()
{
System.out.println("篮球教练教如何运球和投篮");
}
public void eat()
{
System.out.println("篮球教练吃羊肉，和羊奶");
}
}
//乒乓球教练类
public class pp extends jl implements studye
{
pp(){}
pp(String name,int age)
{
super(name,age);
}
public void teach()
{
System.out.println("乒乓球教练教如何发球和接球");
}
public void eat()
{
System.out.println("乒乓球教练吃小白菜，和大米粥");
}
public void learne()
{
System.out.println("乒乓球教练学习英语");
}
}
//篮球运动员类
public class ly extends ydy
{
ly(){}
ly(String name,int age)
{
super(name,age);
}
public void learn()
{
System.out.println("篮球运动员学习如何运球和投篮");
}
public void eat()
{
System.ot.println("篮球运动员吃牛肉，和牛奶");
}
}
//乒乓球运动员类
public class py extends ydy implements studye
{
py(){}
py(String name,int age)
{
super(name,age);
}
public void learn()
{
System.out.println("乒乓球运动员学习如何发球和接球");
}
public void eat()
{
System.out.println("乒乓球运动员吃大白菜，和小米粥");
}
public void learne()
{
System.out.println("乒乓球运动员学习英语");
}
}
