static修饰的内部类是静态内部类，如果内部类与外部类的静态成员名称相同，则通过 类名.静态成员 访问外部类的静态成员，如果名称不同，则可直接调用

当创建内部类的对象时，不需要外部类的对象，可以直接创建 【内部类 对象名=new 内部类()】

静态内部类不能直接访问外部类的非静态成员，但可通过new 外部类().成员的访问

普通内部类中， 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。

静态成员内部类中，如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

一般静态变量都是公用的、全局的，程序一启动就会在内存开辟一块空间，存放它们。静态的不必实例化就能直接使用，是说在没有生成任何对象时就能运用该方法，所以静态方法里不能对非静态的成员变量做操作。一般静态方法操作静态成员变量或全局变量。

要搞清楚这个问题，我们需要清楚他们之间有什么区别，有什么优势和劣势。

首先看看静态与非静态方法的区别：

静态方法　　　　　　　　　　　　　　　　　 　 |  实例方法

1、静态方法可以通过“类.方法()”调用 　 　　　　 | 要在对象实例化后使用对象调用

2、只能使用静态变量和局部变量　　　　　　　　| 所有变量都可以使用

3、静态方法不能被子类重写　　　　　　　　　　| 实例方法可以

4、接口不能定义静态方法　　　　　　　　　　   | 实例方法可以

从上面区别来看，静态方法只有一个优势，就是调用的时候不用实例化，其他情况下跟实例方法相比都是处于劣势。那么我们在什么情况下会使用到静态方法？相信大家第一时间会想到一样的东西，工具类Util。工具类给我们开发带来了大大的方便，归根到底是“不用实例化就能用”的功劳。这是静态方法的一个优势。

而静态方法的劣势也很明显，局限性很大，不能重写，不能引用普通变量，接口不能定义等等。。。可能还有很多我没列举出来。

那究竟什么时候该用静态方法？我们就要最大化利用其优势而避其缺点：

1、一个方法完成一个独立的功能，而且不会干扰到其他方法或变量，则即使删掉这个方法，对其他东西都没有任何影响。

2、不依赖构造方法，不依赖接口，不依赖继承。（这也是为什么越学面向对象，越会纠结这个问题）

举个例子：String类即使删掉 static valueOf(Object obj)方法，也不会影响实例方法chatAt(int index)的使用。当然它可能会影响其他重载的valueOf方法。

至于现在网上很多资料都有一个误区，就是说静态方法一开始加载，会占用内存，而实例方法不会。这个说话其实是错误的，它们都是一样一开始就会加载，而且只会占用一份内存。因为方法不是变量，它只需要有一份内存就够了。而变量则不一样

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

下面来看看静态变量与非静态变量

静态变量　　　　　　　　　　　　　　　　　 　 |  非静态变量

1、可以通过“类.变量”来引用。　　　　　　　　  | 只能通过实例对象来引用。

2、程序运行时分配内存　　　　　　　　　　　　|  类实例化时分配内存。

3、只有一份内存被分配　　　　　　　　　　　　|  有多少个类被实例化，就有多少个该类的变量那么多份内存被分配。

4、静态变量定义后必须声明初始化　　　　　　   | 非静态变量可以延迟初始化。

其他.....

很明显，静态变量拥有的优势不少，第一点不用说。第2、3点可以利用它来做一个整个程序的全局变量，因为任何修改都只会指向同一份内存。

而第3点优势恰好就是我们的“饿汉式单例模式”的一个最简单的实现。

创建静态内部类时//////因为他是静态的内部类，不依靠外部类存在，所以可以不需要外部类对象，直接创建内部类/////

new一个对象时，其实是调用它的构造方法；

new Inner（）实际上是调用其构造方法创建对象，调用方法时我们得用这个类的对象去调用，所以要创建一个外部类对象去调用这个方法；

而static修饰的是类的对象，在类加载时就完成了创建，所以可以直接使用

package com.dada;
public abstract class Car {
public int danjia;
public int zaizhong;
public float time;
public abstract void only(float f);
}
package com.dada;
public class Huoc extends Car { 
@Override 
public void only(float time) {  
float zm;  danjia=100;  zm=danjia*time;  
System.out.println("货车单价每小时100元，您租用时间为："+time+"小时"+"请支付："+zm+"元"); 
    }
}
package com.dada;public class Jiaoc extends Car { @Override public void only(float time) {  // TODO 自动生成的方法存根  float zm;  danjia=60;  zm=danjia*time;  System.out.println("轿车单价每小时60元，您租用时间为："+time+"小时"+"请支付："+zm+"元"); }}

package com.dada;public class Dabc extends Car { @Override public void only(float time) {  // TODO 自动生成的方法存根  float zm;  danjia=80;  zm=danjia*time;  System.out.println("巴士单价每小时80元，您租用时间为："+time+"小时"+"请支付："+zm+"元"); }}

package com.dada;public class Pikac extends Car { @Override public void only(float time) {  // TODO 自动生成的方法存根  float zm;  danjia=70;  zm=danjia*time;  System.out.println("皮卡车单价每小时70元，您租用时间为："+time+"小时"+"请支付："+zm+"元"); }}


package com.dada;
import java.util.Scanner;
public class Home {
public static void main(String [] ages) { 
int number = 0; int count = 0; 
Car a=new Huoc(); 
Car b=new Jiaoc();
 Car c=new Dabc();
  Car d=new Pikac();
   System.out.println("    ======哒哒租车系统======\n"); 
   System.out.println("序 号     车  型      单   价        载重/载人  "); 
   System.out.println(" 1     货 车     100/时                15吨      "); 
   System.out.println(" 2     轿 车       60/时                  5人      "); 
   System.out.println(" 3     巴 士       80/时                20人      "); 
   System.out.println(" 4     皮 卡       70/时          2吨+5人      "); 
   System.out.println(); 
   do {  
   System.out.println("请输入所选车辆序号：");
    @SuppressWarnings("resource") 
    Scanner sc=new Scanner(System.in); 
    number=sc.nextInt(); 
     if(number==1) {  
     System.out.println("请输入租用时间：");   a.only(sc.nextFloat());  count=1; } 
     else if(number==2) { 
      System.out.println("请输入租用时间：");   b.only(sc.nextFloat());  count=1; } 
      else if(number==3) {  
      System.out.println("请输入租用时间：");   c.only(sc.nextFloat());  count=1;  } 
      else if(number==4) {  
      System.out.println("请输入租用时间：");   d.only(sc.nextFloat());  count=1; } 
      else {  
      System.out.println("没有该车辆请重新选择！");   } }while(count!=1);
      }}

封装：

修改属性的可见性——设为private

创建setter/getter方法——用于属性的读写

在setter/getter方法中加入属性控制语句——对属性值的合法性进行判断

如果希望静态方法中调用非静态变量和非静态方法，需要通过创建类的对象，然后通过类的对象来访问非静态变量和非静态方法！

成员变量：定义在类中；

局部变量：定义在方法中。

final代表“最终的”含义

创造子类的对象后，先执行父类的构造方法，再创造子类的构造方法

顺序：父类属性初始化 -> 父类构造方法 -> 子类属性初始化 -> 子类构造方法

系统中的包

静态初始化块，初始化块，构造方法执行顺序

当使用静态内部类的时候。创建静态内部类对像时，不需要先创建外部对象，可以直接创建

内部类 对象名 = new 内部类（）；

什么叫做类

静态初始化块只在该类加载的时候运行一次，并且最先被执行，如果再次创建一个对像时，并不会再执行一次静态初始化块

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

怎么写java的构造

怎么

引用类型转换

1. 向上类型转换（隐式/自动类型转换），是小类型到大类型的转换（无风险）

2. 向下类型转换（强制类型转换），是大类型到小类型（有风险）

3. instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题