equals（）默认是Object的方法。比较的是两个对象的内存地址，即使是两个对象的值完全是一样的，他们这是存在两个完全不同的空间，这里指的是内存空间。 如果重新equals方法的话，会显示以下的代码： public boolean equals(Object obj){ /*修饰符为公开，数据类型是判断真假值得布尔代数，方法名是equals，（Object obj）这个参值是Object类中的对象值，用来检测JAVA中对象用的*/ if(this == obj)/*判断对象是一个对象,返回值是真*/ return ture; if(obj == null)/*判断这个对象什么都没有，返回值是假*/ return false; if(getClass() != obj.getClass())/*判断对象属性和对象属性的值不符合，返回值是假*/ return false; 类A other = (类A)obj;/*上述已经足够判断参值对象基本属性是否为一个类型，这里讲参值对象执行为一个类型*/ if(变量名 != other.变量名)/*这里判断两个对象的某个变量中的值不相等，返回值是假*/ return false; …………/*继续执行对比其他变量中的变量值是否不相等*/ return true;/*返回值是真，判断两个对象为相等继而通过，否则就不相等*/

从对象的内存角度来理解. 假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,里面的变量需要占用0.5M内存. 现在通过代码来看看内存的分配情况: 2.f = new Father();//系统将分配1M内存. Son s = new Son();//系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法. 3.Son s1 = s;//s1指向那1.5M的内存. Father f1 = (Father)s;//这时f1会指向那1.5M内存中的1M内存,即是说,f1只是指向了s中实例的父类实例对象,所以f1只能调用父类的方法(存储在1M内存中),而不能调用子类的方法(存储在0.5M内存中). Son s2 = (Son)f;//这句代码运行时会报ClassCastException.因为f中只有1M内存,而子类的引用都必须要有1.5M的内存,所以无法转换. Son s3 = (Son)f1;//这句可以通过运行,这时s3指向那1.5M的内存.由于f1是由s转换过来的,所以它是有1.5M的内存的,只是它指向的只有1M内存.

问：什么是内部类呢？ 答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。 问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！ 答：内部类的主要作用如下： 1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类 2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据 3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便 问：内部类有几种呢？ 答：内部类可分为以下几种： ◦成员内部类 ◦静态内部类 ◦方法内部类 ◦匿名内部类

内部类 1.成员内部类 （1）定义成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( ); 2.静态内部类： （1）.不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问。 （2）.外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员 （3）.直接创建 内部类 对象名= new 内部类()； 3.方法内部类： （1）只在方法中可见，只能在方法中可用。 （2）不能使用访问控制符和 static 修饰符。

1.方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。 2.方法内部类使用时，在方法中创建内部类对象，用对象调用其内部类中的方法。 注：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

1、调用外部内的成员变量：外部内名.this.变量名 2、创建内部类的对象：外部内对象.new 内部类（）

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();
  }
 }
}

如果我们直接在代码中直接输出一个对象，会发现它输出的是对象在内存中的地址，我们称其为哈希码（对象地址字符串，是用来唯一区分对象的，就好比我们使用的身份证号码）。如果我们希望在输出一个对象的时候能够直接输出对象的属性值，就需要重写toString方法（只有父类是Object的类才可以重写toString方法，因为toString方法是Object类的方法）。

啪啪租车系统 代码1： http://hubojing.github.io/2017/03/18/%E8%BE%BE%E8%BE%BE%E7%A7%9F%E8%BD%A6%E7%B3%BB%E7%BB%9F%EF%BC%88Java%E5%AE%9E%E7%8E%B0%EF%BC%89/ 代码2： http://www.imooc.com/article/16922 代码3： www.imooc.com/article/16880 代码4： 参考了代码http://blog.csdn.net/Joseph_Cherry/article/details/60530978 自己的项目https://code.csdn.net/example440982/dadacar/tree/master 代码5： http://www.imooc.com/article/16652%20%20%20Java 运用接口： 1，http://www.imooc.com/article/16376 2，http://www.imooc.com/article/17018

1.语法层面上的区别 　　1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法； 　　2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的； 　　3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法； 　　4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。 2.设计层面上的区别 　　1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。 　　2）设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过ppt里面的模板，如果用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，如果它们的公共部分需要改动，则只需要改动模板A就可以了，不需要重新对ppt B和ppt C进行改动。而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。

代码1 package com.imooc; public abstract class Human { public abstract void chinese(); public abstract void americans(); } package com.imooc; public class Language extends Human { public void chinese() { // TODO Auto-generated method stub System.out.println("中国人说汉语"); } @Override public void americans() { // TODO Auto-generated method stub System.out.println("美国人说英语"); } } package com.imooc; public class Test { public static void main(String args[]){ Human obj1 = new Language(); obj1.chinese(); obj1.americans(); } }

UML： 1、概念：Unified Modeling Language(UML)统一建模语言或标准建模语言 2、三种常用的UML图： ·用例图（The Use Case Diagram）：关注功能，描述系统中出现的角色，以及它所需要的功能。 ·序列图（The Sequence Diagram）：关注顺序，描述用户和系统中对象的交互环节：步骤和顺序 ·类图（The Class Diagram）：关注关系：描述类和类之间的关系（继承等），表现类的属性和方法 3.UML建模工具：如Visio、Rational Rose、PowerDesiner

Super关键字：在对象内部使用，代表父类对象 访问父类的属性super.age 访问父类方法super.eat(); 子类构造过程中必须调用父类的构造方法：隐示super();显示调用父类构造方法，必须放在构造方法的第一行 当子类构造方法中既没有显示调用父类的构造方法，父类又没有无参的构造方法则编译出错

1-3 如何使用Java中的对象 ⑴使用对象的步骤： ①创建对象： 类名 对象名= new 类名();//对一个类实例化 Telphone phone = new Telphone(); ②使用对象： 引用对象的属性：对象名.属性 phone.screen = 5;//给screen属性赋值5 引用对象的方法：对象名.方法 phone.sendMessage();//调用sendMessage()方法 例： package com.imooc; public class InitailTelphone { public static void main(String[] args) { // TODO Auto-generated method stub Telphone phone=new Telphone(); phone.sendMessage(); //给实例变量赋值 phone.screen=5.0f; phone.cpu=1.4f; phone.mem=2.0f; //调用对象的方法 phone.sendMessage(); } }

接口 1.接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。 2.接口的概念 类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类里方法的实现细节 ，它只规定这些类里必须提供某些方法。 3.接口定义使用interface 关键字。 接口 －> 是个规范 约束类 [修饰符] interface 借口名 ［extends 父接口1，父接口2］ ｛ 零个到多个常量定义 public static final 零个到多个抽象方法定义 public abstract ｝ 接口就是用来被继承 被实现的 修饰符一般建议用public 不能使用private 和 protected 类是单继承的 接口是可以多继承的 接口的引用 指向一个实现了接口的对象 IPlayGame ip1=new SmartPhone(); IPalyGame ip2=new Psp(); ip1.playGame(); ip2.playgame(); 匿名内部类： Interface i=new Interface(){ public void method(){ System.out.println("匿名内部类实现接口的方式"); } }; ip3.playGame(); 或者： new IPlaygame(){ public void playGame(){ System.out.println("使用匿名内部类的方式实现接口2"); } }.playgame();