OOP.Unit03

达内

知识体系

对象内存管理

对象内存管理

• 编译好的Java程序需要运行在JVM中
• 无论代码还是数据都要存储在内存中，JVM为Java程序提供并管理所需要的内存空间
• JVM内存分为“栈”，“堆”，“方法区”

堆内存

• 对象存储在“堆”中
• 访问对象需要依靠引用，所有成员变量的生命周期是：从对象在堆中创建，到对象从堆中回收结束
• GC是JVM自带的一个线程（其实是守护线程，自动运行着的程序），用于回收没有任何引用指向的对象
• 所有在确定一个对象不再使用的时，应该及时将其设为null
• System.gc() 建议JVM马上调用GC线程回收资源

栈内存

• 栈存放方法中的局部变量
• 局部变量的生命周期：Java程序在开始到结束会有多次方法的调用。JVM会为每一个方法的调用在栈中分配一个对应的空间，这个空间叫做方法的栈帧
• 一个栈帧对应一个正在调用的方法，栈帧中存储了该方法的参数，局部变量等数据，当某一个方法调用完成后，其对应的栈帧会被清除，局部变量失效
• 成员变量和局部变量比较：定义在那个位置，是否有默认值，生命周期和存放位置不一样

方法区

• 方法区用于存放类的信息，Java运行时，会通过classLoader载入类文件的字节码信息，经过解析后将其装入方法区。类的各种信息包括方法都在方法区中存储
• 类中的方法定义会加载到方法区，类实例化对象时，多个对象会有各自在堆中的空间，但所有实例对象是共用在方法区中的一个方法

继承

extends关键字

• 多个子类通过泛化的过程到抽出一个父类，用于继承
• extends关键字实现类的继承
• Sub class 可以继承Super Class的成员变量和成员方法，也可以有定义自己的成员变量和成员方法
• 一个子类只能继承一个父类，但一个父类可以有多个子类

继承中的构造方法

• 子类的构造方法中必须通过super关键字来调用父类的构造方法，这样可以妥善的初始化继承自父类的成员变量
• 如果子类未通过super关键字调用父类的构造方法，编译器会默认的加入父类无参构造（如果父类没有无参构造，会有编译错误）
• 一个子类的对象可以向上造型为父类的对象，即父类型的引用可以指向子类的对象，注意的是父类只能访问父类中的成员，不能访问子类扩展的部分

方法的重写

• 子类可以重写继承自父类的方法，就是方法名和参数列表与父类相同，但方法的实现不同。
• 当子类的重写方法被调用时，无论是父类还是子类引用，都是运行的子类重写后的版本
• 如果子类不加super关键字来调用父类的版本，就会舍弃父类里面的写的代码

class foo{
    public void f(){
        sysout("haha");
    }
}
class hoo extends foo{
    public void f(){
        sysout("hehe");
    }
}
//输出结果是hehe
class foo{
    public void f(){
        sysout("haha");
    }
}
class hoo extends foo{
    public void f(){
        super.f();
        sysout("hehe");
    }
}
//输出结果是haha  hehe

• 重写和重载的区别：两种完全不同的语法现象，编译期或者运行期绑定

经典案例

构建Tetromino类，重构T类和J类并测试

package day02;
public class Tetromino {
    Cell[] cells;
    public Tetromino(){
        cells = new Cell[4];
    }
    //打印格子中四个格子所在的坐标
    public void printTetromino(){
        String str = "";
        for(int i=0; i<cells.length-1; i++){
            str += "(" + cells[i].getCellInfo() + "),";
        }
        str +="(" +cells[cells.length-1].getCellInfo() + ")";
        System.out.println(str);
    }
    //方块的下落一个格子
    public void drop(){
        for(int i=0; i<cells.length;i++){
            cells[i].row++;
        }
    }
    //方块左移一个格子
    public void moveLeft(){
        for(int i=0; i<cells.length;i++){
            cells[i].col--;
        }
    }
    //方块右移一个格子
    public void moveRight(){
        for(int i=0; i<cells.length;i++){
            cells[i].col++;
        }
    }
}
---
package day02;
public class TetrominoJ extends Tetromino{
    public TetrominoJ(int row, int col){
        super();
        cells[0] = new Cell(row, col);
        cells[1] = new Cell(row, col+1);
        cells[2] = new Cell(row, col+2);
        cells[3] = new Cell(row+1, col+2);
    }
}
---
package day02;
public class TestTetrominoJ {
    public static void main(String[] args) {
        Tetromino j = new TetrominoJ(1, 2);
        System.out.println("-------打印J坐标 -----");
        j.printTetromino();
    }
}

重写T类的print方法并测试

//重写Tetromino的print方法并测试
    public void print(){
        System.out.println("I am a J");
        super.print();
    }
//测试结果是：I am a J   +   print出来的坐标

课后作业

• JVM在检查到对象在没有引用指向时候，清理对象，可以通过System.gc()来通知GC来快些清理，在平时对象不用时候，应该将对象设置为null
• Java会出现内存泄漏
• JVM管理内存，分为三个部分， Foo foo = new Foo(); foo.f();这两行代码是怎样内存实现的
• 只有单继承
• 下面代码很重要

class Base{
    double size;
    String name;
    public Base(double size, String name){
        this.size = size;
        this.name = name;
    }
}
public class Sub extends Base{
    String color;
    public Sub(double size, String name, String color){
        super(size,name);
        this.color = color;
    }
    public static void main(String[] args){
        Sub s = new Sub(5.6, "测试对象","红色");
        System.out.println(s.size + "--" + s.name + "--" + s.color + "--");
    }
}
结果是：5.6--测试对象--红色--