java的知识点13——多态、对象的转型(casting)、final关键字、抽象方法和抽象类、接口的作用、如何定义和使用接口?、接口的多继承、面向接口编程

多态

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。

多态的要点：

1. 多态是方法的多态，不是属性的多态(多态与属性无关)。

2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

多态和类型转换测试

package cn.dym03;
class Animal{public void shout() {System.out.println("叫了一声！");}
}
class Dog extends Animal{public void shout() {System.out.println("汪汪汪！");}public void seeDoor() {System.out.println("看门中……");}
}
class Cat extends Animal{public void shout() {System.out.println("喵喵喵喵！");}
}
public class TestPolym {static void animalCry(Animal a) {a.shout();}public static void main(String[] args) {Animal a1=new Cat();animalCry(a1);Animal a2=new Dog();animalCry(a2);Dog dog=(Dog)a2;dog.seeDoor();}
}

多态最为多见的一种用法，即父类引用做方法的形参，实参可以是任意的子类对象，通过不同的子类对象实现不同的行为方式。

但是多态也有弊端，就是无法调用子类特有的功能。比如，不能使用父类的引用变量调用Dog类特有的seeDoor()方法。

那如果就想使用子类特有的功能行不行呢?行!这就是：对象的转型

对象的转型(casting)

父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。

向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型!使用子类特有的功能

对象的转型

package cn.dym04;public class TestCasting {public static void main(String [] args) {Object obj=new String("代止兮欢迎你！");  //向上可以自动转型//obj.charAt(0)  无法调用。 编译器认为obj是object类型而不是String类型//编写程序时，如果想调用运行时类型的方法，只能进行强制类型的转换  //否则通不过编译器的检查String str=(String)obj;System.out.println(str.charAt(0));System.out.println(obj==str);}
}

在向下转型过程中，必须将引用变量转成真实的子类类型(运行时类型)否则会出现类型转换异常ClassCastException。

类型转换异常

package cn.dym04;public class TestCasting2 {public static void main(String[] args) {Object obj=new String("代止兮欢迎您！");//真实的子类类型是String，但是此处向下转型为StringBufferStringBuffer str=(StringBuffer)obj;System.out.println(str.charAt(0));}
}

为了避免出现这种异常，我们可以使用instanceof运算符进行判断

向下转型中使用instanceof

package cn.dym04;public class TestCasting3 {public static void main(String[] args) {Object obj=new String("代止兮欢迎您！");if(obj instanceof String) {String str=(String)obj;System.out.println(str.charAt(0));}else if(obj instanceof StringBuffer) {StringBuffer str=(StringBuffer)obj;System.out.println(str.charAt(0));}}
}

final关键字

final关键字的作用： 1. 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。

2. 修饰方法：该方法不可被子类重写。但是可以被重载!

3. 修饰类: 修饰的类不能被继承。比如：Math、String等。

抽象方法和抽象类

·抽象方法

使用abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

·抽象类

包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

抽象类和抽象方法的基本用法

package cn.dym04;
abstract class Animal{abstract public void shout();//抽象方法
}
class Dog extends Animal{//子类必须实现父类的抽象方法，否则编译错误public void shout() {System.out.println("汪汪汪！");}public void seeDoor() {System.out.println("看门中……");}
}
public class TestAbstractClass {public static void main(String[] args) {Dog a=new Dog();a.shout();a.seeDoor();}
}

抽象类的使用要点:

1. 有抽象方法的类只能定义成抽象类

2. 抽象类不能实例化，即不能用new来实例化抽象类。

3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。

4. 抽象类只能用来被继承。

5. 抽象方法必须被子类实现。

接口的作用

为什么需要接口?接口和抽象类的区别?

接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。

抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。做系统时往往就是使用“面向接口”的思想来设计系统。接口就是规范

面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。

如何定义和使用接口?

定义接口的详细说明：

1. 访问修饰符：只能是public或默认。

2. 接口名：和类名采用相同命名机制。

3. extends：接口可以多继承。

4. 常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。

5. 方法：接口中的方法只能是：public abstract。省略的话，也是public abstract。

要点

1. 子类通过implements来实现接口中的规范。

2. 接口不能创建实例，但是可用于声明引用变量类型。

3. 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。

4. JDK1.7之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。

5. JDK1.8后，接口中包含普通的静态方法。

接口的使用

package cn.dym04;
//飞机接口
interface Volant{int FLY_HIGHT=100;void fly();
}
//善良接口
interface Honest{void helpOther();
}
class Angel implements Volant,Honest{public void fly() {System.out.println("我是天使，飞起来啦！");}public void helpOther() {System.out.println("扶老奶奶过马路！");}
}
class GoodMan implements Honest{public void helpOther() {System.out.println("扶老爷爷过马路！");}
}
class BirdMan implements Volant{public void fly() {System.out.println("我是鸟人，正在飞！");}
}public class TestInterface {public static void main(String [] args) {Volant volant=new Angel();volant.fly();System.out.println(volant.FLY_HIGHT);Honest honest=new GoodMan();honest.helpOther();}
}

接口的多继承

接口完全支持多继承。和类的继承类似，子接口扩展某个父接口，将会获得父接口中所定义的一切。

package cn.dym04;
interface A{void testa();
}
interface B{void testb();
}
interface C extends A,B{void testc();
}
public class Test implements C {public void testc() {System.out.println("1");}public void testa() {System.out.println("2");}public void testb() {System.out.println("3");}public static void main(String [] args) {Test t=new Test();t.testa();}
}

面向接口编程

面向接口编程是面向对象编程的一部分。

通过面向接口编程，而不是面向实现类编程，可以大大降低程序模块间的耦合性，提高整个系统的可扩展性和和可维护性。