多态 多态中成员函数的特点 interface 的应用

多态

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

当几个事物有共同方法时，我们可以将这个共同方法的定义提取出来，封装在一个新的抽象类中，并让这些类继承这个抽象类，子类覆写父类中的方法。此后，我们只需要将父类的引用指向子类，就可以通过子类对象调用父类的方法，实现子类的功能，提高了代码的复用性。

举例：客车，货车 都能运输，将运输工具功能定义提取出来，客车和货车分别在自己子类对运输内容具体化。我们就可以在调用运输工具中，根据对象，调用相应的功能呢。

猫 x = new 猫();

动物 x = new 猫();//一个对象，两种形态。

猫这类事物即具备者猫的形态，又具备着动物的形态。

这就是对象的多态性。

1多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接受自己的子类对象。

2多态的前提

必须是类与类之间有关心，要么继承，要么实现。

前提是， 父类的方法被子类方法覆盖。

3多态的好处

多态的出现大大提高了程序的扩展性。

4多态的弊端

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5多态的应用

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

abstract class Student
{
public abstract void study();
public void sleep()
{
System.out.println("躺着睡");
}
}

class DoStudent
{
public void doSome(Student stu)
{
stu.study();
stu.sleep();
}
}

class BaseStudent extends Student
{
public void study()
{
System.out.println("base study");
}
public void sleep()
{
System.out.println("蹲着睡");
}
}

class AdvStudent extends Student
{
public void study()
{
System.out.println("Adv study");
}
}

class Test
{
public static void main(String[] args)
{
DoStudent ds = new DoStudent();
ds.doSome(new BaseStudent());
ds.doSome(new AdvStudent());
}

}

类型转换

当我们需要使用子类特有对象时，只需要将父类引用的对象，向下转型为子类对象。就可以调用子类的特有方法。

Animal a= new Cat;
//类型提升,向上转型

a.eat();

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

//强制将父类的引用，转成子类的类型。向下转型。

Cat c=(Cat)a; //向下转型。

c.catchMouse();

//千万不要出现 将父类对象转成子类类型。

/*我们能转换的是父类应用指向了自己的子类对象时， Animal a= new Cat;

该对应可以被提升。也可以被转换*/

//多态自始至终都是子类对象在做着变化。

abstract class Animal
{
abstract void eat();
}

class Cat extends Animal
{
public void eat()
{
System.out.println("吃鱼");
}
public void catchMouse()
{
System.out.println("抓老鼠");
}
}

class Dog extends Animal
{
public void eat()
{
System.out.println("骨头");
}
public void kanJia()
{
System.out.println("看家");
}
}

public static void main(String[] args)
{
Animal a= new Cat;	//类型提升,向上转型
a.eat();
//如果想要调用猫的特有方法时，如何操作？
//强制将父类的引用，转成子类的类型。向下转型。
Cat c=(Cat)a;	//向下转型。
c.catchMouse();
//千万不要出现 将父类对象转成子类类型。
/*我们能转换的是父类应用指向了自己的子类对象时， Animal a= new Cat;
该对应可以被提升。也可以被转换*/
//多态自始至终都是子类对象在做着变化。

function(Cat c);
public static void function(Animal a)//Animal a= new Cat;
{
a.eat();
if (a instanceof Cat) //instanceof：用于判断对象的具体类型。只能用于引用数据类型判断
//通常在向下转型前用于健壮性的判断。
{
Cat c= （Cat）a;
c.catchMouse();
}
else if (a instanceof Dog)
{
Dog c= （Dog）a;
c.kanJia();
}
}
}
}

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

在编译时期，参阅引用型变量所属的类中是否有调用的方法。

如果有，编译通过。

如果没有，编译失败。

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

简单总结就是：[b]多态调用时：[/b]

成员函数

编译看父类是否有该方法，运行看子类的方法体。

静态成员函数：

无论编译和运行，都参考左边。

成员变量：

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

class Fu
{
int num= 1;
void method1()
{
System.out.println("fu method-1");
}
void method2()
{
System.out.println("fu method-2");
}
static void method4()
{
System.out.println("fu method-4");
}
}

class Zi extends Fu
{
int num = 2;
void method1()
{
System.out.println("Zi method-1");
}
void method3()
{
System.out.println("Zi method-3");
}
static void method4()
{
System.out.println("Zi	method-4");
}

}

class Test
{
public static void main(String[] args)
{
Fu f= new Zi();
f.method1();	//结果是Zi的method1，覆盖
f.method2();	//结果是Fu的method2.

//num全局变量
System.out.println(f.num);	//结果是Fu的num
Zi z= new Zi();
System.out.println(z.num);	//结果是Zi的num

//method4() 是静态函数
f.method4();	//结果是Fu的method4
z.method4();	//结果是Zi的method4
/*
在多态中成员函数的特点：
在编译时期，参阅引用型变量所属的类中是否有调用的方法。
如果有，编译通过。
如果没有，编译失败。

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

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

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

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

}

/*需求
电脑运行实力
电脑运行基于主板。
*/

interface PCI
{
public void open();
public void close();
}

class MainBoard
{
public void run()
{
System.out.println("mainborad run");
}
public void usbPCI(PCI p)	//PCI p=new NetCard() 接口型引用指向自己的子类对象
{
if (p!=null)
{
p.open();
p.close();
}
}
}

class NetCard implements PCI
{
public void open()
{
System.out.println("netcard open");
}
public void close()
{
System.out.println("netcard close");
}
}

class SoundCard implements PCI
{
public void open()
{
System.out.println("sound open");
}
public void close()
{
System.out.println("sound close");
}
}

class Test
{
public static void main (String[] args)
{
MainBoard mb = new MainBoard();
mb.run();
mb.usbPCI(null);
mb.usbPCI(new NetCard());
mb.usbPCI(new SoundCard());
}
}

interface 的应用

/*需求：数据库的操作
数据是：用户信息
1：连接数据库	JDBC	Hibernate
2：操作数据库
c create  r read  u update  d  delete
3关闭数据库连接
*/

class UserInfoByJDBC implements UserInfoDao
{
public void add(User user)
{
1JDBC连接数据库；
2使用sql添加语句添加数据；
3关闭连接
}
public void delete(User user)
{
1JDBC连接数据库；
2使用sql添加语句删除数据；
3关闭连接
}
}

class UserInfoByHibernate implements UserInfoDao
{
public void add(User user)
{
1JDBC连接数据库；
2使用sql添加语句添加数据；
3关闭连接
}
public void delete(User user)
{
1JDBC连接数据库；
2使用sql添加语句删除数据；
3关闭连接
}
}

interface UserInfoDao
{
public void add(User user);
public void delete(User user);
}

class Test
{
public static void main (String [] args)
{
UserInfoDao ui= new UserInfoByJDBC();
UserInfoDao ui= new UserInfoByHibernate();
ui.add(user);
ui.delete(user);
}
}