1、面向对象内存分析
栈的特点
（1）JVM为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量等）
（2）栈属于线程私有，不能实现线程间的共享！
（3）栈的存储特性是：先进后出，后进先出。由系统自动分配，速度快！是一个连续的内存空间。
（4）栈描述的是方法执行的内存模型，每个方法被调用会创建一个栈帧（存储局部变量、操作数、方法出口等），方法结束，栈帧消失。
堆的特点：
（1）JVM只有一个堆，被所有的线程共享。
（2）堆是一个不连续的内存空间，分配灵活，速度慢！
（3）堆用于存储好的对象和数组（数组也是对象）
方法区（又叫静态区）：它在堆里。
（1）JVM只有一个方法区，被所有的线程共享.
（2）用于存放程序里唯一的内容（类对象，静态变量、字符串常量等）
举例
（1）代码
public class SxtStu {
//属性fields
int id;
String sname;
int age;
Computer comp; //引用数据类型
//方法
void study(){
System.out.println("电脑名称是："+comp.brand);
}
void play(){
System.out.println("我在玩游戏！哈哈哈");
}
//构造方法。用于创建这个类的对象。无参的构造方法可以由系统自动创建。
SxtStu(){
System.out.println("调用了无参的构造方法！");
}
//程序执行的入口，必须要有
//javac Sxtstu.java , java Sxtstu
public static void main(String[] args) {
SxtStu stu = new SxtStu(); //创建一个对象
stu.id=1001;
stu.sname= "小明";
stu.age = 18;
Computer c1 = new Computer();
c1.brand = "联想";
stu.comp = c1;
stu.play();
stu.study();
}
}
class Computer {
String brand;
}
（2）画图说明程序运行中内存变化
2、构造器-->构造方法
基本要点
（1）通过new关键字调用
（2）构造器虽然有返回值，但是不能定义返回值类型（返回值类型肯定是本类），不能在构造器里使用return关键字。
（3）如果没有定义构造器，编译器会自动定义一个无参的构造函数。
（4）构造器的方法名必须和类名一致。
代码实例
public class BallGame {
double x;
double y;
// 重载构造方法
public BallGame(double x,double y ){
this.x=x;
this.y=y;
}
public void jiaGame(){
System.out.println(x+y);
}
public static void main(String[] args) {
BallGame ballGame = new BallGame(12,30);
ballGame.jiaGame();
}
}
3、 this以及static关键字
- 创建对象分为四步：
（1）分配对象空间，并将对象成员变量初始化为0或者null
（2）执行属性值的显示初始化--->赋值
（3）执行构造方法
（4）返回对象的地址给相关的变量
- this关键字：本质是创建好的对象的地址！由于构造方法调用前，对象已经创建。因此构造方法可以用this代表当前对象。
- this常用的用法：
（1）变量产生歧义！在普通方法里，this指向调用该方法的对象。构造方法里，this指向初始化的对象。
（2）用于重载构造方法，避免相同的初始化代码。但只能在构造方法里用，并且必须位于构造方法的第一句。
（3）不能用于static修饰的方法里。
- static关键字：用static声明的成员变量为静态成员变量，也称为类变量。
（1）为类的共享变量，在类被载入时被显示初始化。
（2）一般用类名.类属性/方法 来调用。
（3）在static方法里不可直接访问非static的成员
4、垃圾回收机制
- 内存管理
（1）java的内存管理很大程度就是对象的管理，包括对象空间的分配和释放。
（2）对象空间的分配：使用new关键字创建对象即可
（3）对象空间的释放：将对象赋值null即可。垃圾回收器将负责回收所用“不可达”对象的内存空间
- 垃圾回收过程
（1）发现无用的对象---->没有变量引用该对象。
（2）回收无用对象占用的内存空间。
- 垃圾回收算法。
（1）引用计数法
（2）引用可达法
- 分代垃圾回收机制-->不同生命周期的对象可以采取不同的回收算法，提高回收效率。对象有三种状态：年轻代，年老代，持久代。
（1）年起代：新产生的对象首先放在Eden区。目标是尽可能快速的收集那些生命周期短的对象即Minor GC.每次Minor GC会清理年轻代的内存算法采用效率高的复制算法。但频繁的操作会浪费内存空间。单年轻代堆满对象后，将未失效的对象放入年老代区域。
（2）年老代：在年轻代里经历了N（默认是15次）垃圾回收后仍然存活的对象，会被放入老年代里。当年老代对象很多的时候，会启动Major GC和Full GC(全量回收)，来一次大扫除。全面清理年轻代和老年代的对象。但这样对系统内存压力大。
（3）持久代：存放静态文件。
（4）导致Full GC可能原因：
1、年老代被写满
2、持久代被写满
3、System.gc()被显示调用（程序建议GC启动，不是调用GC）
4、上一次GC之后Heap的个区域分配策略动态变化
- 容易导致内存泄漏的操作
（1）创建大量无用对象
（2）静态集合类使用--->HashMap、Vector、List使用容易出现内存泄漏，这些静态变量的生命周期和应用程序一致。所有的Object不能被释放。
（3）各种连接对象（IO流、数据库连接对象、网络连接对象）未关闭
（4）释放对象时，没有删除相应的监听器。
（5）要点：程序员无权调用垃圾回收器；可以使用System.gc().该方法只是通知JVM，并不是运行垃圾回收器。尽量少用，会启动Full GC；finalize方法是提供程序员释放对象的方法，但尽量少用。
5、package与import
- 静态初始化块
（1）如果希望加载后，对整个类进行某些初始化操作，可以使用static初始化块。类第一次载入时先执行static代码块并且只执行一次。
（2）在类初始化时执行，不是在创建对象时执行。静态初始化块里不能访问非static成员。
（3）执行顺序：先执行Object静态初始化块，再向下执行子类的静态初始化块。构造方法执行顺序也是这样。
- package
（1）作用：
为了解决类之间的重名问题。
为了便于管理类：合适的类位于合适的包！
（2）怎么用?
通常是类的第一句非注释性语句。
包名：域名倒着写即可，再加上模块名，并与内部管理类。
（3）注意事项：
写项目时都要加包，不要使用默认包。
com.gao和com.gao.car，这两个包没有包含关系，是两个完全独立的包。只是逻辑上看起来后者是前者的一部分。
（4）JDK主要包：
• java.lang：包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
• java.awt：包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
• java.net：包含执行与网络相关的操作的类。
• java.io： 包含能提供多种输入/输出功能的类。
• java.util：包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。
- import
（1）为什么需要import?
• 如果不适用import，我们如果用到其他包的类时，只能这么写：java.util.Date，代码量太大，不利于编写和维护。通过import可以导入其他包下面的类，从而可以在本类中直接通过类名来调用。
（2）import怎么使用?
• import java.util.Date;
• import java.util.*; //导入该包下所有的类。会降低编译速度，但不会降低运行速度。
（3）注意要点：
•java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
• 如果导入两个同名的类，只能用包名+类名来显示调用相关类： java.util.Date date = new java.util.Date();
（4）import static:用于导入指定类的静态属性, JDK5.0后增加！
如何使用：
• import static java.lang.Math.*;//导入Math类的所有静态属性
• import static java.lang.Math.PI;//导入Math类的PI属性
• 然后，我们可以在程序中直接使用：System.out.println(PI);
（5）final关键字的作用
• 修饰变量：一旦赋值，就不能重新赋值了。 final int A = 120;
• 修饰方法：该方法不可被子类重写，但可以被重载。final void study(){}
• 修饰类：不能被继承。final class A {}
6、参数传递机制
java里，方法里所有参数都是“值传递”，也就是传递的是值的副本。不会改变原参数。
- 基本数据类型传值：传递的是值的副本，副本改变不会影响原参数。
- 引用类型参数传值：传递的值对象的内存地址。副本和园参数指向了同一个地址。改变副本指向对象的值，原参数的值也改变。
7、面向对象三大特性
- 继承
（1）类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。提高代码的复用性！继承用extands关键字。子类是父类的扩展.不同的叫法：超类、父类、基类、子类、派生类
public class TestExtends {
public static void main(String[] args) {
Mammal m1 = new Mammal();
m1.puru();
m1.eat();
}
}
class Animal {
String eyes=" 眼睛";
String name=" 无名";
public void eat(){
System.out.println(" 动物吃东西！");
}
}
class Mammal extends Animal {
// 哺乳
public void puru(){
System.out.println(" 小动物吃奶！");
}
}
（2）子类继承父类的成员变量和成员方法，但不继承父类的构造方法.类加载时先加载父类的构造方法。
（3） java中只有单继承， java中的多继承，可以通过接口来实现。
（4） 如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。
（5）instanceof是二元运算符，左边是对象，右边是类；当对象是右边类或者子类所创建的对象时，返回true。反之返回false。
（6）在子类中可以根据需要对从基类中继承来的方法进行重写。重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。重写方法的返回值类型小于等于被重写方法。
• 父类方法的重写：
“==”：方法名、形参列表相同。
“≤≤”：返回值类型和异常类型，子类小于等于父类。
“≥”：访问权限，子类大于等于父类
• 构造方法调用顺序：
根据super的说明，构造方法第一句 总是：super(…)来调用父类对应的构造方法。
先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。
public class TestOverride {
public static void main(String[] args ) {
Animal animal = new Animal();
animal.shout();
Dog dog = new Dog();
dog.shout();
}
}
class Animal{
void shout(){
System. out.println("发出声音！");
}
}
class Dog extends Animal {
void shout(){
System. out.println("旺旺旺！");
}
}
（7）对象的比较==和equals()
• ==：
• 比较两基本类型变量的值是否相等
• 比较两个引用类型的值即内存地址是否相等，即是否指向同一对象。
• equals() ：
• 两对象的内容是否一致
• 示例
• object1.equals(object2) 如：p1.equals(p2)
• 比较所指对象的内容是否一样
• 是比较两个对象，而非两个基本数据类型的变量
• object1 == object2 如：p1==p2
• 比较p1和p2的值即内存地址是否相等，即是否是指向同一对象。
• 自定义类须重写equals()，否则其对象比较结果总是false。
（8）super是直接父类对象的引用，可以通过super来访问父类中被子类覆盖的方法或属性。
- 封装---->一般在javabeen里将属性和方法封装好。
（1）隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。我们程序设计要追求“高内聚，低耦合”。高内聚 ：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合 ：仅暴露少量的方法给外部使用。
（2）封装要点：
• 类的属性的处理:一般使用private. (除非本属性确定会让子类继承)，提供相应的get/set方法来访问相关属性. 这些方法通常是public，从而提供对属性的读取操作。（注意：boolean变量的get方法是用：is开头!）
• 一些只用于本类的辅助性方法可以用private， 希望其他类调用的方法用public
（3）访问控制符：
• 成员（成员变量或成员方法）访问权限共有四种：
• public 公共的：可以被项目中所有的类访问。(项目可见性)
• protected 受保护的：可以被这个类本身访问；同一个包中的所有其他的类访问；被它的子类（同一个包以及不同包中的子类）访问
• default／friendly 默认的/友好的（包可见性）：被这个类本身访问；被同一个包中的类访问。
• private 私有的：只能被这个类本身访问。（类可见性）
• 类的访问权限只有两种
• public 公共的：可被同一项目中所有的类访问。 (必须与文件名同名)
• default／friendly 默认的/友好的：可被同一个包中的类访问。
- 多态
（1）多态时方法的多态，不是属性的多态（多态和属性无关）
（2）多态存在有3个必要条件：继承，方法重写，父类引用指向子类对象。
（3）父类引用指向子类对象后，用该父类引用调用子类重写的方法时，就是多态了
package object;
public class TestPolym {
public static void main(String[] args) {
Animal animal = new Dog(); //向上可以自动转型
System.out.println(animal.age); //属性调用时，仍然是基类的属
性。属性没有多态！
// animal.shout();
animalCry(new Dog());
//传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
//如果没有多态，我们这里需要写很多重载的方法。如果增加一种动物，就需
要重载一种动物的喊叫方法。非常麻烦。
//有了多态，只需要增加这个类继承Animal基类就可以了。
animalCry(new Cat());
Dog dog = (Dog) animal; //编写程序时，如果想调用运行时类型的方
法，只能进行类型转换。不然通不过编译器的检查。
dog.gnawBone();
System.out.println(dog instanceof
Animal);
System.out.println(animal instanceof Cat);
System.out.println(animal instanceof Dog);
}
static void animalCry(Animal a){
a.shout();
}
}
class Animal {
int age=10;
public void shout(){
System.out.println("叫了一声！");
}
}
class Dog extends Animal {
int age=28;
public void shout() {
System.out.println("旺旺旺！");
}
public void gnawBone(){
System.out.println(“我在啃骨头");
}
}
class Cat extends Animal {
int age=18;
public void shout() {
System.out.println("喵喵喵喵！");
}
}
- 对象的转型
（1）子类转换为父类：自动转换.即父类引用指向子类对象。
• 上转型对象不能操作子类新增的成员变量和方法。
• 上转型对象可以操作子类继承或重写的成员变量和方法
• 如果子类重写了父类的某个方法，上转型对象调用该方法时，是调用的重写方法。
（2）父类转换为子类：强制转换
• （绝不是做手术，而是父类的真面目就是一个子类，否则会出现类型转换错误）
8、抽象类
（1）是一种模版模式。抽象类为所有子类提供了一个通用模版，子类可以在这个模版基础上进行扩展。通过抽象类，可以避免子类设计的随意性。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。
（2）要点：
• 抽象方法和抽象类均必须用abstract来修饰。
• 抽象方法没有方法体，只需要声明不需实现。
• 有抽象方法的类只能定义能抽象类
• 相反抽象类里面的方法不一定全是抽象方法，也可能没有抽象方法。
• 抽象类可以包含属性、方法、构造方法。
• 抽象类不能实例化，及不能用new来实例化抽象类，只能用来被子类调用。
• 抽象类只能用来继承。
• 抽象方法必须被子类实现。抽象类的子类必须覆盖所有的抽象方法才能被实例化，否则还是抽象类
（3）实例
abstract class Animal {
abstract void shout(); //抽象方法没有方法体！
}
class Dog extends Animal {
void shout() { //必须重写父类的抽象方法否则编译通不过
// TODO Auto-generated method stub
System.out.println("旺旺旺！");
}
}
9、接口
（1） 为什么需要接口?接口和抽象类的区别?
• 接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是
坏人，则必须欺负好人。
• 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
• 项目的具体需求是多变的，我们必须以不变应万变才能从容开发，此处的“不变”就是“规范”。因此，我们开发项目往往都是面向接口编程！
（2）接口相关规则
• 接口中所有方法都是抽象的。
• 即使没有显式的将接口中的成员用public标示，也是public访问类型的
• 接口中变量默认用 public static final标示，所以接口中定义的变量就是全局静态常量。
• 可以定义一个新接口，用extends去继承一个已有的接口
• 可以定义一个类，用implements去实现一个接口中所有方法。
• 可以定义一个抽象类，用implements去实现一个接口中部分方法
（3）如何实现接口
• 子类通过implements来实现接口中的规范
• 接口不能创建实例，但是可用于声明引用变量类型。
• 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。
• Java的类只支持单继承，接口支持多继承
• Java中，一个类只能继承一个类，但同时可以实现多个接口，既可以实现多重继承的效果和功能，也避免的多重继承的危险性。如：class Student extents Person implements Runner，Flyer
10、内部类
（1）定义：将一个类定义置入另一个类定义中就叫作“内部类”。
• 内部类作为外部类的成员，可以直接访问外部类的成员（包括private成员），反之则不行。
• 内部类做为外部类成员，可声明为private、默认、protected或public。
• 内部类成员只有在内部类的范围之内是有效的。
• 用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。
• 编译后生成两个类： OuterClass.class 和OuterClass$InnerClass.class
（2）内部类分类：成员内部类 ；静态内部类 ；方法内部类 ；匿名内部类
class Outer{
int outer_i = 100;
void test(){
Inner in = new Inner();
in.display();
System.out.println(in.a);
}
class Inner{
int a=5;
void display(){
System.out.println("display: outer_i = " + outer_i);
}
}
}
11、String类
- 基础：
（1）String类又称不可变序列。
（2）String位于java.lang里，java默认导入java.lang下所有类。
（3）Java字符串就是Unicode字符序列。例如字符串“Java”就是四个Unicode字符‘J’，‘a’,'v','a'组成的。
（4）每个用双引号括起来的字符串就是String类的一个实例
- 常量池
（1）全局字符串常量池：其存放的内容是在类加载完成后存到String Pool里的。每个JVM只有一份，存放的是字符串常量的引用值（在堆里生成字符串对象实例）
（2）class文件常量池：在编译的时候每个class都有的.在编译阶段，存放的是常量（文本字符串、final常量）和符号引用。
（3）运行时常量：在类加载完成后，每个class常量池里的符号引用值转存到运行时常量池。