Java基础

【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) {
   
  }
 }