多态的好处和弊端案例（成员变量，成员函数，静态成员函数，接口）会用到instance

/*多态讲解
例如：平时都是看到一个猫看成一个猫这是常态，
猫：猫可以看成猫 猫 mao=new 猫();//这叫常态
其实猫可以看成父类，可以看成动物，例如：Animal 猫=new 猫();//这属于多态 
代码写如下
class Animal
{
}
class 猫 extends Animal
{}
多态：父类类型的引用指向了子类的类型的对象
多态的弊端：只能调用父类中的功能，子类的特用功能就不能再调用了
多态的好处:提提高了程序的扩展性，前期定义的功能可以被后期出现的事情使用。


*/
package item;
abstract class Animal 
{
public abstract void eat();
}
class Cat extends Animal
{
public void eat()
{
System.out.println("猫吃鱼");
}
public void catckMouse()
{
System.out.println("猫抓老鼠");
}
}
class Dogdt extends Animal
{
public void eat()
{
System.out.println("狗吃骨头");
}
public void lockHome()
{
System.out.println("狗看家");
}
}
public class TestPolymorphic {


/**
* @param args
*/
public static void main(String[] args) {
/*案例1：//常态的写法
Cat mao=new Cat();
mao.eat();
mao.catckMouse();

//案例2：如下是常态的写法
Animal cat=new Cat();
cat.eat();
// cat.catckMouse();//多态写这个会报错。因为父类中没有此方法
*/
// 案例3：在存在多态时，如何使用过子类特有的功能
/* Animal maomao =new Cat();
maomao.eat();
Cat cat1=(Cat)maomao;//向下转型，强制转换成
cat1.catckMouse();*/

//案例4：最终只需要写如下即可
Cat maomao=new Cat();
chi(maomao);

Dogdt dogtt=new Dogdt();
chi(dogtt);
/* 输出结果：
猫吃鱼
猫抓老鼠
狗吃骨头
狗看家*/
}
//如有又来个个猪和一个牛，他们都要吃，就要建立很多吃的函数，
//其实用如下就可以了。概述了所有动物都要吃
public static void chi(Animal animal)
{
animal.eat();
//判断这个对象属于什么类型的，一个对象具体属于那个类型的实例
//如下是判断naimal是否是Cat的是例。instance实例的意思，of是谁的意思
if(animal instanceof Cat)
{
Cat maocat=(Cat)animal;
maocat.catckMouse();
}
if(animal instanceof Dogdt)
{
Dogdt dogdt=(Dogdt)animal;
dogdt.lockHome();
}
}

/成员变量，成员函数，静态成员函数的使用多态的案例/

/*多态讲解
多态中成员的特点：
1：成员变量:编译时期可以访问哪些变量看父类,运行结果也是看父类
2：成员函数：编译时期可以访问哪些变量看父类,运行结果也是看子类（情况是：子类重写了父类的方法，没有重写还看父类）
3：静态成员函数：编译和运行都是看父类。
*/
package item;
class Fudt
{
int num=5;//成员变量
public void show()//成员函数案例
{
System.out.println("show fu");
}
public static void ff()
{
System.out.println("静态fu");
}
}
class Zidt extends Fudt
{
int num=6;
int a=7;
public void show()
{
System.out.println("show zi");
}
public void fun()
{
System.out.println("fun");
}
public static void ff()
{
System.out.println("静态测试");
}
}
public class TestPolymorphicy {


public static void main(String[] args) {
Fudt f=new Zidt();
// System.out.println(f.num);//还是父类中num
f.show();//只要重写了。那么调用的还是子类的
// f.fun();
f.ff();
} 
}

/接口使用多态使用案例/

/*接口使用多态的情况
 * */
package item;
interface inter
{
public abstract void show();
}
class Test1 implements inter
{
public void show()
{
System.out.println("test1");
}
}
class Test2 implements inter
{
public void show()
{
System.out.println("test2");
}
}


public class TestPolymorphicInterface {


/**
* @param args
*/
public static void main(String[] args) {
Test1 t1=new Test1();
shoprint(t1);

Test2 t2=new Test2();
shoprint(t2);

/* 输出结果：
test1
test2*/


}


public static void shoprint(inter t)//等于inter t=new Test1();
{
t.show();
}
}