一、关于Java语言中向上转型和向下转型
1.向上转型(upcasting):  子----->父
2.向下转型(downcasting):  父---->子
注意：无论是向上转型还是向下转型，两个类之间必须要有继承关系
public class Test02{
  public static void main(String[] args){
   //向上转型又被称作自动类型转换
   //父类型的引用指向子类型对象
   //程序分两个阶段：编译阶段，运行阶段
   //程序编译阶段只知道a1是一个Animal类型
   //程序在运行的时候堆中的实际对象时Cat类型
   Animal a1 = new Cat();
   //程序在编译阶段a1被看作Animal类型，所以程序在编译阶段a1引用的绑定是Animal类中的eat方法（静态绑定）
   //程序在运行的时候堆中的实际对象是Cat类型，而Cat已经重写了eat方法
   //所以程序在运行阶段对象的绑定的方法是Cat中的eat方法（动态绑定）
   a1.eat();
   Animal a2 = new Cat();  //向上转型
   Cat c1 = (Cat)a2;   //向下转型，强制类型转换
  }
}
//动物类
public class Animal{
  public void eat(){};
}
//猫类，继承了动物类
public class Cat extends Animal{
  //重写动物类中的eat方法
  public void eat(){
   System.out.println("猫吃鱼");
  }
}
外加一点：在做强制类型转换的时候程序是存在风险的
  为了避免ClassCastException的发生，Java引入了instanceof运算符
  1、instanceof运算符的运算结果是Boolean类型
  2、（引用 instanceof 类型）  ---->true/flase   判断“引用”是否是“类型”的实例
  例如：(a instanceof Cat)如果结果是true表示：a引用指向堆中的Java对象时Cat类型
  
二、接口与抽象类:
java的继承是单继承，这种单继承可以保证类的纯洁性，但对类的扩展有一定的影响：实现接口可以看作是对继承的一种补充
继承是底层式的，不太灵活，而实现接口可以在不打破继承关系的前提下，对某个功能扩展，很灵活
         
接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来:
  class 类名 implements 接口
  {
   常量;（采用public static final修饰）
   抽象方法;（采用public abstract修饰）
  }
  接口中的所有变量都是用public static final修饰，所有方法都是用public abstract修饰，所以public static final和
  public abstract都可以省略，系统会默认采用public static final和public abstract修饰变量和方法。
           
接口是更加抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体
接口体现了JAVA编程的多态和高内聚低耦合的设计思想
  接口-----注意事项
   1、接口中没有构造方法，不能被实例化
   2、接口中所有的方法都不能有主体
   3、一个类可以实现多个接口(class A implements B,C{})，接口和接口之间可以多继承(interface A extends B,C{})
   4、接口中可以有变量(但是变量不能用private和protected修饰)
    a、接口中的变量，本质上都是static的，而且是final类型的，即必须初始化，不管加不加static修饰
    b、在JAVA开发中，常常把经常用的变量定义在接口中，作为全局变量。访问形式：  接口名.变量名
   5、一个接口不能继承其它的类，但是可以继承别的接口
   6、一个类实现了一个接口，那么该类必须重写该接口的所有抽象方法。
   7、一个类在实现接口的同时还可以继承其他的类，但是只能继承一个其他的类
  抽象类：
   1、用abstract关键字来修饰一个类时，这个类就是抽象类
   2、用abstract关键字类修饰一个方法时，这个方法就是抽象方法
   3、抽象类与抽象方法在实际应用中不多，但是常常是面试的问题
  抽象类---注意事项
   1、抽象类不能被实例化
   2、抽象类不一定要包含abstract方法，即抽象类可以没有abstract方法
   3、一旦类包含了abstract方法，则这个类必须声明为abstract方法
   4、抽象方法不能有主体
三、前期绑定，后期绑定
前期绑定：在程序运行之前进行绑定，由编译器和连接程序实现，又叫静态绑定。比如static方法和final方法。注意：这里也
  包括private方法，因为它是隐式final的。
后期绑定：在运行时根据对象的类型进行绑定，由方法调用实现，又叫动态绑定，或者运行时绑定。除了前期绑定外的所有方法
  都属于后期绑定。
接口体现了Java的多态特性。多态就是在后期绑定这种机制上实现的。多态带给我们的好处就是，消除了类之间的耦合关系，使
  程序更容易扩展。
//汽车接口
interface Car
{
  //汽车名称
  String getName();
  //获得汽车售价
  int getPrice();
}
//宝马类
class BMW implements Car
{
  public String getName()
  {
   return "BMW";
  }
  
  public int getPrice()
  {
   return 300000;
  }
}
//奇瑞QQ
class CheryQQ implements Car
{
  public String getName()
  {
   return "CheryQQ";
  }
  
  public int getPrice()
  {
   return 20000;
  }
}
//汽车出售店
public class CarShop
{
  //售车收入
  private int money = 0;
  
  //卖出一部车
  public void sellCar(Car car)
  {
   System.out.println("车型:"+car.getName()+"    "+"单价："+car.getPrice());
   //增加卖出车售价的收入
   money += car.getPrice();
  }
  
  //售车总收入
  public int getMoney()
  {
   return money;
  }
  
  public static void main(String[] args)
  {
   CarShop aShop = new CarShop();
   //卖出一辆宝马
   aShop.sellCar(new BMW());
   //卖出一辆奇瑞QQ
   aShop.sellCar(new CheryQQ());
   System.out.println("总收入："+aShop.getMoney());
  }
}
四、接口的作用
/*
  客户业务接口
  接口作用：
   1、可以使项目分层，所有层都面向接口开发，开发效率提高了。
   2、接口使代码之间的耦合度降低（就像灯头与灯泡，内存条与主板的关系），变得“可插拔”，可以随意切换
*/
public interface CustomerService{
  //定义一个退出系统的方法
  void logout();   //public abstract省略了
}
//编写接口的实现类
//该类的编写是完全面向接口去实现的
public class CustomerServiceImpl implements CustomerService{
  System.out.println("成功退出系统！");
}
//测试程序
public class Test{
  //入口
  public static void main(String[] args){
   //要执行CustomerServiceImpl中的logout方法
   //以下程序面向接口去调用
   CustomerService cs = new CustomerServiceImpl();   //多态
   //调用
   cs.logout();
  }
}
    //CustomerService cs = new CustomerServiceImpl();  引用cs在编译时期(前期绑定)是CustomerService类型，到了运行时期
//（后期绑定）就是CustomerServiceImpl类型了。

一、关于Java语言中向上转型和向下转型
1.向上转型(upcasting):  子----->父
2.向下转型(downcasting):  父---->子
注意：无论是向上转型还是向下转型，两个类之间必须要有继承关系
public class Test02{
  public static void main(String[] args){
   //向上转型又被称作自动类型转换
   //父类型的引用指向子类型对象
   //程序分两个阶段：编译阶段，运行阶段
   //程序编译阶段只知道a1是一个Animal类型
   //程序在运行的时候堆中的实际对象时Cat类型
   Animal a1 = new Cat();
   //程序在编译阶段a1被看作Animal类型，所以程序在编译阶段a1引用的绑定是Animal类中的eat方法（静态绑定）
   //程序在运行的时候堆中的实际对象是Cat类型，而Cat已经重写了eat方法
   //所以程序在运行阶段对象的绑定的方法是Cat中的eat方法（动态绑定）
   a1.eat();
   Animal a2 = new Cat();  //向上转型
   Cat c1 = (Cat)a2;   //向下转型，强制类型转换
  }
}
//动物类
public class Animal{
  public void eat(){};
}
//猫类，继承了动物类
public class Cat extends Animal{
  //重写动物类中的eat方法
  public void eat(){
   System.out.println("猫吃鱼");
  }
}
外加一点：在做强制类型转换的时候程序是存在风险的
  为了避免ClassCastException的发生，Java引入了instanceof运算符
  1、instanceof运算符的运算结果是Boolean类型
  2、（引用 instanceof 类型）  ---->true/flase   判断“引用”是否是“类型”的实例
  例如：(a instanceof Cat)如果结果是true表示：a引用指向堆中的Java对象时Cat类型
  
二、接口与抽象类:
java的继承是单继承，这种单继承可以保证类的纯洁性，但对类的扩展有一定的影响：实现接口可以看作是对继承的一种补充
继承是底层式的，不太灵活，而实现接口可以在不打破继承关系的前提下，对某个功能扩展，很灵活
         
接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来:
  class 类名 implements 接口
  {
   常量;（采用public static final修饰）
   抽象方法;（采用public abstract修饰）
  }
  接口中的所有变量都是用public static final修饰，所有方法都是用public abstract修饰，所以public static final和
  public abstract都可以省略，系统会默认采用public static final和public abstract修饰变量和方法。
           
接口是更加抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体
接口体现了JAVA编程的多态和高内聚低耦合的设计思想
  接口-----注意事项
   1、接口中没有构造方法，不能被实例化
   2、接口中所有的方法都不能有主体
   3、一个类可以实现多个接口(class A implements B,C{})，接口和接口之间可以多继承(interface A extends B,C{})
   4、接口中可以有变量(但是变量不能用private和protected修饰)
    a、接口中的变量，本质上都是static的，而且是final类型的，即必须初始化，不管加不加static修饰
    b、在JAVA开发中，常常把经常用的变量定义在接口中，作为全局变量。访问形式：  接口名.变量名
   5、一个接口不能继承其它的类，但是可以继承别的接口
   6、一个类实现了一个接口，那么该类必须重写该接口的所有抽象方法。
   7、一个类在实现接口的同时还可以继承其他的类，但是只能继承一个其他的类
  抽象类：
   1、用abstract关键字来修饰一个类时，这个类就是抽象类
   2、用abstract关键字类修饰一个方法时，这个方法就是抽象方法
   3、抽象类与抽象方法在实际应用中不多，但是常常是面试的问题
  抽象类---注意事项
   1、抽象类不能被实例化
   2、抽象类不一定要包含abstract方法，即抽象类可以没有abstract方法
   3、一旦类包含了abstract方法，则这个类必须声明为abstract方法
   4、抽象方法不能有主体
三、前期绑定，后期绑定
前期绑定：在程序运行之前进行绑定，由编译器和连接程序实现，又叫静态绑定。比如static方法和final方法。注意：这里也
  包括private方法，因为它是隐式final的。
后期绑定：在运行时根据对象的类型进行绑定，由方法调用实现，又叫动态绑定，或者运行时绑定。除了前期绑定外的所有方法
  都属于后期绑定。
接口体现了Java的多态特性。多态就是在后期绑定这种机制上实现的。多态带给我们的好处就是，消除了类之间的耦合关系，使
  程序更容易扩展。
//汽车接口
interface Car
{
  //汽车名称
  String getName();
  //获得汽车售价
  int getPrice();
}
//宝马类
class BMW implements Car
{
  public String getName()
  {
   return "BMW";
  }
  
  public int getPrice()
  {
   return 300000;
  }
}
//奇瑞QQ
class CheryQQ implements Car
{
  public String getName()
  {
   return "CheryQQ";
  }
  
  public int getPrice()
  {
   return 20000;
  }
}
//汽车出售店
public class CarShop
{
  //售车收入
  private int money = 0;
  
  //卖出一部车
  public void sellCar(Car car)
  {
   System.out.println("车型:"+car.getName()+"    "+"单价："+car.getPrice());
   //增加卖出车售价的收入
   money += car.getPrice();
  }
  
  //售车总收入
  public int getMoney()
  {
   return money;
  }
  
  public static void main(String[] args)
  {
   CarShop aShop = new CarShop();
   //卖出一辆宝马
   aShop.sellCar(new BMW());
   //卖出一辆奇瑞QQ
   aShop.sellCar(new CheryQQ());
   System.out.println("总收入："+aShop.getMoney());
  }
}
四、接口的作用
/*
  客户业务接口
  接口作用：
   1、可以使项目分层，所有层都面向接口开发，开发效率提高了。
   2、接口使代码之间的耦合度降低（就像灯头与灯泡，内存条与主板的关系），变得“可插拔”，可以随意切换
*/
public interface CustomerService{
  //定义一个退出系统的方法
  void logout();   //public abstract省略了
}
//编写接口的实现类
//该类的编写是完全面向接口去实现的
public class CustomerServiceImpl implements CustomerService{
  System.out.println("成功退出系统！");
}
//测试程序
public class Test{
  //入口
  public static void main(String[] args){
   //要执行CustomerServiceImpl中的logout方法
   //以下程序面向接口去调用
   CustomerService cs = new CustomerServiceImpl();   //多态
   //调用
   cs.logout();
  }
}
    //CustomerService cs = new CustomerServiceImpl();  引用cs在编译时期(前期绑定)是CustomerService类型，到了运行时期
//（后期绑定）就是CustomerServiceImpl类型了。