静态初始化块 在main() 方法之前执行，且只执行一次。

普通初始化块 和 构造方法 根据具体情况选择性执行。

在java中，执行的优先级：

静态初始化块 >初始化块>构造方法

且静态初始化块 只在类加载时执行一次。

静态成员变量属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到类被卸载了才会进行资源回收。

也就是：静态成员是比较浪费内存空间的。

成员变量（属性）：直接定义在类中，相当于铸造开模时，在模子上制作的花纹。

1、每个使用这个类作为模子的对象，都会有这个属性；

2、从对象外面也看得见。

局部变量：定义在方法中，相当于草稿纸。

1、用后即扔，方法运行完，创建的局部变量就删除掉了；

2、出了方法的作用域就看不到了；

3、！！就近原则：对于每一个变量名，先看局部变量中有没有，然后再看方法外成员变量中有没有。

/**
 * @Author 王权
 */
abstract class Car {
    String name;//名称
    int rentPrice;//租金
    int personCapacity;//载人量
    int goodsCapacity;//载货量
}

class LoadPersonCar extends Car{

    public LoadPersonCar(String name, int rentPrice,int personCapacity) {
        this.name = name;
        this.rentPrice = rentPrice;
        this.personCapacity = personCapacity;
    }
}

class LoadGoodsCar extends Car{
    public LoadGoodsCar(String name, int rentPrice,int goodsCapacity) {
        this.name = name;
        this.rentPrice = rentPrice;
        this.goodsCapacity = goodsCapacity;
    }
}
class LoadPersonAndGoodsCar extends Car{
    public LoadPersonAndGoodsCar(String name, int rentPrice,int personCapacity,int goodsCapacity) {
        this.name = name;
        this.rentPrice = rentPrice;
        this.personCapacity = personCapacity;
        this.goodsCapacity = goodsCapacity;
    }
}
class AudiA4 extends LoadPersonCar{
    public AudiA4(String name, int rentPrice,int goodsCapacity) {
        super(name, rentPrice,goodsCapacity);
    }



}
class MaZiDa6 extends LoadPersonCar {
    public MaZiDa6(String name, int rentPrice,int personCapacity) {
        super(name, rentPrice,personCapacity);
    }


}

class PiKaXue6 extends LoadPersonAndGoodsCar {
    public PiKaXue6(String name, int rentPrice,int personCapacity,int goodsCapacity) {
        super(name, rentPrice,personCapacity,goodsCapacity);
    }

}

class JinLong extends LoadPersonCar {
    public JinLong(String name, int rentPrice,int personCapacity) {
        super(name, rentPrice,personCapacity);
    }

}

class SongHuaJiang extends LoadGoodsCar {
    public SongHuaJiang(String name, int rentPrice,int goodsCapacity) {
        super(name, rentPrice,goodsCapacity);
    }

}

class YiWeiKe extends LoadGoodsCar {
    public YiWeiKe(String name, int rentPrice,int goodsCapacity) {
        super(name, rentPrice,goodsCapacity);
    }

}

import com.sun.org.apache.xpath.internal.SourceTree;

import java.util.Scanner;

/**
 * Created by Administrator on 2019/2/15 0015.
 */
public class DaDaRentCarSystem {
    public static void main(String[] args) {
        //初始化汽车种类
        Car[] carArray = new Car[6];
        carArray[0] = new AudiA4("奥迪A4",500,4);
        carArray[1] = new MaZiDa6("马自达6", 400, 4);
        carArray[2] = new PiKaXue6("皮卡雪6", 450, 4, 2);
        carArray[3] = new JinLong("金龙", 800, 20);
        carArray[4] = new SongHuaJiang("松花江", 400, 4);
        carArray[5] = new YiWeiKe("依维柯", 1000, 20);

        Scanner in = new Scanner(System.in);
        System.out.println("欢迎使用答答租车系统：");
        System.out.println("您是否要租车：1是 0否");
        int isRentCar = in.nextInt();
        float priceCount = 0.0f;
        int personCount = 0;
        float goodsCount = 0.0f;

        if (isRentCar == 1) {
            System.out.println("您可租车的类型及其价目表：");
            System.out.println("序号\t汽车名称\t租金\t容量\t");
            for (int i = 0;i<carArray.length;i++) {
                Car car = carArray[i];
                if (car instanceof LoadPersonCar) {
                    System.out.println(i +".\t" +car.name+"\t"+car.rentPrice+"元/天\t" + "载人：" + car.personCapacity +"人\t");
                } else if (car instanceof LoadGoodsCar) {
                    System.out.println(i +".\t" +car.name+"\t"+car.rentPrice+"元/天\t" + "载货：" + car.goodsCapacity +"吨\t");

                } else {
                    System.out.println(i +".\t" +car.name+"\t"+car.rentPrice+"元/天\t" + "载人：" + car.personCapacity +"人 " +"载货：" + car.goodsCapacity +"吨\t");
                }

            }
            System.out.println("请输入您要租汽车的数量：");
            int rentNum = in.nextInt();
            Car[] rentCar = new Car[rentNum];
            for (int i = 0;i<rentNum;i++) {
                System.out.println("请输入第" + i +"辆汽车的序号：");
                int seq = in.nextInt();
                rentCar[i] = carArray[seq];
            }
            System.out.println("请输入租车天数：");
            int day = in.nextInt();
            for (Car car : rentCar) {
                if (car instanceof LoadPersonCar) {
                    personCount += car.personCapacity;
                    priceCount += car.rentPrice * day;

                } else if (car instanceof LoadGoodsCar) {
                    goodsCount += car.goodsCapacity;
                    priceCount += car.rentPrice * day;
                } else {
                    personCount += car.personCapacity;
                    goodsCount += car.goodsCapacity;
                    priceCount += car.rentPrice * day;
                }
            }
            System.out.println("您的账单：");

            System.out.println("***可载人的车有：");
            for (int i = 0;i<rentCar.length;i++) {
                if (rentCar[i] instanceof LoadPersonCar || rentCar[i] instanceof LoadPersonAndGoodsCar) {
                    System.out.print(rentCar[i].name +" ");

                }

            }
            System.out.println("共载人：" + personCount + "人" );
            System.out.println("***可载货的车有：");
            for (int i = 0;i<rentCar.length;i++) {
                if (rentCar[i] instanceof LoadGoodsCar || rentCar[i] instanceof LoadPersonAndGoodsCar) {
                    System.out.print(rentCar[i].name + " ");
                }

            }
            System.out.println("共载货：" + goodsCount + "吨" );
            System.out.println("租车总价格：" +priceCount+"元" );

        }



        }

    }

创建类的实例中，代码块的执行顺序：

    静态初始化代码块 ---》 普通初始化代码块 ---》 构造方法

注意：静态初始化代码块在类加载时只执行一次

静态方法：

    1 . 可以直接使用类名来调用静态方法

    2 . 静态方法只能直接调用静态成员变量；如果想调用非静态成员变量，则需要创建类的对象，再通过对象来访问非静态成员变量

成员变量和局部变量的区别：

    1 . 作用域不同：

        局部变量的作用域是在定义它的方法内；

        成员变量的作用域是在整个类中

    2 . 优先级不同：

        如果说局部变量和成员变量同名时，局部变量具有更高的优先级（就近原则）

    3 . 初始值不同：

        局部变量没有默认值，需要自定义；成员变量有初始值

    4 . 同一个方法中不能有同名的局部变量

[修饰符]class 类名 extends 父类 impiements接口1，接口2.。。{

 类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法

}

如果要继承父类，继承父类必须在实现接口之前

abstract  class  Animal {abstract void grow();}

static 修饰静态初始化的时候优先被执行切只执行一次

成员变量有初始值，局部变量没有初始值。

static

    Java中被static修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊更推荐用类名访问～～

    使用static可以修饰变量、方法和代码块。

1. 引用多态
   

             父类的引用可以指向本类的对象

             父类的引用可以指向子类的对象

    2.方法多态

             创建本类对象时，调用的方法为本类方法

             创建子类对象时，调用的方法为子类重写的方法或者继承的方法

obj.getClass（）             obj

 类对象                          类的对象

更关注代码信息                  更关注数据信息