1；什么叫面向对象：1；面向对象和面向过程是一种思想

2；面向过程：强调的是功能行为

3；面向对象：将功能进行封装，强调具备了功能的对象

2；面向对象的特征：1；封装         2；继承         3；多态

3；面向对象的特点：可以将复杂的事情简单化

将程序员从执行者变为指挥者

4；类：生活中一般描述事物的行为和属性

JAVA中用类来描述事物：

1；属性：对应类中的成员变量

2；行为：对应类中的方法

类是对生活的一种描述

对象是对生活中事物的描述，实实在在的个体

在JAVA中通过new操作符来完成

例如：Car  car=new Car();

//其实就是在堆内存产生的实体

//Car就是一个类类型变量，类类型变量指向对象

Car.run();

Car car2=new Car();

5；信息隐藏：private----私有:可用与修饰成员变量和成员方法，只能在本类中有效

6；封装：1；通过数据封装，声明为私有

2；提供一个或多个公开的（public）的方法

7；封装的好处：1；隐藏了一个类的实现细节

2；方便控制：限制对属性的不合理操作

3；便于修改：增加代码的可维护性

8；实例变量和局部变量

实例变量==成员变量

1；1，成员变量定义在类中

2，局部变量定义在方法中，参数上，语句中

2；成员变量在类中有效

局部变量只在所属的大括号内生效，出了则无效

3；成员变量存在工作中，随着对象的消失而消失

局部变量存在于栈中，随着所属区别的运行而存在，结束而释放

9；构造函数：

1；构造函数没有返回值

2；构造函数的函数名和类名相同

3；给对象初始化数据

注意：一个类在定义时，如果定义构造函数时，已有，则就没有默认的构造函数

10；构造函数和一般函数的区别

1；格式不同（函数名，返回类型，返回值）

2；构造函数在对象创建时，就被调用，只调用一次；

一般函数在对象创建后，才被调用，可被调用多次

注意：创建一个对象在内存中做了什么事情：

1；先将Person.class文件加载到内存中

2；执行main（）方法，在栈中开辟空间，然后main方法的栈区分配一个变量Person

3；在堆中开辟一个实体空间，分配了内存地址（new）

4；在该实体空间中进行属性空间分配，并进行默认初始化

5；调用该实体的构造函数，进行构造函数初始化

6；将内存中的地址调用在方法的参数，进行传值

11；This   关键字

1；this：代表对象，就是所在函数所属对象的引用

2；什么时候同this？

答：在定义功能时，如果该功能内部使用到了调用该功能的对象，这时就用this来表示对象

3；调用格式：this，this对象后面跟.调用的是成员属性和方法

this对象后面跟（）调用的是本类中的构造方法

注意：this调用函数，必须定义在构造函数的第一行

因为构造函数是用于初始化，所以初始化动作一定会执行，否则编译错误

static  关键字：是一个修饰符，用于修饰成员（成员变量和成员方法）

特点：

1；想要实现对象的中共性数据的对象共享，可以将这个数据进行静态修饰

2；被修饰的成员，可以被类名所调用.类名.静态成员

3；静态随着类的加载而加载，而且优先于对象的存在

弊端：

1；有些数据对象是特有的数据，是不可以被静态修饰，如果修饰这样的数据，那这个数据会变成共享数据，对事物描述就出了问题

2；静态的方法，只有访问静态成员，不能访问非静态的成员

3；静态的方法中，不能使用this和super关键字

12；静态变量和成员变量的区别

1；静态变量所属于类，也称为类变量

2；成员变量所属于对象，也称为实例变量

静态变量存在于方法区

成员变量存在于堆中

静态变量随着类的加载而存在，随着类的消失而消失

成员变量随着对象的创建而存在，随着对象回收而消失

静态变量可以被对象和类名调用

结论：成员变量可以称为对象的特有数据

静态变量可以称为对象的共享数据

静态代码块：

static{

System.out.print();

}

toString(){

return "student[id="+id+",name="+name+"]"

}

作用：1；可以完成类的初始化，静态代码块随着类的加载而执行，而且只执行一次（new 多个对象，只执行一次）

2；如果和主函数在同一个类中，优先主函数执行

13；设计模式：1；创建型模式

2；结构型模式

3；行为型模式

单例模式：保证一个类在内存中的对象唯一性

如何保证对象的唯一性？

1；不让其他程序创建该类对象

2；本类中创建一个本类对象

3；对外提供方法，让其他程序获得这个对象

步骤：

1；因为创建对象都需要构造函数初始化，只有将本类中的构造函数私有化，其他程序就无法创建该类对象

2；在本类创建一个对象

1；private   Single(){

}

private static Single s=new Single();

public static Single GetInstance(){

}

2；private     Single(){

}

public static Single2 s=null;

private static Single2 GetInstance(){

if(s==null){

s=new Single2();

}

return s;

}

14；继承：-----Animal  extends  Object

继承的好处：提高代码的复用性

父类由来：其实由多个类不断向上提取的共性内容而来

实现继承的类为子类，被继承的是父类（基类）

语法格式：修饰符   class  子类名   extends   父类名

extends 是继承的关键字，是扩展的意思

方法重写：三同一小一大

三同：方法名，形参列表相同，返回值相同

一小：子类方法声明抛出的异常类应该比父类方法的声明抛出的异常类更小或相同

一大：子类方法的访问权限应该比父类方法的权限更大或相同

15；super关键字：子类出现后，类中的成员有了哪些特点？

1；成员变量：当子类出现一样属性的时候，子类类型的对象调用该属性，值是子类的属性值

System.out.println(this.birName+"只在地上跑");

System.out.println(super.birName+"只在地上跑");

this：代表本类类型的对象引用

super：代表子类所属父类中的内存空间引用

如果想要调用父类的属性，需要super这个关键字

2；构造函数：发现子类的构造函数运行时，先运行了父类的构造函数

子类的所有构造函数中的第一行，其实都有一条隐身的语句super（）；

3；成员函数：当子类父类出现了一样的方法时，子类对象会运行子类的方法，父类的方法会被覆盖（重写）
          如果需要调用父类的方法，需要super.bird()；

JAVA中类只允许单一继承

多重继承：A继承B,B继承C，C继承D

16；方法重载：1；什么叫做重载：用于定义一组方法，这些方法具有相同的名称，执行类式的操作，但是却使用不同的方法、

2；重载的三大原则：方法名相同

参数不同：数量不同，类型不同，顺序不同

同一作用域

提示：方法重载与返回值类型没有任何关系

1；成员方法重载

2；构造函数重载

17；final  关键字

final 修饰成员属性，这个属性就变为常量，不可变，必须赋初始值

final 修饰方法，这个方法不能重写

final 修饰类，这个类不能被继承，该类中的所有方法和属性都是final

18；类之间的关系：依赖（use-a）   继承（is-a）   聚合（has-a）

19；抽象类：抽象类不能被实例化

抽象方法：只需声明，不需实现

抽象关键字：abstract

如果这个方法是一个抽象方法，那么这个类一定是抽象类

抽象类可以包含普通成员（变量和方法）

子类必须重写父类的抽象方法，如果不重写那么这个类也是抽象类

抽象类有构造函数，用与初始化

抽象类abstract关键字与哪些不能共享：private  final  static

抽象类中不一定包含抽象方法

20；abstract   特点：

1；抽象方法只能定义在抽象类，抽象类和抽象方法必须由abstract关键字修饰（方法，类，不能修饰变量）

2；抽象方法只定义方法声明，并不定义方法实践（只有方法名，没有方法体）

3；抽象类不能被实例（不能创建对象）

4；子类继承抽象类，必须重写父类的抽象方法，如果没有重写，那也是一个抽象类，如果不是抽象类，那么编译不通过

5；abstract关键字不能和final,private,static

附件：ctrl+shift+r-----查找文件

ctrl+t-----查看类结构

ctrl+单击------找到文件

ctrl+c-----复制

接口：是抽象方法和常量值的定义的集合

interface  关键字

DAO------数据访问对象的第一个接口

接口里面只能包含静态常量，不能包含普通的变量

修饰符必须是public

接口里面的方法都是抽象方法（只有方法名，没有方法体，而且abstract关键字可以省略），不能包含普通方法

实现类必须重写接口的抽象方法

继承------extends     实现------implements

一个类实现多个接口，一个接口可以继承多个接口

一个类在继承另一个类的同时，还可以实现多个接口

接口用于设计上，特点：

1；接口是对外提供的规则

2；接口是功能的扩展

3；接口的出现降低了耦合性

21；多态：同一函数，多种形态

<对象   instanceof   类型>

什么叫做多态：同一函数，多种形态

函数本身就是具备多态性，某一中事情有不同的具体的体现

多态的前提：1；必须要有关系（继承和实现）

2；会有方法覆盖（重写）

体现：父类引用或者接口的引用，指向自己的子类对象

好处：提高程序的扩展性

弊端：当父类引用指向子类对象时，但是只能访问父类的方法，不能访问子类中特有的方法

22；异常：程序中出现的错误

1；编译时异常

2；运行时异常

运行时异常包括：运行错误，逻辑错误

try{-----------}  监视可以发生异常的代码部分

catch（异常类型  e）｛-----------｝

1；Exception：异常层次结构的根类

2；ArithmeticException：算术异常

3；ArrayIndexOutofBoundException：数组下标越界

4；NullPointerException：访问空引用

5；NumberFormatException：字符串转换数字失败

6；IOException：IO异常的根类

finally   不论是否发生异常，都会执行

不论有多少个catch，都会执行一个

throw  new   Exception("------------");

e.getMessage();

运行时异常，不需要强制     try{-----}catch(异常类型 e){------}