Java 中的 static 使用之静态方法
1、 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。
如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。


2、 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量

Java 中的 static 使用之静态变量

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

1、 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如：

如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。如：

2、 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量，如下所示：

3、 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。如：

1. 子类构造过程中，必须调用其父类的构造方法

2. 子类构造方法中没有显示调用父类构造方法，系统默认调用父类无参构造方法

3. 如果显示调用构造方法，必须在子类狗仔方法第一行

4. 如果子类构造方法中没有显示调用父类构造方法。父类又没有无参构造方法，编译出错

不写构造方法，默认无参

只写一个有参，默认有参

有参无参都写，默认都用

final修饰类  该类不允许被继承

final修饰方法  该方法不允许被重写

final修饰属性   该属性不会默认初始化，必须有初始值或者在构造方法中赋值

final修饰变量  该变量的值只能赋一次值

Maincallcar.java

package dadacallcar;

import java.util.*;

public class Maincallcar {

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.println("欢迎使用答答打车系统");

System.out.println("您是否要租车：1是 0否");

Scanner inp1=new Scanner(System.in);

int a=inp1.nextInt();

if(a==0) {

inp1.close();

return ;

}

Car[] cararr= {

new Bus(1,"奥迪A4",500,4,0),

new Bus(2,"马自达6",400,4,0),

new Pickup(3,"皮卡雪",450,4,2),

new Bus(4,"金龙",800,20,0),

new Truck(5,"松花江",400,0,4),

new Truck(6,"依维柯",1000,0,20)

};

System.out.println("您可租车的类型及其价目表：");

for(int i=0;i<cararr.length;i++)

{

System.out.println(cararr[i].getNumber()+"\t"

+cararr[i].getName()+"\t"

+cararr[i].getRent()+"\t"

+cararr[i].getForpp()+"\t"

+cararr[i].getForgood());

}

System.out.println("请输入您要租汽车的数量:");

Scanner inp2=new Scanner(System.in);

int b=inp2.nextInt();//b为租车数量

int[] arrinp=new int[b];//arrinp为要租的车序号的数组

for(int i=0;i<b;i++)

{

System.out.println("请输入第"+(i+1)+"辆车的序号：");

Scanner inp0=new Scanner(System.in);

int tempnumber=inp0.nextInt();

arrinp[i]=tempnumber;

}

System.out.println("请输入租车天数:");

Scanner rentday=new Scanner(System.in);

int rentday_num=rentday.nextInt();

System.out.println("您的账单:");

System.out.println("***可载人的车有：");

int forpptt=0;

for(int i=0;i<b;i++)

{

for(int j=0;j<6;j++)

{

if(arrinp[i]==cararr[j].getNumber() && cararr[j].getForpp()!=0) {

System.out.print(cararr[j].getName()+"\t");

forpptt+=cararr[j].getForpp();

}

continue;

}

}

System.out.println("共载人："+forpptt+"人");

System.out.println("***载货的车有：");

int forgoodtt=0;

for(int i=0;i<b;i++)

{

for(int j=0;j<6;j++)

{

if(arrinp[i]==cararr[j].getNumber() && cararr[j].getForgood()!=0) {

System.out.print(cararr[j].getName()+"\t");

forgoodtt+=cararr[j].getForgood();

}

continue;

}

}

System.out.println("共载货："+forgoodtt+"吨");

int money=0;

for(int i=0;i<b;i++)

{

for(int j=0;j<6;j++)

{

if(arrinp[i]==cararr[j].getNumber()) {

money+=cararr[j].getRent();

}

continue;

}

}

money=money*rentday_num;

System.out.println("***共租车总价格："+money+"元");

inp2.close();

inp1.close();

}

}

--------------------------------------

Car.java

package dadacallcar;

public class Car {

private int number;

private String name;

private int rent;

private int forpp;

private int forgood;

public int getRent() {

return rent;

}

public void setRent(int rent) {

this.rent = rent;

}

public int getNumber() {

return number;

}

public void setNumber(int number) {

this.number = number;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getForpp() {

return forpp;

}

public void setForpp(int forpp) {

this.forpp = forpp;

}

public int getForgood() {

return forgood;

}

public void setForgood(int forgood) {

this.forgood = forgood;

}

}

-------------------------------

Bus.java

package dadacallcar;

public class Bus extends Car {

public Bus() {}

public Bus(int number,String name,int rent,int forpp,int forgood) {

setNumber(number);

setName(name);

setRent(rent);

setForpp(forpp);

setForgood(forgood);

}

}

----------------------

Pickup.java

package dadacallcar;

public class Pickup extends Car {

public Pickup() {}

public Pickup(int number,String name,int rent,int forpp,int forgood) {

setNumber(number);

setName(name);

setRent(rent);

setForpp(forpp);

setForgood(forgood);

}

}

--------------------------

Truck.java

package dadacallcar;

public class Truck extends Car {

public Truck() {}

public Truck(int number,String name,int rent,int forpp,int forgood) {

setNumber(number);

setName(name);

setRent(rent);

setForpp(forpp);

setForgood(forgood);

}

成员内部类的使用方法：

1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

继承初始化顺序：

父类属性初始化--父类构造方法--子类属性初始化--子类构造方法

java会给成员变量一个初始化的值0

Java不会给局部变量初始值

object类：（是所有类的父类，如果一个类没有使用extends关键字明确标示继承另外一个类，那么这个类默认继承object类。 object类中的方法，适合所有子类。）

1. toString()方法： 在object类里面定义toString（）方法的时候返回的对象的哈希code码（对象地址字符串）【可通过重写toString()方法表示出对象的属性

2.  equals()方法：比较对象的引用是否指向同一块内存地址。但一般情况下比较两个对象时比较他的值是否一致，所以要进行重写。

Java中super的使用：

子类的构造过程当中必须调用其父类的构造方法

如子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法。

如果显示调用构造方法，必须在子类的构造方法第一行。

如子类构造方法中既没有显式调用父类的构造方法，而父类又没有无参的构造方法，则编译出错。

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

继承 final关键字：

final可以修饰类，方法，属性和变量。

修饰类 -> 则该类不允许被继承

修饰方法 -> 则该方法不允许被重写

修饰属性 -> 则该类的属性不会进行隐式的初始化（类的初始化属性必须拥有值）或在构造方法中赋值（但只能选其一）【确定属性初始化值后，不能再修改】

修饰变量 -> 则该变量只能赋一次值，即变为常量

继承的初始化顺序：

1. 现初始化父类再初始化子类

2. 先执行属性初始化，再执行构造方法初始化