*多态:
* 生活中的多态:一种物质，有多种表现形态(金刚石和石墨)
* 程序中的多态:同一个"接口"(Car)，因不同的实现(Benz,Bmw,Byd..)而执行不同的操作(子类 重写 后的方法)
* 多态的优点:
* 1.简化代码
* 2.提高代码的扩展性和可维护性 *(满足开闭原则)
* 多态的实现:前提条件:必须和继承,重写结合使用;一般做法是：写一个方法，它只接收父类作为参数，编写的代码只与父类打交道。调用这个方法时，实例化不同的子类对象（new 一个对象）。
多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象
package object;
public class TestPolym {
public static void main(String[] args) {
Animal animal = new Dog(); //向上可以自动转型
System.out.println(animal.age); //属性调用时，仍然是基类的属性。属性没有多态！
// animal.shout();
animalCry(new Dog());
//传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
//如果没有多态，我们这里需要写很多重载的方法。如果增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
//有了多态，只需要增加这个类继承Animal基类就可以了。
animalCry(new Cat());
Dog dog = (Dog) animal; //编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。
dog.gnawBone();
System.out.println(dog instanceof Animal);
System.out.println(animal instanceof Cat);
System.out.println(animal instanceof Dog);
}
static void animalCry(Animal a){
a.shout();
}
}
class Animal {
int age=10;
public void shout(){
System.out.println("叫了一声！");
}
}
class Dog extends Animal {
int age=28;
public void shout() {
System.out.println("旺旺旺！");
}
public void gnawBone(){
System.out.println("我再啃骨头");
}
}
class Cat extends Animal {
int age=18;
public void shout() {
System.out.println("喵喵喵喵！");
}
}
更具体的说：
（1）、子类重写父类的方法。使子类具有不同的方法实现。
（2）、把父类类型作为参数类型，该父类及其子类对象作为参数转入。
（3）、运行时，根据实际创建的对象类型动态决定使用那个方法。
* 1.创建汽车类(父类)
* 2.创建奔驰类,宝马类并继承汽车类(子类),在子类中重写父类的方法
* 3.将父类作为参数传入 drive(Car b)
* 4.执行过程中传入具体的子类对象,程序在执行过程会执行子类重写后的方法
*程序需要满足"开闭原则":
* "开":对扩展要"开"(程序容易扩展新的功能)--->程序的扩展性要好
* "闭":对修改要"闭"(当添加或修改功能时，代码应尽可能少的更改或不更改)
* 可以通过多态来解决程序扩展性差的问题。
* 类型的自动转化: byte-->short-->int-->long--->float-->double
* 比赛的方法
* byte--->short--->int--->long-->float-->double
* 向上转型(自动转换):将子类转换为父类进行使用
* 生活案例:演员(父类)和替身(子类)
* 利用父类创建子类后(发生了向上转型):
* 1.只能访问父类的成员变量和成员方法(子类自有的属性和方法无法使用)
* 2.如果子类重写了父类的某个方法，上转型对象调用该方法时，是调用的重写方法。
* long l=10L;
* int i=(int)l;--->强制转换
* 向下转型(强制转换):父类转换为子类
* 可以访问子类中新增的属性和方法
* 异常:java.lang.ClassCastException类型转换异常
* instanceof运算符:
* 对象 instanceof 类 :判断该对象是否为指定类的实例，如果该对象是类实例返回true,否则返回false
*final关键字: 最终的
*1.使用final修饰的变量,就变成常量，在运行的过程中不能被重新赋值
*2.使用final修饰方法,不能被子类重写(覆盖)
*3.使用final修饰的类，不能继承(不能派生其他子类)
*java中的常见的final修饰的类
*String,Math,Scanner,StringBuffer...
*
*static修饰的方法或属性:
* 类名.属性或类名.方法名 *
* 对象.属性或对象名.方法名
abstract(抽象)修饰符必须放在类名前 抽象类 ;;;;;
1 abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。
2 abstract修饰方法，会使这个方法变成抽象方法，也就是只有声明（定义）而没有实现，实现部分以"；"代替。需要子类继承实现（覆盖）。
3 有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。
4 父类是抽象类，其中有抽象方法，那么子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的实例的能力，否则子类也必须是抽象类。抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。
* 抽象方法:使用abstract关键字修饰的方法,抽象方法没有方法体
* 抽象类(为继承而生):使用abstract修饰类,包含抽象方法的类必须放在抽象类之中，抽象类可 以有 构造函数，抽象类可以包含0到多个抽象方法,也可以包含非抽象方法
* 抽象类中是否必须有抽象方法-->不一定
* 包含抽象方法的类一定是抽象类
* 抽象类不能实例化,不能通过new关键字创建对象。
* 通过抽象类，可以避免子类设计的随意性
* 如果一个类继承了一个抽象类,必须重写所有其抽象方法
* 或者子类也是一个抽象类,否则无法通过编译。
设计模式GOF:经典问题的解决方案(前人经验的总结)
* 23种设计模式:
* 简单工厂模式不属23中设计模式中的一种，主要可以通过简单工程模式创建对象
* 生活中使用的手机，个人不会去制造一个，而是从工厂购买(生成产品的过程交给了工厂)
* 优点:
* 可以根据用户的需求动态创建产品(对象)
* 需求:当输入ch字符串时创建一个Chinese对象返回，输入am时创建一个American对象返回
* 1.使用static修饰:无需创建对象,直接使用类名.方法名调用
* 2.返回值类型:父类类型
* 3.根据用户输入的标示动态创建对象
* XxxFactory--->工厂模式,主要用于生产Xxx对象