java--面向对象的使用方法

堆和栈的简介：

栈： 栈的大小会随方法和函数增删局部变量而按需变化。 内存分配随后会被释放，而无需你去管理内存分配。 栈的大小有限制，根据你所使用的操作系统而定。 存储在栈中的变量一直存在，只要创建它们的函数在运行。 堆： 内存不是自动管理的，也不是由中央处理器像栈那样严格管理。当这些块不再需要时，你需要自己释放已分配内存。 堆容易出现内存泄漏，即内存被分配给未使用的对象，而对其他进程则不可用。 堆没有大小限制。 与栈相比，堆中的对象访问起来慢得多，堆内存中的写操作也比较慢。 好消息是内存分配和管理不会成为你的问题，对这些对象的访问非常快。 它的大小确实受到限制，事实上你也不能调整栈的变量的大小。 什么时候用堆？ 如果存在需要全局访问的变量，而不是仅对创建它的方法和函数可用，则使用堆来分配内存。 当你需要大量的内存，堆也是不错的，因为它对内存大小没有限制。你还可以调整堆的变量的大小。

堆和栈的区别：

（1）堆用于动态内存分配，而栈用于静态分配。 （2）在栈中分配的变量可直接从内存访问，因此这些变量可以运行得非常快。另一方面，访问堆中的对象需要更多的时间。 （3）在栈中，当程序被编译时分配内存。而在堆中，则是开始于程序运行时

方法重载：

注意： （1）同一个类中，方法名称相同，参数列表不同 （2）编译器在在编译的时候自动根据方法的签名来绑定调用不同的方法 （3）与返回值类型无关，与参数名称无关 方法签名：方法名+参数列表 补充： （1）同一个文件中可以包含多个类，但是public修饰的类只能有一个 （2）public修饰的类必须与文件名相同

构造方法：

（1）常常给成员变量赋初值 （2）与类同名，没有返回类型 （3）在创建对象时被自动调用 （4）若自己不写构造，编译器默认提供无参构造；若自己写了构造，则不再默认提供

this：

（1）定义：指代当前对象，哪个对象调指的就是哪个对象 方法中访问成员变量之前，默认都有个this。 （2）用法： this.成员变量-------------调用成员变量 this.方法名-------------调用方法 this（）--------------调用构造方法 （3）在static方法中不能使用this

内存管理：由JVM来管理

（1）堆： 1.用于存储所有new出的对象（包括成员变量） 2.成员变量的生命周期：创建对象时存在堆中，对象被回收时，一并消失 3.垃圾回收器不定时向堆中查看，看到垃圾就回收 回收过程是透明的，若想回收快一点，可调用System.gc（） 4.内存泄漏：不再使用的对象没有被及时回收 建议：当对象不再使用时，应及时将引用设置为null 5.堆是一个不连续的内存空间，分配灵活，速度慢 （2）栈： 1.用于存储正在调用中方法的所有局部变量（包括参数） 2.调用方法时在栈中为该方法分配一块对应的栈帧， 栈帧中包含所有的局部变量（包括参数） 方法调用结束时，栈帧消失，局部变量一并消失 3.局部变量的生命周期：调用方法时存在栈中， 方法调用结束时和栈帧一并消失 4.栈属于线程私有，不能实现线程间的共享 5.栈是由系统自动分配的，速度快，栈是一个连续的内存空间 （3）方法区： 1.用于存储.class字节码文件（包括方法）， 2.方法只有一份，通过this来区分具体是哪个引用 （4）注意： 成员变量： 1.类中，方法中 2.new时存在堆中，对象被回收时消失 3.有默认值

局部变量：

1.方法中 2.调方法时存在栈中，方法调用结束时和栈帧一并消失 3.没有默认

继承：

1.目的：避免代码重复，有利于代码的重用 2.通过extends关键字实现继承 3.父类：所有子类所共有的属性和行为 子类：子类所特有的属性和行为 4.子类继承父类后，子类具有： 子类+父类 5.一个父类可以有多个子类 一个子类只能有一个父类——单一继承 6.继承具有传递性 7.java规定：构造子类之前必须先构造父类 8.可以通过私有的方式（private）使父类的属性和行为私有

super：指代当前对象的父类对象

用法： 1.super.成员变量---------访问父类的成员变量 2.super.方法名（）--------调用父类的方法 3.super（）-------------------调用父类的构造

向上造型

1.父类型的引用指向子类的对象 2.能点出什么，看引用的类型

方法重写：

1.发生在父子类中，方法名、方法列表相同，方法体不同 2.重写的方法被调用时看对象的类型 原则： 1.两同： 方法名称相同 参数列表相同 2.两小： 子类的返回值类型小于或等于父类的： void和基本类型时，返回值类型必须相同 引用类型时，必须小于或等于父类的返回值类型 子类抛出的异常小于或等于父类的-----异常 3.一大： 子类方法的访问权限大于或等于父类的------访问修饰符

重写和重载的区别

1.重写：父子类中，方法名相同，参数列表相同，方法体不同 重写遵循“运行期”绑定，根据对象的类型调用对象 2.重载：一个类中，方法名相同，参数列表不同，方法体不同 重载遵循“编译期”绑定，根据引用的类型绑定方法

package：

1.作用：避免类的命名冲突 2.包名可以有层次结构 3.建议：包名所有字母都小写 4.类的完全限定名：包名.类名

import：

1.作用：声明类/引用类 2.同包中的类可以直接访问 3.不同包中的类想访问： （1）先import，声明类，再引用类 （2）类的全称-------太繁琐（不建议）

访问控制修饰符：

1、public：公开的，任何类 2、private:私有的，本类可用 3、protected：受保护的，本类，子类，同包类 4、默认的：什么也不写，本类，同包类可用 注意：类的访问修饰：public和默认的;类成员的访问修饰：如上四种都可以

static：静态的

1.静态变量： （1）由static修饰 （2）属于类的，存在方法区中，只有一份 （3）常常通过类名.来访问 （4）何时用：所有对象的数据都一样时使用 2.静态方法： （1）由static修饰 （2）属于类的，存在方法区中，只有一份 （3）常常通过类名.来访问 （4）没有的隐式的this传递 静态方法中不能直接访问实例成员 （5）何时用：方法的操作，仅与参数相关而与对象无关时使用 3.静态块：1.由static修饰 2.属于类的，类被加载期间自动执行 类只能被执行一次，所以静态块也执行一次 3.何时用：常常用于加载静态资源（图片，音频等）

补充：

1.实例变量： （1）属于对象的，存在堆中 （2）有几个对象，就有几个实例变量 （3）必须通过对象名.来访问 2.静态变量： （1）属于类的，存在方法区中 （2）只有一份 （3）常常通过类名.来访问

final ：不能变

1.修饰变量：变量不能被改变 2.修饰方法：方法不能被重写 3.修饰类：类不能被继承

static final 常量：

1.必须声明的同时初始化 2.不能改变，通过类名点来访问 3.建议：常量名所有字母都大写 4.在编译时，会自动替换为具体的值，效率高

抽象方法：

1.由abstract修饰 2.只有方法的定义，没有方法的实现（大括号都没有）

抽象类：

1.由abstract修饰 2.包含抽象方法的类，必须是抽象类 不包含抽象方法的类也可以声明为抽象类（我乐意） 3.抽象类不能被实例化，例如：不能new 对象，但能 类名 变量 4.抽象类是需要被继承的，子类：（1）重写所有抽象方法 （2）也声明为抽象类 5.抽象类的意义： （1）包含公共的属性和行为，被子类所共享----代码重用 （2）为所有子类提供一种统一的类型---向上造型 （3）包含抽象方法，为子类提供一个统一的入口 子类有不同的实现 6. 抽象类的子类，除非也是抽象类，否则必须重写父类中的抽象方法。这样做的效果就是限定了子类必须完成某些动作，比如在父类中有eat()这个方法，那子类中必须也有eat()方法。

接口：

1.是一个标准、规范 2.由interface定义 3.只能包含常量和抽象方法 4.接口不能被实例化 5.接口也需要被实现的，实现（用implements实现）类/子类： 必须重写接口中的所有抽象方法 6.一个类可以实现多个接口，用逗号分开 若又继承又实现时，应先继承后实现，应先继承extends，后实现implements 7.接口可以继承接口

注意：

```java 类与类----------------继承 类与接口--------------实现 接口与接口------------继承 接口不能有构造方法 抽象类可以包含构造方法

多态：

1.意义：①同一类型的引用指向不同的对象时，有不同的实现-------行为的多态 ②同一对象被造型为不同的类型时，有不同的功能-------对象的多态 2. 向上造型： 3. 父类型的引用指向子类的对象 4. 能造型成的类型有：父类、实现的接口 5. 能点出什么看引用的类型 6. 强制类型转换，成功的条件: 引用所指向的对象，就是该类型 ; 引用所指向的对象，实现了该接口 ; 通过instanceof来判断引用是否是某种类型，强转成功的条件就是它为true

内部类：内部类有独立的.class

成员内部类：不太常用 类中套类，外部的的叫外部类，里面的叫内部类 内部类通常只服务于外部类，对外不具备可见性 内部类对象通常是在外部类中创建的 内部类中可以直接访问外部类的成员（包括私有的） 内部类中有个隐式的引用指向创建它的外部类对象

匿名内部类：比较常用

(1) 如果想创建一个类的对象，并且对象只被创建一次 此时该类不必命名，称为匿名内部类 (2) 匿名内部类中访问外部的数据，该数据必须是final的

面向对象三大特征：

封装：

类：封装的是对象的属性和行为 方法：封装的是具体的逻辑功能实现 访问控制修饰符：封装的是访问的权限

继承：

作用：避免代码重复，有利于代码的复用 父类：所有的子类所共有的属性和行为 子类：子类所特有的属性和行为 子继承父后，子具有：父+子 具有传递性，单一继承、多接口实现

多态：

意义：行为的多态，对象的多态 向上造型、强制类型转换、instanceof配合多态实现 多态的表现形式：重写+重载

注意：

1.当一个类实现多个接口时，并且发生向上造型时，对象能调用什么方法，要看引用类型 2.当一个类继承另一个类时，并且发生方法重写时，对象能调用什么，要看new出来的对象