0801-0807 多态 接口

多态：面向对象的第三种表现形式。

定义：可以理解为事物存在的多种体现形态。

总结：一个规律两个体现。

举例：人，分为男人和女人。动物，猫，狗，老虎。

猫 x = new 猫();

动物 x = new 猫();

以上是多态在对象上的体现。

多态还可以在函数中体现，当虚函数被重载、覆盖时，既可以理解为是多态。

重点讲对象的多态。

0.多态的体现

1.多态的前提

2.多态到底有什么好处

3.多态如何应用

------------------------------------------------------------------------------------------------------------------

需求：

对猫狗进行分 别描述。

抽取：

abstract class Animal 

{

public  abstract  void eat();

}

class Cat extends Animal

{

public void eat()

{

System.out.println("eat fish");

}

public void catchMouse()

{

System.out.println("catch");

}

}

class Dog extends Animal

{

public void eat()

{

System.out.println("eat bones");

}

public void watchHome()

{

System.out.println("watch Home");

}

}

class DuoTaiDemo

{

public static void main(String[] args)

{

Cat c = new Cat();

c.eat();

Cat c1 = new Cat();

c1.eat();

Dog d = new Dog();

d.eat();

function(new Cat());

}

public static void function(Animal c)

{

c.eat();

}//提高代码复用性

}

class Pig extends Animal

{

public void eat()

{

System.out.println("siliao");

}

public void gongDi()

{

System.out.println("gong di");

}

}

1.多态的体现

父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。

2. 多态的前提:

必须是雷雨类之间有关系，要么继承，要么实现。

通常还有一个前提：就是存在覆盖。（共同的成员方法，在某些函数里面实现，才实现了后期拓展性。）

3.多态的好处

多态有利于增强代码的拓展性。

4.多态的弊端：（局限性）

提高了拓展性，但是只能使用父类提供的共同的方法和变量。

------------------------------------------------------------------------------------------------------------------

class DuoTaiDemo

{

public static void main(String[] args)

{

Animal a = new Cat();//类型提升。回想当年，byte提升到int 的时候。。。（向上转型，转成父类 //型）

Animal a = new Cat();

a.eat();

Cat c = (Cat)a;//强制类型转换

c.catchMouth

}

}

既然能向上转型，就也有向下转型。

如果想调用猫的特有方法，如何操作？

强制将父类的引用转成子类类型。

Animal a = new Cat();

a.eat();

Cat c = (Cat)a;//强制类型转换

c.catchMouth();

小心。慎用向下转型（丢失精度的转型），这样可能不会得到预期的效果。如将一直猫转化为一只动物。

不要将父类对象转换成子类类型。可以将父类的引用转换成子类类型。

当父类的引用指向了自己子类的对象时，改因用可以被提升，也可以被转换。

Animal a = new Cat();//这就是父类引用指向子类对象。

当

Animal a = new Animal();这样的时候，就不能被提升也不能被转化。

多态自始至终都是子类对象再作变化。子类可以向上变化也可以向下变化。

举例：老师的例子。

毕老师和毕姥爷。

毕老师的父亲也会讲课（工商管理）

毕老师讲课（java）

有人来找毕姥爷讲课，毕姥爷不在家，毕老师在家。毕老师遍化装成毕姥爷的父亲，这是转型（提升）。

有人来拜访，看到转型之后的毕老师，会看到毕姥爷（提升后的毕老师）。

代码：

毕姥爷 x = new 毕老师();

x.讲课();

毕老师的讲课方法（java）复写了毕姥爷的讲课方法（工商管理）。

讲完课回家。毕老师的朋友来找毕老师看电影。

一进屋，看见了毕老爷。

x.看电影（）；//肯定不行，因为毕老师换装成了毕姥爷，没有看电影的方法。

所以需要转换。

毕老师 y = (毕老师)x;

//向下转型

自始至终都是毕老师（子类对象）在变化。

public static void function(Animal a)

{

a.eat();

Cat c = (Cat)a;

c.catchMouse();

}

如果传一个狗到a的位置，会编译成功，在运行的时候出现类型转换错误的提示。

public static void function(Animal a)

{

a.eat();

if (a instanceof Cat)

{

Cat c = (Cat)a;

c.catchMouse();

}

else if (a instanceof Dog)

{

Dog c = (Dog)a;

c.kanjia();

}

}

------------------------------------------------------------------------------------------------------------------

6.多态的出现代码中的特点（使用的注意事项）

需求：预热班 和 就业班的学员 都有学习 和 睡觉 的功能

class Student

{

abstract void study();

public void sleep()

{

System.out.println("lying sleep");

}

}

class baseStudent extends Student

{

public void study()

{

System.out.println(" base study");

}

public void sleep()

{

System.out.println("level2 sleep");

}

}

class advStudent extends Student{

public void study(){

System.out.println("study advanced");

}

}

class DuoTaiDemo3

{

public static void main(String[] args)

{

BaseStudent bs = new BaseStudent();

bs.study();

bs.sleep();

DoStudent ds = new DoStudent();

ds.doSome(new BaseStudent());//使用单独封装的类对学生进行操作

//也可以传advstu

}

}

class DoStudent

{//单独封装

public void doSome(Student stu)

{

stu.study();

stu.sleep();//已经提升了复用性

}

}

多态将对象调用变得简单了，使得原先需要挨个调用的对象变为批量操作。 

-记得将工具类抽取出来-

------------------------------------------------------------------------------------------------------------------

多态中成员的特点

class Fu

{

void method1()

{

System.out.println("fu method1");

}

void method2()

{

System.out.println("fu method2");

}

}

class Zi extends Fu{

void method1(){

System.out.println("zi method1");

}

void method3(){

System.out.println("zi method3");

}

}

错误示例：Fu   f = new Zi();

在多态中成员函数的特点：

在编译时期，参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有则编译失败。

在运行时，残月对象所属的类中是否有调用的方法。

简单总结就是：成员变量在多态调用时，编译看左边，运行看右边。

以上是   非 静 态 成员函数的特点（有重写特点）

面试题1

FU 中num = 5 

zi中num = 8

Fu f = new Zi(); 5

Zi z = new Zi(); 8

为什么父类引用指向子类对象，还是5？

在多态中，成员变量的特点：无论编译还是运行，都参考左边（引用变量所属的类）

面试题2

Fu中有Method4

Zi中有static method4 内容不一样

Fu f = new Zi();

f.method4();

运行结果：fu method4

在多态中，静态成员函数的特点，无论编译和运行，都参考左边。

从内存上解释，static会首先加载，单独存在于一片区域当中，并非动态创建，不属于某一个确切的对象。

总结：

非静态成员函数在多态时的特点：（父类引用指向子类对象）

编译的时候，左边是最小需求。如果左边有的右边都有，那么就可以通过。

运行的时候，右边是最小需求。如果右边调用的左边没有，则运行出错。

非静态成员变量在多态时的特点：

无论编译还是运行，都参考左边（引用变量所属的类）

静态成员函数在多态时的特点：

无论是编译还是运行都参考左边。

------------------------------------------------------------------------------------------------------------------

需求：

电脑运行实例

电脑运行基于主板。

class MainBoard

{

public void run()

{

System.out.println("main board run");

}

}

class DuoTaiDemo5

{

publi static void main(String[] args)

{

MainBoard mb = new MainBoard();

mb.run();

}

}

以上的程序拓展性差。想上网上不了，想听音乐听不了。

class MainBoard

{

public void run()

{

System.out.println("main board run");

}

public void useNetCard(NetCard c)

{

c.open();

}

}

class NetCard

{

public void open()

{

System.out.println("net open");

}

public void close()

{

System.out.println("net closed");

}

}

class DuoTaiDemo5

{

publi static void main(String[] args)

{

MainBoard mb = new MainBoard();

mb.useNetCard(new NetCard());

}

}

更新之后的设计思想：

interface PCI

{

public void open();

public void close();

}

class MainBoard

{

public void run()

{

System.out.println("mainBoard run");

}

public void usePCI(PCI P)

{

if( p != null)

{

p.open();

p.close();

}

}

}

class DuoTaiDemo5

{

public static void main(String[] args)

{

MainBoard mb = new MainBoard();

mb.run();

mb.usePCI(null);

mb.usePCI(new NetCard());

}

}

class NetCard implements PCI

{

public void open()

{

System.out.println("net open");

}

public void close()

{

System.out.println("net closed");

}

}

PCI p = new NetCard()//接口类型引用指向自己的子类。

------------------------------------------------------------------------------------------------------------------

多态的拓展示例

需求：数据库的操作。

数据：用户信息

1.连接数据库 JDBC Hibernate(框架连接)

2.操作数据库

C R U D create read update delete

3、关闭数据库连接

interface UserInfoDao

{

public void add(User user);

public void delete(User user);

}

class UserInfoByJDBC implements UserInfoDao{

public   void add(User user)

{

1.连接数据库

2.使用 sql进行操作

3.关闭连接

}

public   void delete(User user)

{

1.连接数据库

2.使用 sql进行操作

3.关闭连接

}

public   void update(User user)

{

1.连接数据库

2.使用 sql进行操作

3.关闭连接

} public  void delete(User user)

{

1.连接数据库

2.使用 sql进行操作

3.关闭连接

}

}

class

{

public static void main(String[] args)

{

UserInfoByJDBC ui = new UserInfoByJDBC();

{

ui.add(user);

ui.delete(user);

}

}

}

class DBOperate

{

public static void main(String[] args)

{

}

}

//接口可以对于程序内部屏蔽外界的改变，方便开发，降低了程序之间的耦合性。

左边随时改，右边不用变、。