创建对象的时候，执行的是类的构造方法；构造方法与类名相同；构造方法用来初始值；所以在main方法中创建hello对象时，执行了HelloWorld类的构造方法；对name进行初始化；

类在初始化时，执行顺序：静态初始化代码块（仅在类加载时执行，创建为对象时不执行）  -> 普通初始化代码块  ->  构造方法

在静态方法中，可以直接调用统类的静态变量或静态方法；不能访问非静态变量；如果想要使用，可以创建类的对象，通过对象来访问非静态变量；

在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。

需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

我们来看一段代码：

运行结果：

通过输出结果，我们可以看到，程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象 hello2 时并未执行静态初始化块。

//父类

public  class Car(){

private int id;

private String name;

private int price;

public int getid{

return id;

}

public void setid{

this.id =id;

}

public int getname{

return name;

}

public void setname{

this.name =name;

}

public int getprice{

return price

}

public void setprice{

this.price =price;

}

}

//客车子类

public kecar extends Car{

private int keliang;

    public kecar(int id,String name,int price,int keliang){

   this.setid(id);

        this.setname(name);

        this.setprice(price);

        this.keliang=keliang; 

}

public int getkeliang{

   return keliang;

}

    public void setkeliang{

   this.keliang =keliang;

}   

}

//皮卡子类

public pika extends Car{

  private double huoliang;

  private int keliang;

  public pika(int id,String name,int price,int keliang,double huoliang,int keliang){

this.setid(id);

    this.setname(name);

    this.setprice(price);

    this.setkeliang(keliang);

    this.huoliang=huoliang;

    this.keliang=keliang;

  }

  public double gethuoliang{

return huoliang;

  }

  public void sethuoliang{

this.huoliang=huoliang;

  }

  public int getkeliang{

return keliang;

}

  public void setkeliang{

this.keliang =keliang;

}

}

//货车子类

public huocar extends Car{

private double huoliang;

    public huocar(int id,String name,int price,int keliang,double huoliang){

   this.setid(id);

        this.setname(name);

        this.setprice(price);

        this.setkeliang(keliang);

   this.huoliang=huoliang;

}

    public double gethuoliang{

   return huoliang;

  }

    public void sethuoliang{

   this.huoliang=huoliang;

  }

}

//测试类

public class Test{

public static void main(String[] args){

  System.out.println("欢迎使用大大打车系统")；

  System.out.println("是否租车：1.是 其他键退出")

  Test test=new Test();

  while(test.test1()){

System.out.println("你可以选择的车型和价目表");

         System.out.println("------------------------");

         Car[] cars={new kecar(1,"奥迪A8",800,4),

            new kecar(2,"兰博基尼",3000,4),

new pika(3,"福特猛禽",1300,4,2),

new huocar(4,"斯柯达",500,4),

new huocar(5,"依维柯",1000,20)

};

System.out.println("编号"+" "+"\t"+"车型"+"  "+"\t"+"租金"+" "+"\t"+"容量");

        //foreach的格式:for(元素类型T 每次循环元素的名称O : 循环对象)

for(Car car:cars){

          if(car.getClass().equals(kecar.class)){

System.out.println(car.getid()+"\t"+"\t"+car.getname()+"\t"+"\t"+car.getprice()+"/天"

+"\t"+"载客"+((kecar)car).getkeliang()+"/人"); //((kecar)car)强制转换

 }

 if(car.getClass().equals(pika.class)){

System.out.println(car.getid()+"\t"+"\t"+car.getname()+"\t"+"\t"+car.getprice()+"/天"

+"\t"+"载客"+((pika)car).getkeliang()+"/人"+" "+"载货"+((pika)car).gethuoliang()+"/吨");

 }

          if(car.getClass().equals(huocar.class)){

System.out.println(car.getid()+"\t"+"\t"+car.getname()+"\t"+"\t"+car.getprice()+"/天"

+"\t"+"载货"+((huocar)car).gethuoliang()+"/吨"); 

  }

  }

        System.out.println("------------");

        System.out.println("请输入你要租车的数量")；

//新建一个扫描器（创建一个Scanner，控制台会一直等待输入，直到敲回车键结束，把所输入的内容传给Scanner，作为扫描对象）

        Scanner c =new Scanner(System.in);

//c.nextInt()是扫描到输入的值

int carnum= c.nextInt();//用于接收租车数量

List<Car> carlist=new ArrayList<>();//调用集合框架list用于存储客户租车清单

int add=0;//扩展列表容量

List<Car> carlistkecar=new ArrayList<>();//用于存储载人的车辆

        List<Car> carlisthuocar=new ArrayList<>();//用于存储载货的车辆

        int passengerCar=0;//载人数

        int Carhuo=0;//载货数

        int Carprice=0;//总资金

for(i=0;i<=carnum;i++){

   System.out.println("请输入你要租第"+(i+1)+"号车");

int num=c.nextInt();

carlist.add(cars[num-1]);

System.out.println("成功添加"+carlist.getadd().getname());

if(cars[num-1].getClass().equals(kecar.class)){

passengerCar+=((kecar)carlist.getadd().getkeliang());

Carprice+=((kecar)carlist.getadd().getprice());

carlistkecar.add(carlist.getadd());

}

if(cars[num-1].getClass().equals(pika.class)){

passengerCar+=((pika)carlist.getadd().getkeliang());

Carhuo+=((pika)carlist.getadd().gethuoliang());

Carprice+=((pika)carlist.getadd().getprice());

carlistkecar.add(carlist.getadd());

carlisthuocar.add(carlist.getadd());

}

if(cars[num-1].getClass().equals(huocar.class)){

Carhuo+=((huocar)carlist.getadd().gethuoliang());

Carprice+=((huocar)carlist.getadd().getprice());

carlisthuocar.add(carlist.getadd());

}

add++;

}

System.out.println("请输入你要租车的天数")；

Scanner d=new Scanner(System.in);

int carDay=d.nextInt();

Carprice=Carprice*carDay;

System.out.println("租车完成"+"\n"+"开始统计数据");

System.out.println("你共租了"+carnum+"辆车：");

for(Car car:carlist){

System.out.print(car.getname());

}

System.out.println();//直接换行或为了排版和打印特殊图案

System.out.println("共租"+carDay+"天");

System.out.println("可载"+passengerCar+"人");

System.out.println("可载"+Carhuo+"吨");

System.out.println("共需租金"+Carprice+"元");

System.out.println("请付钱")

System.out.println("--------");

Scanner q=new Scanner(System.in);

if(Carprice!=q.nextInt()){

System.out.println("付钱金额错误，请重新付钱");

}else{

System.out.println("--------------");

System.out.println("交易成功");

}

System.out.println();

System.out.println("----感谢您的使用----")；

System.out.println("继续租车请按1，退出任意键")；

  }

       System.out.println("----欢迎你再次使用，再见------");

}

//捕获异常

public boolean test1{

try{

Scanner t=new Scanner(System.in);

if(t.nextInt==1){

return true;

}else{

return false;

}

   }catch(Exception e1){

return false;

}

}

}

成员变量和局部变量区别

然而在某些时候，我们更希望该类所有的对象共享同一个成员。此时就是 static 大显身手的时候了！！

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

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

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

静态初始化块掌握很不熟悉，一定化勤加练习！

对于静态方法，可以直接使用类名调用静态方法，也可以通过对象名调用

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

super关键字的应用

继承初始化顺序

记住一个原则,静态的只能访问静态的,因为他们在对象没创建前就存在了.

如果想访问非静态的则必须初始化该对象,因为只有初始化后对象在内存才存在(静态的除外)