黑马程序员： 面向对象-----多态

------- android培训、java培训、期待与您交流！ ---------- 

模板方法设计模式
 为了提高的代码的复用性
 可以将后去时间的功能单独进行封装

 解决问题：定义功能时，如果功能中有一部分确定，一部分不确定
 将不确定的内容对外提供出去，让子类来完成具体的实现
 abstract class GetTime
 {
//如果不想让子类复写这个功能可以，把getTime()定义常量：用final
  public final void getTime()
  {
 long start=System.currentTimeMilli();
  code();
  long end=System.currentTimeMillis();
}
public abstract void code();  // 抽象后的方法是无法通过对象进行调用的，
 
 
 }
 class SubDemo extends GetTime
 {
 public void code()
 {
 
 for(int y=0;y<1000;y++)
 System.out.println("y")
 
 }
 }

 class TemplateDemo
 {
 public static void main(String[] args)
 {
  SubDemo sb=new SubDemo()
	sb.getTime(); 直接调用父类的getTime()方法。
 }
 
 
 }

 ------------------------------
 接口
   可以简单的理解为：接口是特殊的抽象类
   当抽象类中的所有的方法都是抽象时，可以定义成接口的形式
   
   定义类用的class关键字
   定义接口用的interface 关键字
  
当定义接口时，接口中的成员最常见在两种
而且这两种成员都有固定的修饰符
1、抽象方法
	public abstract
2、全局常量
	public static final
接口不可以被实例化

必须由接口的子类覆盖了接品中所有的抽象方法后，该接口的子类才可以
实例化
如果只覆盖了部分抽象方法，那么该子类是一个抽象类。

类与类之间是继承关系 extends
类与接口之间的关系是实现关系 implements
  interface Inter
  {
  public static final int num=3;
   public abstract void show();
   public abstract void method();
  
  }


  类与接口只能用实现来进行implements
  class Demo
  {
  
  }

  在接口中如果 public abstract、public static final
都不写，java都会给补全，还是在定义时进行手动补全，增加代码的阅读性

----------------
 多实现和多继承
class a
{

}
class b
{


}

class c extends a,b //java不能多继承在类上
{
}
c c=new c();
c.show(); //会出现调用的不确定性，原因就在于，方法以有主体，而主体内容会出现不同
java 保留多继承机制，并继续改良，将多继承变成了多实


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

接口可以进行多实现。
interface a
{
 public void show();
}
interface b
{

public void show();
}

class c implements a,b  //可以 多实现，为什么可以多实现，因为接口的方法没有主体
{
  public void show()  //如果两个都相同只要实现一个就可以了。
  {
  
  }
  
}

java只是把多继承改变成了多实现
  在接口上，可以多继承

  java它的多继承在类上是通过多实现体现，
  在接口中是可以进行多继承。
  就是因为主体的调用的不确定性


  接口与接口之间是继承关系，而且 可以多继承
  interface a{public abstract void show();}
interface b{public abstract void show();}
interface c extends a,b   //在接口上，可以多继承
{
public abstract void show();
}
-----------------------------------------
接口---功能的扩展
class Demo
{
public void show()
{

System.out.println("demo show run");
}
}
interface Test
{
 public void method();
}

 subDmeo具备Demo类中的基本功能
 有了自己所属的体系，具备了体系中该事物的基本共性内容
 为了在该类中增加一些其他非体系中的功能，可以通过实现封装了该 功能的接口来完成
 
 接口就是一个体系中的事物的功能的扩展
 接口的出现避免了单继承的局限性
class SubDemo extends Demo implements Test
{
 public void method()
 {
 System.out.println("method run");
 
 }
}

接口的特点：
提供功能的扩展
接口是对外暴露的规则
接口的出现降低耦合（紧密）性


接口可以用来多实现
 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
 接口与接口之间可以有继承关系


 接口和抽象类的区别
1、
类只能单继承
而接口可以被多实现
2、
类可以对事物进行具体描述，定义属性，行为
接口只能定义全局常量和抽象行为
3、
类与类之间是所属类系 is a
类与接口之间是实现关系 like a 


-----
多态
  多种形态
  这里重点讲的就是对象的多态性。
对象的多态性，可以以各种形态出现
动物 y=new 狗（）  //对象的多态性，狗对象即是狗类型 ，又是动物类型 
 必须要明确一点：狗是动物中的一种。意味着狗是需要继承动物的才可以这样指向

 多态性：在程序中的体现
  就是父类或接口的引用指向自己的子类对象

  多态的好处：
	搞高了代码的扩展性

弊端：
  前期建立父类的引用虽然可以接收后期所有该类的子类对象
  但是只能使用父类中的功能呢，不能使用子类中的特有功能
  因为前期的程序无法知道后期的子类的特有内容的

  但是前期的程序可以使用子类覆盖了父类的方法的内容

前提：
  1、必须存着继承关系。
  2、通常要有覆盖操作
 


  例如：
   abstract class Animal
   {
    abstract void eat();
   }
   class dog extends Animal
   {
    public void eat()
    {
    
    }
   
   }
   class Cat extends Animal
   {
    public void eat()
    {
    
    }
   }
   class DuoTaiDemo
   {
   public static void main(String[] args)
   {
   Dog d1=new Dog();
   /*
   父类引用指向子类对象。
   A引用可以指向Animal的任意的子类的对象
   但是A引用只能调用的是Animal类中的方法
   
   */
-------------------
  转型：
   Animal a=new Dog();// 子类对象的类型提升。向上转型(从狗类型 转成动物类型 )
   好处：提高了扩展性，局限：只能使用父类中的方法
   这种提升可以限制对子类对象的操作

   Dog d=(Dog)a ; //向下转型 ，转成子类型 
   d.eat();
   可以使用子类的特有方法
  弊端： 如果类型转换错误，会出现运行异常
  
   什么时候 使用向上转型，和向下转型 呢？
   当需要对程序进行扩展，或者限定对对象的方法操作时，使用向上转型 
   当要使用子类的特有的内容时，就需要向下转型 ，转型前一宝要判断，否则容易出现问题 


   注意： 在这个转型 过程中，自始自终都是一个子类对象在做着类型的变化而已。
   千万别把父类对象转成子类型 ，那是不可能
      Anumal a =new Ainmal();
        Dog d=(Dog)a;   //不能这么写。
   }

   public static void method(Animal a) //只能调用父类的功能
   {
    a.eat();
    a.catchMouse();  //前期的子类是不能调用后期子类的特有方法
   }
   
   }
   多态的问题就是复杂的问题简单化，将共性的内容进行封将起来
   只要调用它的共性内容就可以，操作其他事物做事情了。

   --------------------------------
类型的判断
    在进行子类特有方法使用时，要进行向下转型时，转型前一定要做判断，否则
    容易发生classCastException
    判断引用类型，要使用一个关键字完成，关键字 instanceof
    对象 instanceof 类型

    这个判断是向下转型前的健壮性判断
    例如：
    if(a instanceof Cat)
    {
     Cat c=(Cat)a;
    }

多态的出现在成员调用上的特点
成员变量：
  在编译时期，参考的是引用型变量所属的类中是否有调用的成员变量，如果有，编译通过，如果没有编译失败
  运行时期， 调用的也是引用型变量所属类中的成员变量
    编译和运行时看左边.
    其实这种情况不多见

因为函数覆盖的特性，运行的子类对象在调用show方法，覆盖了父类中的方法
成员函数：
	  编译时期，参考的是引用型变量所属的类中是否有调用的方法，有,编译通过，没有编译失败
	  运行时期，参考的是对象所属的类中是否有调用的方法，如果有运行子类自己的方法，如果没有变父类的方法

  简单说：编译时看左边，运行时期看右边

	非静态方法需要和当期运行的对象进行动态绑定，哪个对象调用了这个方法，这个方法就所属哪个对象
	就会运行哪个对象中的方法

静态函数(静态方法)
  编译时期，参考的是引用型 变量所属的类中是否有该方法
  运行时期，参考的也是引用型变量所属的类中的方法

  简单说：编译和运行都看左边
	  因为静态方法是不所属于对象的，是所属于类的
	  它会类加载的时候，静态的绑定在所属的类中。


  非静态方法，编译时看左边，运行时看右边 ，其他的都看左边

class Fu
{
 int num=4;
 public void show()
 {
 
 System.out.println("fu run");
}
public static void getShow()
{
System.out.println("fu run");
}
class Zi extends Fu
{
 int num=5;
 public void show()
 {
 System.out.println("zi run");
 
 }
 public static void getShow()
{
System.out.println("zi run");
}

}

class DuoTia
{
 public static void main(String[] args)
 {
    Fu f=new Zi();
     f.num;  //
     f.show();
     f.getShow();
 
 
 }


}

------- android培训、java培训、期待与您交流！ ----------