目录
多态(polymorphism)
多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个 方法，具体实现会完全不同。 比如：同样是调用人的“休息”方法，张三是睡觉，李四是旅 游，高淇老师是敲代码，数学教授是做数学题； 同样是调用人“吃饭”的方法，中国人用 筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。
多态的要点：
- 多态是方法的多态，不是属性的多态（多态与属性无关）。
- . 多态的存在要有 3 个必要条件：继承，方法重写，父类引用指向子类对象。
- 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。
多态和类型转换
public class TestPolym {
public static void main(String[ ] args) {
Animal a1 = new Cat(); // 向上可以自动转型
//传的具体是哪一个类就调用哪一个类的方法。大大ᨀ高了程序的可扩展性。
animalCry(a1);
Animal a2 = new Dog();
animalCry(a2);//a2 为编译类型，Dog 对象才是运行时类型。
/*编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
* 否则通不过编译器的检查。*/
Dog dog = (Dog)a2;//向下需要强制类型转换
dog.seeDoor();
}
// 有了多态，只需要让增加的这个类继承 Animal 类就可以了。
static void animalCry(Animal a) {
a.shout();
}
/* 如果没有多态，我们这里需要写很多重载的方法。
* 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
static void animalCry(Dog d) {
d.shout();
}
static void animalCry(Cat c) {
c.shout();
}*/
}
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("喵喵喵喵！");
}
}
这是多态最为多见的一种用法，即父类引用做方法的形参，实参可 以是任意的子类对象，可以通过不同的子类对象实现不同的行为方式。
由此，我们可以看出多态的主要优势是ᨀ高了代码的可扩展性，符合开闭原则。但是多 态也有弊端，就是无法调用子类特有的功能，比如，我不能使用父类的引用变量调用 Dog 类特有的 seeDoor()方法。
对象的转型(casting)
父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。
向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方 法。这时，我们就需要进行类型的强制转换，我们称之为向下转型！
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)); // 位于 0 索引位置的字符
System.out.println(obj == str); // true.他们俩运行时是同一个对象
}
}
在向下转型过程中，必须将引用变量转成真实的子类类型(运行时类型）否则会出现类 型转换异常 ClassCastException。
类型转换异常
public class TestCasting2 {
public static void main(String[ ] args) {
Object obj = new String("北京尚学堂");
//真实的子类类型是 String，但是此处向下转型为 StringBuffer
StringBuffer str = (StringBuffer) obj;
System.out.println(str.charAt(0));
}
}
为了避免出现这种异常，我们可以使用 instanceof 运算符进行判断。
向下转型中使用 instanceof
public class TestCasting3 {
public static void main(String[] args) {
Object obj = new String("阿虎学Java");
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 关键字的作用：
- 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。
final int MAX_HEIGHT = 180; - 修饰方法：该方法不可被子类重写。但是可以被重载
final void eat(){} - 修饰类: 修饰的类不能被继承。比如：Math、String 等。
final class A {}
修饰方法：
修饰类：
抽象方法和抽象类
抽象方法
使用 abstract 修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子 类必须要给抽象方法ᨀ供具体的实现。
抽象类
包含抽象方法的类就是抽象类。通过 abstract 方法定义规范，然后要求子类必须定义具 体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。
抽象类和抽象方法的基本用法
public class TestAbstractClass {
public static void main(String[] args) {
Dog a = new Dog();
a.shout();
a.seeDoor();
}
}
//抽象类
abstract class Animal {
abstract public void shout(); //抽象方法
}
class Dog extends Animal {
//子类必须实现父类的抽象方法，否则编译错误
public void shout() {
System.out.println("汪汪汪！");
}
public void seeDoor(){
System.out.println("看门中....");
}
}抽象类的使用要点:
- 有抽象方法的类只能定义成抽象类
- 抽象类不能实例化，即不能用 new 来实例化抽象类。
- 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来 new 实例， 只能用来被子类调用。
- 抽象类只能用来被继承。
- 抽象方法必须被子类实现。