java基础四（多态）

以上章节中我们学习了java的封装、继承两大特性，接下来我们来熟悉关于多态的相关知识点。

1.向上转型

   又叫自动转型、隐式转型。向上转型就是父类引用指向子类实例，也就是子类的对象可以赋值给父类的对象。
   如：Animal dog = new Dog();  //Dog类是Animal的子类。
   注：向上转型是安全的，因为任何子类都继承并接受了父类的方法。
   向上转型的应用：当一个子类对象向上转型父类对象以后，就被当成了父类的对象，所能调用的方法会减少，只能调用子类重写父类的方法以及父类派生的方法（如get(); set()方法）

2.向下转型

 又叫强制类型转换，子类引用指向父类对象，此处必须进行强转，可以调用子类特有的方法。
 必须满足转型条件才能进行强转：兄弟类之间不可以进行强制类型转换。

3.instanceof运算符

1）instanceof 运算符用来判断对象是否可满足某个特定类型实例特征

2）返回值为true/false

3）一般用于if语句中

注：java中所有类都直接或间接继承自Object类。

Animal animal = new Cat();	
if(animal instanceof Cat){  //true
	System.out.println("Cat");
}            //animal这个引用实际指向的是Cat的实例。具有Cat类型的特征。
if(animal instanceof Animal){  //true
	System.out.println("Animal");
}          //具有Animal类特征，是因为Animal是Cat的父类。
if(animal instanceof Object){  //true
	System.out.println("Object");
}        //具有Object类特征，是因为Animal的父类是Object。
//animal具有Animal类型的特征，也同时具有Object类型的特征。

4. 注：父类中的静态方法无法被子类重写，所以向上转型之后，只能调用到父类原有的静态方法

如父类中有一个静态的say方法（static修饰），子类不可以重写，子类写的say方法表面上看起来似乎是重写，其实际上是子类自己的say方法。

父类（Animal）：

public static void say(){
		System.out.println("动物间打招呼");
	}

子类(Cat)：

//@Override  不是重写，会报错
public static void say(){
		System.out.println("小猫喵喵喵~");
	}

5. abstract关键字

//抽象类
abstract public class Shape{

    //抽象方法
    abstract double area();
}

从以上例子可以看出，抽象是用abstract修饰，抽象类中有一种特殊方法，即用abstract关键字来修饰的方法，称为"抽象方法"

5.1 抽象类与抽象方法的特点：

 1）抽象方法不允许直接实例化，换句话说抽象类不能创建对象，它只能作为其他类的父类，但可以通过向上转型，指向实例化。

2）抽象方法只有声明，不能有实现，也就是仅有方法头，而没有方法体和操作实现。

5.2 定义抽象类的意义：
1）为其子类提供一个公共的类型（父类引用指向子类对象）；

2）封装子类中的重复内容（成员变量和方法）

3）将父类设计成抽象类后，既可借由父子继承关系限制子类的设计随意性，在一定程度上避免了无意义父类的实例化。

5.3 重点注意：

1）含有抽象方法的类，只能被定义为抽象类。
2）抽象类不一定包含抽象方法。
3）在抽象类中的成员方法可以包括一般方法和抽象方法
4）抽象类不能被实例化，即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。
   如：Shape抽象类中不包含抽象方法：

 abstract public class Shape{
        public void area(){
            System.out.println("图形周长为：");   //一般方法
        }
   }

 测试类中实例化Shape,编译器会报错。  
   Shape s = new Shape();  //报错！
5）一个类继承抽象类后，必须实现其所有抽象方法，否则也是抽象类，不同的子类对父类的抽象方法可以有不同的实现。
   如: 抽象类父类Shape

  abstract public class Shape{
        abstract double area(); //抽象方法
   }

则其子类Rectangle有两种做法:
   方案一：重写抽象方法area(),使方法得以实现

 //子类Rectangle类
public class Rectangle extends Shape{
        //属性：矩形的长、宽
        public double length;
        public double width;
        public Rectangle(double length,double width){
            this.length = length;
            this.width = width;
        }
        //重写父类中area()方法
        public double area(){
            return (double)length*width;
        }
   }

方案二：子类Rectangle类也定义为抽象类

public abstract class Rectangle extends Shape{
        //属性：矩形的长、宽
        public double length;
        public double width;
        public Rectangle(double length,double width){
            this.length = length;
            this.width = width;
        }
   }

6）即使父类是具体的，但其子类也可以是抽象的。如Object是具体的，但可以创建抽象子类。
7）abstract方法不能用static和private修饰；对于类，不能同时用final和abstract修饰，因为final关键字使得类不可继承，而abstract修饰的类如果不可以继承将没有任何意义。两者放在一起，会起冲突
   如以下用法都会引起编译器报错：
      static abstract double area();  //抽象方法
      private abstract double area();  //抽象方法
      abstract final class Shape{
        abstract double area(); //抽象方法
      }

6.interface与abstract

1) 接口中抽象方法可以不写abstract关键字，访问修饰符默认为public,当类实现接口时，需要去实现接口中的所有抽象方法，否则需要将该类设置为抽象类。
2) 接口中可以包含常量，默认public static final 
   JDK1.8以后新增: 

   i) default:默认方法，可以带方法体，可以在实现类中重写，并可以通过接口的引用调用。如下：

 default void conn(){
        System.out.println("我是接口中的默认链接")
   }

   调用接口中默认的方法：类名.super.conn();   
   
   ii) static:静态方法，也可以带方法体，不可以在实现类中重写，可以同接口名调用

static void conn(){
     System.out.println("我是接口中的静态方法")
   }  //调用：接口名.静态方法

3) 接口也可以实现继承，并且可以继承多个父接口