黑马程序员------面向对象（No.6）(接口、多态)

----------------------
ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------


接口
格式：interface{ }
接口中的成员修饰符是固定的。
1.成员常量：public static final
2.成员函数：public abstract
接口的出现，将“多继承”通过另一种形式体现出来，即“多实现”。

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全部重写后，子类才可以实例化。否则，子类是一个抽象类

/*
接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全部重写后，子类才可以实例化。
否则，子类是一个抽象类
*/
interface Inter{
public static final int NUM = 3;
public abstract void show();
}
class Test implements Inter{
public void show(){}
}
class InterfaceDemo{
public static void main(String[] args){
Test t = new Test();
System.out.println(t.NUM);//输出3
System.out.println(Test.NUM);//输出3
System.out.println(Inter.NUM);//输出3
}
}

编译后产生三个.class文件：Inter.class、Test.class、InterfaceDemo.class

interface A{
void methodA();
}
interface B{
void methodB();
}
//可以多继承 只在接口与接口之间
interface C extends A,B{
void methodC();
}
class D implements C{
public void methodA(){}
public void methodB(){}
public void methodC(){}
}

接口的特点：
1.接口是对外暴露的规则。
2.接口是程序的功能扩展。
3.接口可以用来多实现。
4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
5.接口与接口之间可以有继承关系。

abstract class Student{
//每个学生都有自己学习功能的实现，所以定义成抽象方法。由子类实现该功能
abstract void study();
//每个学生都有相同的sleep功能。
void sleep(){
System.out.println("sleep");
}
}
//扩展功能要放在接口中，要扩展这个功能，就实现这个接口。
interface Smoking{
void smoke();
}
//实现了Smoking接口。具有Smoking功能。
class ZhangSan extends Student implements Smoking{
void study(){}
public void smoke(){}
}
//没有实现Smoking功能。
class LiSi extends Student{
void study(){}
}

多态

多态：可以理解为事物存在的多种体现形态。
人：男人、女人；
动物：猫、狗；
猫 x = new 猫( );
动物 x = new 猫( );

1.多态的体现
父类引用指向子类对象（父类的引用可以接收自己的子类对象）。
2.多态的前提
必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提，就是存在覆盖（重写）。
3.多态的好处
多态的出现大大的提高了程序的扩展性。
4.多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员。

abstract class Animal{
public 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("看家");
}
}
class DuoTaiDemo{
public static void main(String[] args){
//父类引用指向子类对象（父类的引用可以接收自己的子类对象）（类型提升）（向上转型）
Animal a = new Cat();
a.eat();
//如果想要调用猫的特有方法时，如何操作？
//强制向下转型
Cat c = (Cat)a;
c.catchMouse();//输出  抓老鼠

//这种方式错误，这种方式就是将父类对象转成子类类型。
//我们能转换的是父类应用指向了自己的子类对象事，该应用可以被提升，也可以被强制转换。
//多态自始自终都是子类对象在做着变化。
//Animal a1 = new Animal();  同时抽象类也不能直接被实例化
//Cat c1 = (Cat)a1;

fun(new Dog());
fun(new Cat());
}
public static void fun(Animal a){
a.eat();
if(a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse();
}
if(a instanceof Dog){
Dog d = (Dog)a;
d.kanJia();
}
}
}

我们能转换的是父类应用指向了自己的子类对象事，该应用可以被提升，也可以被强制转换。多态自始自终都是子类对象在做着变化。
5.多态的应用

/*
基础班学生：
学习、睡觉
高级版学生：
学习、睡觉
*/
abstract class Student{
public abstract void study();
public void sleep(){
System.out.println("躺着睡");
}
}
//将操作Student的方法封装成类
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 DuoTaiDemo{
public static void main(String[] args){
//BaseStudent bs = new BaseStudent();
//bs.sleep();
//bs.study();
//AdvStudent as = new AdvStudent();
//as.sleep();
//as.study();
DoStudent ds = new DoStudent();
ds.doSome(new BaseStudent());
ds.doSome(new AdvStudent());
}
}

6.多态的出现代码中的特点（多态使用注意事项）
在编译时期，参阅引用型变量所属类中是否有调用的方法。如果有，编译通过，如果没有则编译失败。
在运行时期，参阅对象所属的类中是否有调用方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

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

在多态中，静态成员的特点：
无论编译和运行，都参考左边。
（视频出处：传智播客毕向东Java基础视频教程-day08-05-面向对象(多态中成员的特点).avi）

----------------------
ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
详情请查看：http://edu.csdn.net