成员内部类使用方法：

1、什么是内部类

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

2、Inner类的方法可以随意访问Outer类的任何成员变量；

 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，即使Outer类中的数据修饰符为private，Inner类中定义的方法也可以访问；

3、 内部类对象的创建

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

例如：Outer outclass = new Outer();

Inner inclass = outclass.new Inner();

4、编译上面的程序后，会发现产生了两个 .class 文件，一个是外部类的 .class 文件，另一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class；

5、外部类如何调用内部类的方法和成员变量？

外部类不能够直接使用内部类的方法和成员，必须先创建内部类的对象，然后通过内部类的对象来访问成员变量和方法；

6、Inner类与Outer类有成员变量重名，Inner类的调用方法；

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

例如：一个内部类和外部类都包含成员变量byte，如果内部类想要访问外部类的byte变量，格式如下：

Outer.this.b；

一、项目分析：
1、数据模型分析
2、业务模型分析
3、显示和流程分析

（一）数据模型分析
1、将现实世界的事与物的主要特征 --分析--抽象--> 信息系统数据存取的数据结构以及约束信息，数据结构的组成：操作（方法）、属性
（二）业务模型分析
1、在设计应用程序前，应该明确该应用必须执行哪些任务。
·分析业务需求量是应用程序开发中最重要的步骤之一。
·确认业务需求的目的在于创建一个能同时满足零售商和消费者需要的解决方案。
2、本程序中，面向消费者的业务有：【选车】，【租车天数】，【统计金额】，【载客、载货量】
（三）显示和流程分析
1、显示：用户可以看到的信息提示界面
2、流程：显示信息的执行过程和步骤
3、在本系统中，以命令行显示提示信息和结果，要考虑其样式，用户输入的数据不同如何提示，如何处理并显示结果。例如：请选择车辆->请输入序号->输出总金额...

package com.imooc;

public class Car {
 private int cargo;//载货量
 private int carPerson;//载人量
 private String carName;//车名
 private int rentMoney;//租金

 //使用set、get方法读写属性
 public void setCargo(int cargo) {
  this.cargo=cargo;
 }
 public int getCargo() {
  return cargo;
 }
 public void setcarPerson(int carPerson) {
  this.carPerson=carPerson;
 }
 public int getcarPerson() {
  return carPerson;
 }
 public void setcarName(String carName) {
  this.carName=carName;
 }
 public String getcarName() {
  return carName;
 }
 public void setrentMoney(int rentMoney) {
  this.rentMoney=rentMoney;
 }
 public int getrentMoney() {
  return rentMoney;
 }
}

public class passengerCar extends Car {
 public passengerCar(String carName,int cargo,int carPerson,int rentMoney) {
  this.setCargo(cargo);
  this.setcarName(carName);
  this.setcarPerson(carPerson);
  this.setrentMoney(rentMoney);
 }
 //toString方法通常只是为了方便输出，在屏幕上显示出来。重写toString方法返回乘客车车辆信息
 public String toString() {
  return this.getcarName()+"载重："+this.getCargo()+"t，载人"+
      this.getcarPerson()+"个人，租金"+this.getrentMoney();
 }
}

public class Truck extends Car {
 public Truck(String carName,int cargo,int carPerson,int rentMoney) {
  this.setCargo(cargo);
  this.setcarName(carName);
  this.setcarPerson(carPerson);
  this.setrentMoney(rentMoney);
 }
 //toString方法通常只是为了方便输出，在屏幕上显示出来。重写toString方法返回货车车辆信息
 public String toString() {
  return this.getcarName()+"载重："+this.getCargo()+"t，载人"+
       this.getcarPerson()+"个人，租金"+this.getrentMoney();
 }
}

public class Pickup extends Car {
 public Pickup(String carName,int cargo,int carPerson,int rentMoney) {
  this.setCargo(cargo);
  this.setcarName(carName);
  this.setcarPerson(carPerson);
  this.setrentMoney(rentMoney);
 }
 //toString方法通常只是为了方便输出，在屏幕上显示出来。重写toString方法返回皮卡车车辆信息
 public String toString() {
  return this.getcarName()+"载重："+this.getCargo()+"t，载人"+
       this.getcarPerson()+"个人，租金"+this.getrentMoney();
 }
}

import java.util.Scanner;

public class dadaText {
 public static void main(String[] args) {
  //利用多态性，对各类车实例化并保存到数组
  Car[] cars= {
   new passengerCar("奥迪A4", 0, 4, 400),
   new passengerCar("金龙", 0, 10, 600),
   new Truck("松花江", 4, 0, 400),
   new Truck("依维柯", 30, 0, 800),
   new Pickup("皮卡雪6", 2, 4, 500),
   new Pickup("皮卡车", 4, 20, 1000),
  };
  //进入提示显示步骤
  System.out.println("欢迎使用达达租出系统！");
  System.out.println("是否租车：yes/no");
  //读取用户键入的信息并判断
  Scanner input=new Scanner(System.in);
  String t=input.next();
  if("yes".equals(t)) {
   System.out.println("您可租的车型及价目表如下：");
   System.out.println("序号"+"\t车名"+"\t\t载人数（人）"+"\t载货量（吨）"+"\t租金（元/天）");
   //输出实例化的各类车
   for(int i=0;i<cars.length;i++){
    System.out.println((i+1)+"\t"+cars[i]);//调用println函数时会自动调用toString()方法，使其在屏幕中显示出来
   }
   //租车的数量以及哪种车型
   System.out.println("请输入要租车的数量：");
   int carNum=input.nextInt();
   Car[] newCars = new Car[carNum];
   for(int j=0;j<carNum;j++) {
    System.out.println("请输入第"+(j+1)+"序号");
    int yy=input.nextInt();
    newCars[j]=cars[yy-1];
   }
   //租车的天数
   System.out.println("请输入要租车的天数");
   int times=input.nextInt();
   
   //输出账单
   int totalRent=0;
   int totalCargo=0;
   int totalPerson=0; 
   System.out.println("您本次的租车账单："+"/n");
   System.out.println("此次选用车型"+"/n");
   for(int i=0;i<carNum;i++)
   {
    System.out.println(newCars[i].getcarName()+"/t");
    totalCargo+=newCars[i].getCargo();
    totalPerson+=newCars[i].getcarPerson();
    totalRent+=newCars[i].getrentMoney()*times;
   }
   System.out.print("\n");
   System.out.println("共可载客"+totalPerson+"人");
   System.out.println("共可载货"+totalCargo+"吨");
   System.out.println("请付租金"+totalRent+"元");
   System.out.print("\n");
   System.out.print("谢谢惠顾，欢迎下次光临");
   input.close();
  }
 }
}

                                       接口

       1.接口概念;

             类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细，它只规定这些类里必须提供某些方法。

        2.接口定义：

             和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。

              接口定义的基本语法：

               【修饰符】interface 接口名 【extends 父接口1，父接口2...】

                 {

                      零个到多个常量定义...

                       零个到多个抽象方法的定义...

}

                  接口就是用来被继承、被实现的，修饰符一般建议用public

                  注意：不能使用private和protected 修饰接口

         3.接口定义：

               常量;

                   接口中的属性是常量，即使定义时不添加public static final修饰符，系统也会自动加上。

                 方法：

                     接口中的方法只能是抽象方法，总是使用，即使定义时不添加public  abstract 修饰符，系统也会自动加上。

             4.使用接口：

                   一个类可以实现一个或多个接口，实现接口使用implements关键字。java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。

                  继承父类实现接口的语法为：

                   【修饰符】 class 类名 extends 父类 implements 接口1，接口2...

                      {

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

                       }

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

             使用接口：

                    接口在使用过程当中，还经常与匿名内部类配合使用

                     匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称

              语法格式：

                   Interface i=new Interface(){

                              public void method(){

                                     System.out.println("匿名内部类实现接口的方式");

}

}；

       抽象类

      1.语法定义;

           抽象类前使用abstract关键字修饰，则该类为抽象类。

       2.应用场景：

            a.在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。

            b.从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类模板，从而避免了子类设计的随意性。

        3.作用：

            限制规定子类必须实现某些方法，但不关注实现细节

         4.使用规则：

              a. abstract定义抽象类

              b. abstract定义抽象方法，只有声明，不需要实现

              c.包含抽象方法的类是抽象类

              d.抽象类中可以包含普通的方法，也可以没有抽象方法

              e.抽象类不能直接创建，可以定义引用变量

                     引用类型转换

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

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

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

java包名命名：java.(功能).(类)

包的使用：通过import关键字，在某个文件使用其它文件中的类

将某个包下所有文件加载：eg：com.imooc.*

定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，

即：内部类 对象名 = 外部类对象.new 内部类( );

//创建外部类对象
HelloWorld o = new HelloWorld();
//创建内部类对象
Inner i = o.new I();
//调用内部类对象的show方法
i.show();

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

运行结果：

面向对象三大特性：封装，继承，多态

封装：将类的某些信息隐藏在类的内部，只允许外部程序通过方法来操作和访问  

封装步骤：

1. 修改属性的可见性：private

2. 创建getter/setter方法（用户属性的读写）

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

内部类的主要作用：

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

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

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

JAVA中的this关键字

1. this关键字代表当前对象
   

   this.属性 操作当前对象的属性

   this.方法 调用当前对象的方法

2. 封装对象的属性的时候，经常会使用this关键字

private 私有的

protected 受保护的

public 公共的

1.概念：

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

2.好处：

   a.只能通过规定的方法访问数据

   b.隐藏类的实例细节，方便修改和实现

3.封装的实现步骤

修改属性的可见性 （设为private）

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

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

变量赋值方法：

1. 构造方法为变量进行赋值

2. 通过初始化块为变量进行赋值

3. 通过静态初始化块为变量进行赋值（只在类加载时执行一次，而且只能为静态变量进行赋值）