【1、对象转型casting】
(1)一个基类的引用类型变量可以“指向”其子类的对象。
(2)一个基类的引用不可以访问其子类对象新增加的成员(属性和方法)。
(3)可以使用引用变量"instanceof 类名"来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。
(4)子类的对象可以当作基类的对象来使用称作向上转型(upcasting),反之称为向下转型(dwoncasting)。
class Animal {
public String name;
Animal(String name) {
this.name = name;
}
}
class Cat extends Animal {
public String eyesColor;
Cat(String name, String eyesColor) {
super(name);
this.eyesColor = eyesColor;
}
}
class Dog extends Animal {
public String furColor;
Dog(String name, Strung furColor) {
super(name);
this.furColor = furColor;
}
}
public class Test {
public static void main(String[] args) {
Animals animal = new Animal("name");
Cat cat = new Cat("catName", "blue");
Dog dog = new Dog("dogName", "black");
System.out.println(animal instanceof Animals); // (3)
System.out.println(cat instanceof Animals); // (3)
System.out.println(dog instanceof Animals); // (3)
System.out.println(animal instanceof Cat); // (3)
animal = new Dog("bigYellow", "yellow"); // (1)
System.out.println(animal.name);
System.out.println(animal.furColor); // (2)
System.out.println(animal instanceof Animal);
System.out.println(animal instanceof Dog);
Dog dog1 = (Dog)a; // 强制类型转换
System.out.println(dog1.furColor);
}
}
【2、动态绑定和多态】
动态绑定是指“在执行期间(javac)(而非编译期java)”判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。
(1)要有继承
(2)要有重写
(3)父类引用要指向子类对象。
例子:根据Lady对象的成员变量pet所引用的不同的实际类型而调用相应的enjoy方法。
class Animal {
//
public Animal(String name) {
this.name = name;
}
//
public void sound() {
System.out.println("动物叫了……");
}
//
private String name;
}
class Cat extends Animal {
//
public Cat(String name, String eyeColor) {
super(name);
this.eyeColor = eyeColor;
}
//
public void sound() {
System.out.println("猫叫了……");
}
//
private String eyeColor;
}
class Dog extends Animal {
//
public Dog(String name, String furName) {
super(name);
this.funName = furName;
}
//
public void sound() {
System.out.println("狗叫了……");
}
//
private String furColor;
}
class Lady {
public Lady(String name, Animal pet) {
this.name = name;
this.pet = pet;
}
//
public void myPetSound() {
pet.sound();
}
//
private String name;
private Animal pet;
}
public class Test {
public static void main(String[] args) {
Cat cat = new Cat("catName, "blue");
Dog dog = new Dog("dogName", "black");
Lazy lazy1 = new Lazy("lazy1", cat);
Lazy lazy2 = new Lazy("lazy2", dog);
lazy1.myPetSound();
lazy2.myPetSound();
}
}
【3、抽象类】
用abstract关键字来修饰一个类时,这个类叫做抽象类;用abstract来修饰一个方法时,该方法叫做抽象方法。
含有抽象方法的类必须被声明为抽象类,抽象类必须被重写。
抽象类不能被实例化。
抽象方法只需声明,而不需实现。
【4、Final关键字】
final的变量的值不能够被改变
final的成员变量
final的局部变量(形参)
final的方法不能够被重写
final的类不能够被继承
【实例】
public class TestFinal {
public static void main(String[] args) {
}
}