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

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

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

内部类不可直接加使用外部类的成员变量，要用this关键字，使用方法：外部类.this.成员变量

成员内部类、方法内部类、静态内部类，在实际开发编程中有什么用

https://blog.csdn.net/hivon/article/details/606312

public class HelloWorld {

    public class Inner {

public void show() {

System.out.println("welcome to imooc!");

}

}

public static void main(String[] args) {

HelloWorld hello = new HelloWorld();

Inner i = hello.new Inner();

i.show();

在内部类中构造方法时要引入对象hello.new.Inner

内部类的主要作用如下：

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

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

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

this表当前对象

private仅自己类中可用，不加修饰符可供同类同包名使用，protect同类同包名以及子类（儿子）可用，public任意可用

封装将属性改为private修饰，创建getter/setter方法，在这方法中加入属性控制语句

使用其他包内的类，import 包名.类名  

成员变量：在类中定义，用来描述对象将要有什么，可以用在整个类中。java会给成员变量赋初始值0

局部变量：在类的方法中定义，在方法中临时保存数据，只能用在所在的方法中。java不会给局部变量赋初始值。

成员变量和局部变量可以重名，局部变量具有更高的优先级，取局部变量的值。

目前学的初始化有3种：1.初始化块{ }；2.静态初始化static{ }；3.构造方法初始化 类名（）{ }；创建对象时 类名 对象名=new 类名（），此时三种初始化都执行，顺序为213，而静态初始化只能执行一次，即第一次创建对象有执行，第二次创建对象就没了

package actual_combat;

public abstract class Auto {
    private int num;//序号
    private String name;//车名
    private int price;//租价
    private int carload;//载人数
    private int cargoload;//载货量

    public int Number(){
        return num;
    }
    public void Number1(int num) {
        this.num=num;
    }
    public String Name(){
        return name;
    }
    public  void Name1(String name){
        this.name=name;
    }
    public int Price(){
        return price;
    }
    public void Price1(int price){
        this.price=price;
    }
    public int Carload(){
        return carload;
    }
    public void Carload1(int carload){
        this.carload=carload;
    }
    public int Cargoload(){
        return cargoload;
    }
    public void Cargoload1(int cargoload){
        this.cargoload=cargoload;
    }

    @Override
    public String toString() {
        return num+"  "+name+"\t"+price+"    "+carload+"       "+cargoload;
    }
}
package actual_combat;

public class Bus extends Auto {
    public Bus(int num,String name,int price,int carload){
        this.Number1(num);
        this.Name1(name);
        this.Price1(price);
        this.Carload1(carload);
    }
}
package actual_combat;

public class Car extends Auto {
    public Car(int num,String name,int price,int carload){
        this.Number1(num);
        this.Name1(name);
        this.Price1(price);
        this.Carload1(carload);
    }
}
package actual_combat;

public class Pickup extends Auto{
    public Pickup(int num,String name,int price,int carload,int cargoload){
        this.Number1(num);
        this.Name1(name);
        this.Price1(price);
        this.Carload1(carload);
        this.Cargoload1(cargoload);
    }
}
package actual_combat;

public class Truck extends Auto{
    public Truck(int num,String name,int price,int cargoload){
        this.Number1(num);
        this.Name1(name);
        this.Price1(price);
        this.Cargoload1(cargoload);
    }
}
package actual_combat;
import java.util.Scanner;

public class Runtest {
    public void runtest() {
        Auto[] cars = new Auto[6];
        cars[0] = new Car(1, "奥迪A4", 500, 4);
        cars[1] = new Car(2, "马自达6", 400, 4);
        cars[2] = new Pickup(3, "丰田皮卡", 450, 4, 2);
        cars[3] = new Bus(4, "金龙", 800, 20);
        cars[4] = new Truck(5, "松花江", 400, 4);
        cars[5] = new Truck(6, "依维柯", 1000, 20);
        System.out.println("您可租车的类型即价格表！");
        System.out.println("序号 车名  租价  载客人数  载货量");
        for (int i = 0; i < cars.length; i++) {
            System.out.println(cars[i]);
        }
        System.out.println("请输入租用汽车的数量！");
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();//输入选项
        while (a <= 0) {
            System.out.println("WARING！输入车辆数量有误！！！");
            a = scanner.nextInt();//输入选项
        }
            int endPrice = 0;//总价格
            int allpeople = 0;//总人数
            int allthing = 0;//总货物数
            String[] NAME = new String[a];//数量为a的所有车型名字
            for (int i = 0; i < a; i++) {
                System.out.println("请输入第" + (i + 1) + "量车序号");
                    int b = scanner.nextInt();//输入选项
                    NAME[i] = cars[b - 1].Name();//第b辆汽车的名字
                    endPrice += cars[b - 1].Price();//第b辆汽车的价格
                    allpeople += cars[b - 1].Carload();//第b辆汽车的载人数
                    allthing += cars[b - 1].Cargoload();//第b辆汽车的载货数
            }
            System.out.println("请输入需要租用的天数！");
            int c = scanner.nextInt();
            System.out.println("确认本次订单！");
            System.out.println("本次一共使用了：");
            for (int i = 0; i < a; i++) {
                System.out.print(NAME[i]);
                System.out.println("!");
            }
            System.out.println("本次一共租用：" + a + "  辆汽车！可载人数为：" + allpeople + "!可载物：" + allthing + "吨");
            System.out.println("本次租车一共花费" + endPrice * c + "元！");
    }
}
package actual_combat;

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        System.out.println("欢迎来到租车系统！继续请按 1 ；退出请按 0 ！");
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();//输入选项
        while (a != 1 && a != 0) {
            System.out.println("请重新输入 选项 ！");
            a = scanner.nextInt();
        }
        if (a == 1) {
         new Runtest().runtest();
        }
    }
}

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

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

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

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

显示和流程分析:

业务模型分析输出结果----对应----用例图；

数据模型分析输出结果----对应----类图；

显示和流程分析输出结果---对应----时序图和界面原型图；

原型工具有：

Axure RP |墨刀|Sketch|石墨文档；

~~~~~~~~~~~~~~~~~~~~~

显示和流程分析:

业务模型分析输出结果----对应----用例图；

数据模型分析输出结果----对应----类图；

显示和流程分析输出结果---对应----时序图和界面原型图；

原型工具有：

Axure RP |墨刀|Sketch|石墨文档；

~~~~~~~~~~~~~~~~~~~~~