JAVA总结

JAVA总结

（一）JAVA概述

一、JAVA语言简介：

Java分为三个体系：
（1）JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
（2）JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
（3）JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

二、JAVA特点：

1、Java语言是简单的                2、Java语言是面向对象的
3、Java语言是分布式的             4、Java语言是健壮的
5、Java语言是安全的                6、Java语言是**体系结构中立**的
7、Java语言是**可移植**的             8、Java语言是解释型的
9、Java是高性能的                    10、Java语言是多线程的
11、Java语言是动态的

三、 JAVA工作原理

一、工作原理

二、java垃圾回收机制
当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用。

（二）搭建java程序开发环境

一、下载JDK

二、在"系统变量"中设置3项属性

JAVA_HOME,PATH,CLASSPATH(大小写无所谓),若已存在则点击"编辑"，不存在则点击"新建"。
变量设置参数如下：
变量名：JAVA_HOME
变量值：C:\Program Files (x86)\Java\jdk1.8.0_91 // 要根据自己的实际路径配置
变量名：CLASSPATH
变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar; //记得前面有个"."
变量名：Path
变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

三、JDK目录介绍

（1）bin:jdk/bin目录下基本都是.exe结尾的可执行文件
（2）lib:jdk/lib目录存放的都是Java开发工具要用的一些库文件
（3）jdk/jre目录提供java程序运行的全部环境
（4）jdk/jre/lib:该目录提供了JRE要用的代码库
（5）jdk/db目录，该目录应该是新加的，JDK6之后自带的微型数据库,这是一个纯 Java 实现、开源的数据库管理系统（DBMS）。

（三）DOS窗口

一、打开dos窗口：wind+r 在运行窗口输入cmd

二、dos命令：

转盘 盘符名： D： e：
文件夹切换： cd 文件夹名字（只能进入下一层）
查看文件夹 ： dir
返回上一级目录： cd …/
编译命令 ： javac +java源文件的名字和后缀。 会在当前位置生成对应的class文件。
执行使用： java +class文件的名字
创建文件夹：md
创建文件：echo（echo+空格+内容+>+文件名及后缀 新内容会覆盖旧内容）（echo+空格+内容+>>+文件名及后缀 在 原有内容之后添加）
查看文件内容：type 文件名称+后缀
删除文件夹：rd（必须为空）

三、退出DOS窗口：exit

（四）Scanner

要想使用Scanner 必须使用import进行导入
import java.util.Scanner;
import java.util.*;
Scanner in = new Scanner（System.in）创建打印机 此时的打印机并没有开启。
new Scanner（System.in）代表创建对象，
Scanner in 就是声明了一个叫做in的变量，变量的类型是Scanner。以后在想使用打印机的时候 in 就可以代表改该打印机。
当你在调用in这个对象的方法的时候，打印机就会被开启，如果你没有进行键盘输入，打印机就会一直在那死等你。

（五）JAVA标识符与关键字

一、 标识符的合法定义：

1：由26个英文字母大小写，数字0-9，符号：_或$组成。
2：数字不可以开头。
3：不可以使用关键字和保留字，但能包含关键字与保留字。
4：Java严格区分大小写，长度无限制。
5：标识符不包含空格。

二、标识符命名规则

包名：多单词组成时所有的字母都小写。如：xxxyyyzzz。
常量名：所有字母都大写，多单词组成时用下划线连接。XXX_YYY_ZZZ。
类名接口名：多单词组成是所有的首字母大写。驼峰写法**:XxxYyyZzz**。
变量名和函数名：多单词组成时，第一个单词首字母小写，之后的单词首字母大写。xxxYyyZzz。

三、Java关键字

关键字不能用作变量名、方法名、类名、包名和参数。
常用关键词分类如下：
1、类、方法和变量修饰符关键字
2．访问修饰符关键字
3．流程控制关键字
4．异常处理关键字
5．包控制关键字
6．数据类型关键字
7．没有使用的关键字
8．特殊类型和方法关键字

（六）常量和变量

一、常量的概念及声明

常量是代表程序运行过程中不能改变的值。
常量的语法格式如下：
final 数据类型 常量名称 = 值；
final 数据类型 常量名称1 = 值1， 常量名称2 = 值2，……常量名称n = 值n；

二、 变量的概念及声明

是计算机语言中能储存计算结果或能表示值抽象概念。变量可以通过变量名访问。在指令式语言中，变量通常是可变的；

变量的语法格式如下：
数据类型 变量名
（在同一个类中不能有相同名字的变量，使用变量+在进行数字运算的时候和数学中的+是一样的，但在string+字符串的时候叫拼接。）

（七）数据类型

一、数据类型的基本分类

byte、long、short、int类型的默认值都是零；
string类型的默认值为null；
Boolean类型的默认值为false；
float、double的默认值都为0.0；

二、引用数据类型：

对象、数组都是引用数据类型。
所有引用类型的默认值都是null。

三、基本数据类型的转换

各数据类型按容量大小（表数范围大小）由小到大排列为：
Byte, short, char ——int ——long——float——double
1.在一个双操作数以及位运算等算术运算式中，会根据操作数的类型将低级的数据类型自动转换为高级的数据类型，分为以下几种情况：
1）只要两个操作数中有一个是double类型的，另一个将会被转换成double类型，并且结果也是double类型；
2）只要两个操作数中有一个是float类型的，另一个将会被转换成float类型，并且结果也是float类型；
3）只要两个操作数中有一个是long类型的，另一个将会被转换成long类型，并且结果也是long类型；
4）两个操作数（包括byte、short、int、char）都将会被转换成int类型，并且结果也是int类型。
2. 如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，再做其它类型的自动转换。
3. 对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。
4. 不能在布尔值和任何数字类型间强制类型转换；
5. 不同级别数据类型间的强制转换，可能会导致溢出或精度的下降
6. 当字节类型变量参与运算，java作自动数据运算类型的提升，将其转换为int类型。

（八）运算符

一、算术运算符

表格中的实例假设整数变量A的值为10，变量B的值为20：

二、赋值运算符

三、关系运算符

表格中的实例整数变量A的值为10，变量B的值为20：

四、逻辑运算符

假设布尔变量A为真，变量B为假

五、三元运算符（三目）

变量=（表达式）？ value1：value2；

（九）流程控制

一、分支结构

Java有两种分支结构：

(1)if语句

a:if语句
If语句的用语法如下：
if(布尔表达式){
//如果布尔表达式为true将执行的语句}
b：if…else语句
if…else的用法如下：
if(布尔表达式){ //如果布尔表达式的值为true}
else{ //如果布尔表达式的值为false}
如果布尔表达式的值为true，则执行if语句中的代码块。否则执行If语句块后面的代码。
c：if…else if…else语句
if…else语法格式如下:
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码}
else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码}
else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码}
else {
//如果以上布尔表达式都不为true执行代码}
d:嵌套的if…else语句
嵌套的if…else语法格式如下：
if(布尔表达式 1){
////如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
////如果布尔表达式 2的值为true执行代码
}}

(2)switch语句

switch语法格式如下：
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句}
switch语句有如下规则：
(1)switch语句中的变量类型只能为byte、short、int或者char，JDK1.7版本及以上可以使用String。
(2)switch语句可以拥有多个case语句。每个case后面跟一个要比较的值和冒号。
(3)case语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
(4)当变量的值与case语句的值相等时，那么case语句之后的语句开始执行，直到break语句出现才会跳出switch语句。
(5)当遇到break语句时，switch语句终止。程序跳转到switch语句后面的语句执行。case语句不必须要包含break语句。如果没有break语句出现，程序会继续执行下一条case语句，直到出现break语句。
(6)switch语句可以包含一个default分支，该分支必须是switch语句的最后一个分支。default在没有case语句的值和变量值相等的时候执行。default分支不需要break语句。

二、循环结构

Java中有三种主要的循环结构：

(1)while循环

while 结构为：
while( 布尔表达式 ) {
Java代码}
只要布尔表达式为true，循环体会一直执行下去。

(2)do…while循环

do…while循环至少会执行一次。
结构为：
do {
//代码语句}while(布尔表达式);

(3)for循环

1、For循环的使用

语法结构：
For( 【初始变量】; 【表达式】 ; 【变量更新】){
Java代码
}
关于for循环有以下几点说明：
(1)最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
(2)然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
(3)执行一次循环后，更新循环控制变量。
(4)再次检测布尔表达式。循环执行上面的过程。
for (;? 可以没有任何参数，代表是死循环
在for语句中可以同时声明多个变量，必须是同一类型的。

2、Break continue return 关键字

a、 Break 结束当前循环
//输出1–10之间的所有数字,不输出7 之后的值
for(int i=1;i<=3;i++) {
System.out.print(i+"\t");
if(i==2) {
break;
}
System.out.print(“我是break”);
}

b、Continue 结束本次循环 进入下一次循环
//输出1–10之间的所有数字,continue
for(int i=1;i<=3;i++) {
System.out.print(i+"\t");
if(i==2) {
continue;
}
System.out.print(“我是continue”);
}

c、 Return 结束当前循环
for(int i=1;i<=3;i++) {
System.out.print(i+"\t");
if(i==2) {
return;
}
System.out.print(“我是return”);
}

3、For循环的嵌套

外层循环控制行，内层循环控制列。外层循环循环一次。内层循环循环一遍。

public static void main(String[] args) {
//外层循环 当条件满足的时候 循环一次
for(int i=0;i<2;i++) {
System.out.println(“第”+i+“次开始报数”);
//循环学生进行报数1–13 进行条件判断 1–13
for(int j=1;j<14;) {
System.out.println(“第”+j+“报数”);
if(j==10) {
// break;
// return;
continue;
}
j++;
}
//当内层循环一遍结束之 继续进行外层循环的判断

	}
}

Return 结束当前所有循环。
Break 结束当前所在循环。
Continue 结束当前循环的本次循环进行当前循环的下一次循环。
Break的加强版 定点跳出原来break只能结束当前所在循环，使用定点break，相当于给我们break添加一个跳出去的节点。
定位点必须在for循环语句的上面第一行

4、增强型for循环

增强型的for循环，主要针对于数组使用。在一个数组可以保存多个相同数据类型的值。
For（变量：数组）{
Java代码
}
循环语句中的变量类型必须与数组的类型一致
for(int a:num) {
System.out.println(a);
}

（十）数组

保存多个相同数据类型的集合（容器柜子）。

一、数组的使用规则：

1.既能存储原始数据类型，又能存储对象类型。
2.数组元素的个数称为数组的长度。长度一旦确定，就不能改变。
3.数组元素的下标是从0开始的，即第一个元素的下标是0。
4.可以创建数组的数组。
5.数组可以作为对象处理。数组对象含有成员变量length，用来表示数组的长度。
规则说明有以下几点：
1．可以只给部分元素赋初值。
2．只能给元素逐个赋值，不能给数组整体赋值。
3．如不给可初始化的数组赋初值，则全部元素均为0值。（基本数据类型）
4．如给全部元素赋值，则在数组说明中， 可以不给出数组元素的个数。

二、数组的创建：

创建的语法
数组类型 [] 数组的名字； （推荐使用）
数组类型 数组的名字[]；

三、数组的赋值方式：

在创建的时候只给定长度，不给具体的值。num=new int[5];
在创建的时候给具体的值，不明确长度。
num=new int[]{1,5,8,25}

四、数组的使用

数组中的所有的值称为数组的元素，数组的元素个数称为数组的长度。数组的长度是数组.length，数组中的每一个元素都有一个下标，下标从0开始，数组下标的最大值是数组的长度减1。

（1）查看数组的长度

num.length。数组的长度结果是int类型的。
int leng=num.length; 使用变量来接收数组的长度
System.out.println(num2.length); 直接输出长度

（2）数组的赋值

根据数组的元素下标
num1[0]=10;
num1[2]=20;

（3）查看数组的元素

根据数组的元素下标
1、一个一个查看
//查看数组的值
int temp=num1[0];
int temp1=num2[3];
System.out.println(temp);
System.out.println(temp1);
System.out.println(num1[num1.length-2]);
在去使用元素下标获取数组中的元素值的时候，可以使用数组.length进行计算。用来接收数组元素的变量的数据类型必须数组的类型一致。
2、 使用循环查看数组中的所有元素

for(int i=0;i<num2.length;i++) {
 System.out.println(num2[i]);
}

增强型的for循环的使用；
//使用for each 循环
for(int temp:num2) {
System.out.println(temp);
}
不需要自己考虑数组的长度，但是临时变量的数据类型必须与数组的类型保持一致。除非是数组的大类型。

五、多维数组

多维数组就是一维数组中的元素是数组。
public static void main(String[] args) {
//创建两个数组
int [] num1=new int[3];
int [] num2=new int[] {1,5,68,54,30,60};
//创建多维数组
int [][] num3=new int[2][];
num3[0]=num1;
num3[1]=num2;
for(int i=0;i<=num3.length-1;i++) {
for(int j=0;j<num3[i].length;j++) {
System.out.println(num3[i][j]);
}
}
System.out.println(num3[1][1]);
num3[0][0]=20;
/* num3[0][1]=30; */
num3[1][0]=30 num3[2][0]=40;
System.out.println(num3[0][1]);
System.out.println(num3.length);
//普通for循环进行打印输出

     //增强型for循环
	for(int[] temp:num3) {
	for(int temp1:temp) {
		System.out.println(temp1);				
			}
		}

六、数组的排序

（1）冒泡排序

冒泡排序（从小到大）
相邻两个数进行比较，第一波比较后，最大的数在最后。（每比较完之后，后面的数就减少一个比较 ）

（2）选择排序

选择排序（从小到大） 也称为比较排序
选择排序，让数组中的每一个数，依次与后面的数进行比较，如果前面的数大于后面的数，就进行位置的交换。换个说法，选择排序：第一个数依次与后面的数比较，第一次比较完之后最小的数在最前面 。

七、使用Arrays进行数组的操作

Arrays 工具，java已经帮我将我需要对数组进行的操作进行了打包。
可以直接使用，只要进行导包就可以.
因为Arrays中的方法都是用static修饰的，所以可以直接类名.方法名
sort：给数组排序
fill ：给所有位置都赋值
substring（4，6）截取4-6的值
copyof：复制数组，必须定义一个新的数组进行接收

八、String

==和equals的比较：==比较的是地址/equals比较的是值
isEmpty：判断字符串是否为空
replace：替换
toCharArray：将字符串转为数组
split：将一个字符串根据给定的内容分成多个字符串
indexOf：查找字符串中是否含有指定内容，如果有返回元素下标
toUpperCase：转换为大写
toLowerCase：转换为小写
valueOf:将你输入的数字转为字符串
toString：输出为字符串

（十一）OOP面向对象编程

一、类的构成和使用

类是具有相同属性和方法的多个对象的抽象。
怎么创建类？
Class 类名{ } 类名必须符合命名规则
在同一个java文件中可以创建多个不同类名的类，但是只能有一个用public修饰的。用public修饰的类名必须与java文件的名字一致。
Public 是什么？访问权限修饰符，
Public 公共的
Private 私有的
Protected 受保护的
不写默认的
类里面可以写什么？
类里面可以写java代码

（1）属性

属性 ： 用来描述对象或者类的静态部分
属性就是变量 数据类型 变量
数据类型可以是基本数据类型，也可以是引用数据类型类（类类型）
创建属性 可以赋值可以不赋值
调用对象的属性 对象名.属性名
类的引用：
一个类可以被另外一个类当做属性来引用，被引用的就是该类的属性。
引用其他类的输出：
属性分为全局属性和局部属性：
全局属性归当前类所有，他会有默认值，可以被当前所有非静态static方法调用。
局部属性归当前区域（方法）所有，局部变量在使用之前必须进行赋值，没有默认值。
当局部变量与全局变量名字相同时，采取局部优先原则。
静态属性可以被非静态方法和静态方法直接调用。非静态属性只能被非静态方法直接调用。

（2）方法

方法是在类里面写的
【访问限定符】 【修饰符】 返回值类型 方法名（【参数…】）{方法体 java代码}
访问限定符：限定方法的访问作用域 public
修饰符：static静态 final最终 abstract抽象
返回值类型： 有返回值（可以是任何类型：基本、引用），如果方法有返回值name必须使用return关键字并且返回的内容必须与返回值类型一致 无返回值void
参数：可以是任何类型 可以是多个

1、普通方法

如果方法没有使用修饰符进行定义，那么需要使用对象.方法名（【参数】）进行调用；
方法的具体分类解释：
a.没返回值没有参数
//无参数无返回值方法
public void study() {
System.out.println(“我在学习java”);
for(int i=1;i<10;i++) {
for(int j=1;j<=i;j++) {
System.out.print(i+""+j+"="+(ij)+"\t");
}
System.out.println();
}
}
在调用方法的时候，只会执行方法体中的java代码
b.没返回值有参数
//没有返回值有参数的方法
public void study(String name …) {
System.out.println(this.name+“在学习”);
}
在调用方法的时候，需要传入与形式参数类型一样的实际参数。形式参数可以有多个，如果形参是多个的话，实际参数的个数以及参数类型必须一致。
c.有返回值没参数
//有返回值类型没有参数的方法
public String study1() {
System.out.println(“我在学习linux”);
return “hello”;
}
在声明方法的时候，必须使用return关键字，并且必须放在方法体的最后一行。Return返回的内容必须与方法规定的返回值类型一致。如果没有return关键字程序就会报错。 调用方法的时候返回值可以不接收，可以直接使用输出语句输出。如果要接收返回值必须使用与返回值类型一样的变量进行接收。
d.有返回值有参数
//有参数有返回值的方法 返回值类型是对象类型 参数是对象类型的参数
public Student dedaoStu(Student stu) {
// Student stu = new Student();
System.out.println(stu.name);
return stu;
}
在调用的时候需要传入对应的参数，使用return关键字。 参数的类型可以是类类型。

2、代码块

{
代码块
}
代码块属于类所有，随着对象的创建被调用。每一次创建对象的时候都会被调用一次。

3、静态代码块

Static{
静态代码块
}
// 静态代码块
static{
System.out.println(“我是静态代码块”);
}
在程序启动类被加载到内存中的时候就会被调用，并且只调用一次。

三、构造方法

就是用来创建对象的时候用的。
语法： public 类名(【参数】){ java代码}
参数怎么写：变量 变量的类型 名字

1、有参数构造方法

是在new对象给对象赋值，给对象的属性赋值。如果类中没有属性就不能创建有参数构造方法，参数的个数可以是多个。不要超过属性的个数。 参数的名字可以与你要赋值的属性的名字一致，如果一致的话必须使用this关键字来进行参数和属性的区分。如果不用this就必须将参数的名字和属性的名不一样，但是参数的类型必须与要赋值的属性一致。
public 类名(【有参数】){ java代码}

2.无参数构造方法

创建对象的时候不赋值
public 类名(【无参数】){ java代码}
当类中没有任何构造方法的时候，会有一个默认的无参数构造方法，但是一旦类中有了有参数构造方法，就不会再有默认无参数构造方法。如果你在类中写了有参数构造方法，就一定要把无参数构造方法也显示的写出来。

3.构造方法的调用

在创建对象的时候根据有没有传参数来调用
new Person(); 根据你空号中是否传值，不传值代表调用的是无参数构造方法
如果传参数：根据参数的个数调用对应有参数构造方法，实际传的参数的类型必须与你要使用的有参数构造方法的参数类型以及类型的顺序一致

四、静态修饰符的使用

可以使用static进行属性和方法的修饰
1)Static 数据类型 属性名； 静态属性 全局属性
非静态属性只能被非静态方法直接调用，静态属性可以被静态或非静态方法直接调用。
静态属性属于类的，非静态属性属于对象的。
2)Public static 返回值类型 方法名（【参数】）{}
静态方法归类所有， 类名.方法名（【参数】）；
非静态方法归对象所有。对象名.方法名（【参数】）；
静态方法也可以被对象进行调用
package com.xingyun.static01;
public class StaticShuXingDemo {
//静态属性
static String name;
int age;
static {
// name=“张三”;
StaticShuXingDemo ssd= new StaticShuXingDemo();
ssd.age=10;
ssd.name=“李四”;
System.out.println(“静态代码块被调用”);}
//非静态方法
public void getName() {
System.out.println(name);//静态属性可以被静态和非静态方法直接调用
System.out.println(age);
}
public static int getAge() {
// System.out.println(age);//报错 静态不能调用非静态属性
System.out.println(name);
return 15;
}
public static void main(String[] args) {
//调用静态方法
// StaticShuXingDemo.getAge();
// StaticShuXingDemo.getName();
// StaticShuXingDemo ssd=new StaticShuXingDemo();
// ssd.getName();
String str=“ascfdvfbgbdf”;
String str1=new String(str);
System.out.println(str1.toUpperCase());
}

五、方法的调用

怎么调用？
如果方法是非静态的，那么需要是用new 对象
对象名.方法名（【参数】）；
如果是静态方法，直接使用类名.方法名
类名.方法名（【参数】）；
String类是一个特例：可以不用new对象就可以直接调用它自己的非静态方法。是因为它有一个叫做字符串池的空间。

六、对象的引用

一个类可以引用另外一个类。将另外一个类当做自己的属性进行引用。
A类
package com.xingyun.demo01;
public class AClass {
//A对象引用B对象 作为自己的属性
BClass bc;
public void study() {
bc=new BClass();
//调用B对象的study
bc.study();
}
}

B类
package com.xingyun.demo01;
public class BClass {
//B对象引用C对象 作为自己的属性
CClass cc;
public void study() {
cc=new CClass(“王五”);
//调用C对象的study 传入c对象的name值
cc.study(cc.name);
}
}

C类
package com.xingyun.demo01;
public class CClass {
String name;
public CClass(String name) {
this.name = name;
}
public void study(String name) {
System.out.println(name+“在学习”);
}
}
测试类
package com.xingyun.demo01;
public class Test {
public static void main(String[] args) {
//实例化对象 创建对象
AClass ac=new AClass();
ac.study();
}
}

七、面向对象四大特性

（1）抽象

（2）封装：

我自己有的属性我不想让你其他人直接那过去用。我们自己写一些方法，如果你想用我的属性，那你可以通过我自己的方法来进行使用。
获取属性
给属性赋值
a.对私有化的属性进行封装
b.封装就是使用方法来进行对属性的操作
一般封装的方法都称为get（）和set（）赋值，
每一个私有属性都对应的有一个get和一个set方法，方法的名是get或者set加上属性名字的首字母大写。 getName setName
Get 方法有返回值，且返回值的类型与属性的类型一致。
public int getAge() {
return age;
}
Set方法没有返回值 但是有参数，参数的类型必须与属性的类型一致。
public void setAge(int age ) {
this.age=age;
}

（3）继承

两个类拥有关系，使用extends关键。
Public class aa extends bb{} AA与BB是子父类关系。Aa是子类 BB是父类。
继承的特点：
①　只能是单继承 一个类中只能有一个直接父类。
②　一个类可以有多个子类。
③　子类继承了父类就拥有父类的所有属性和方法
④　子类可以有自己的独有的属性和方法。
⑤　可以在子类中写一个和父类一样的方法，方法的重写：在两个类中（子父类），方法的名字和参数以及参数的类型、顺序、个数都一样。方法的返回值也必须一致
如果A类继承了B类，B类继承了C 。那么A类也就拥有了C类的所有属性和方法。

Object 类

每一个类都继承自Object类
toString 返回对象的字符串表示形式 每一个对象在直接输出的时候默认调用object的toString。
getClass().getName() + ‘@’ + Integer.toHexString(hashCode())
可以重写toString方法，不是只把object的方法重写一遍。而是为了让我们能够更加清楚的看到我们的对象到底有什么内容。
Equals 也是Object的方法
当对象与对象进行比较的时候：使用= =比较的是对象的地址，使用equals默认比较的也是地址值，我们可以重写equals方法，然后根据自己重写equals里面的比较方式进行比较
@Override
public boolean equals(Object obj) {
//直接比较对象的name属性值是否相等
Car c= (Car)obj;//需要进行强制类型转换
if(this.name==c.name) {
System.out.println(“1111111111”);
return true;
}
return true;
}

（4）多态

同一个对象拥有多种状态：
向上转型 子类转父类 Car cx = new JiaoCar();
编译时状态： 子类=子类
运行时状态： 子类=父类 将子类独有属性和方法进行隐藏
向下转型 父类转子类 JiaoCar jc = (JiaoCar)cx;
必须是进行向上转型之后的那个父类对象，进行强制转换赋值给子类对象。
转型之后就可以调用子类独有的属性和方法。
instanceOf 判断两个是不是子父类
将向上转型时候得到的对象与父类对象进行比较，看看是否是同类型的对象。
boolean bool = cx instanceof Car;
多态的体现：重写和重载