内存管理 继承 super

回顾:
1.方法的签名:方法名+参数列表
2.方法的重载(Overload):
  1)发生在一个类中，方法名称相同，参数列表不同
  2)编译器根据签名自动绑定调用不同的方法
3.构造方法:构造器、构建器、构造函数
  1)常常用于给成员变量赋初值
  2)与类同名，没有返回值类型
  3)创建对象时被自动调用
  4)若不写则默认一个无参的，若写了则不再默认提供
  5)可以重载
4.this:指代当前对象，哪个对象调指的就是哪个对象
       只能用在方法中，方法中访问成员变量之前默认有个this.
  this的用法:
    this.成员变量名------------访问成员变量
    this.方法名()--------------调用方法
    this()---------------------调用构造方法
5.引用类型数组
    Cell[] cells = new Cell[4]; //创建Cell数组对象
    cells[0] = new Cell(2,5); //创建Cell对象

    int[][] arr = new int[3][];
    arr[0] = new int[2];

    int[][] arr = new int[3][4];

笔记:
1.内存管理:由JVM来管理

  1)堆:
    1.1)存储所有new出来的对象(包括成员变量)
 1.2)没有任何引用指向的对象就是垃圾，
     垃圾回收器(GC)不定时到内存中清扫垃圾，
     回收过程是透明的(看不到的)，并不一定发现垃圾就马上回收，
  调用System.gc()建议虚拟机尽快调度gc来回收垃圾
                                   垃圾回收器(GC)----不定时的清扫垃圾
                                   System.gc()
 1.3)内存泄漏:不再使用的内存没有被及时的回收
              建议:对象不再使用时及时将引用设置为null
 1.4)成员变量的生命周期:
       创建对象时存在堆中，对象被垃圾回收器回收时一并消失
  2)栈:

    2.1)存储正在调用的方法中的所有局部变量(包括参数)
 2.2)调用方法时会为该方法在栈中分配一块对应的栈帧，
        栈帧中包含方法中的所有局部变量(包括参数)，
  方法调用结束时，栈帧被消除，局部变量随之消失
 2.3)局部变量的生命周期:
       调用方法时存在栈中，方法结束栈帧被清除时一并消失
 成员变量:
1)类中，方法外
2)创建对象时存在堆中，对象被回收时一并消失
3)有默认值，可以不显式初始化

局部变量:
1)方法中
2)方法被调用时存在栈中，方法结束栈帧被清除时一并消失
3)没有默认值，必须显式初始化
eg：
Aoo o = new Aoo(); //a=0;
o.show(5); //int b=5;

class Aoo{
  int a;
  void show(int b){
    int c;
 System.out.println(a); //正确
 System.out.println(b);
 System.out.println(c); //编译错误
  }
}

  3)方法区:

    3.1)存储.class字节码文件(包括方法)
    3.2)方法只有一份，通过this来区分具体的对象

每个对象有自己的row和col

Cell c = new Cell();
c.row = 2;
c.drop(); ----------c.row=3

Cell cc = new Cell();
cc.row = 4;
cc.drop(); ---------cc.row=5
结果正确，意味着在drop()正确的区分出来到底是c还是cc了
this只能用在方法中

2.继承:
/*class Person{ //父类
  String name;
  int age;
  String address;
  void eat(){}
  void sleep(){}
}

class Student extends Person{ //子类
  String className;
  void study(){}
}
class Teacher extends Person{ //子类
  double salary;
  void teach(){}
}
class Doctor extends Person{ //子类
  String level;
  void cut(){}
}*/
  1)作用:代码的复用
  2)通过extends来实现继承
  3)父类/基类:所有子类所共有的属性和行为
    子类/派生类:子类所特有的属性的行为
  4)子类继承父类后，子类具有: 子类的+父类的
  5)一个父类可以有多个子类，
    一个子类只能继承一个父类-----单一继承
  6)继承具有传递性
  7)java规定:构造子类之前必须先构造父类
    子类构造方法中若没有调用父类的构造方法，
 则默认super()调父类的无参构造，
 若子类构造方法中调用了父类的构造方法，则不再默认提供
    super()调父类构造必须位于子类构造方法的第一句

3.super:指代当前对象的父类对象
  super的用法:
   1)super.成员变量名----------访问父类的成员变量
   2)super.方法名()------------调用父类的方法
   3)super()-------------------调用父类的构造方法

//super的演示
public class SuperDemo {
	public static void main(String[] args) {
		Boo o = new Boo();
	}
}

class Coo{
	Coo(int n){
		
	}
}
class Doo extends Coo{
	Doo(){
		super(2);
	}
}








class Aoo{
	Aoo(){
		System.out.println("父类构造方法");
	}
}
class Boo extends Aoo{
	Boo(){
		super(); //默认---调父类无参构造
		System.out.println("子类构造方法");
	}
}

4.向上造型:有两种，自己造型或者是系统帮助造型
  1)父类型的引用指向子类的对象
  2)能点出来什么，看引用的类型

package oo.day03;
//向上造型
public class UpDemo {
	public static void main(String[] args) {
		Eoo o1 = new Eoo();
		o1.e = 1;
		o1.show();
		//o1.f = 2; //编译错误，父不能访问子的
		
		Foo o2 = new Foo();
		o2.f = 1;
		o2.test();
		o2.e = 2; //正确，子可以访问父的
		o2.show();
		
		//能点出来什么，看引用的类型
		Eoo o3 = new Foo(); //向上造型
		o3.e = 1;
		o3.show();
		//o3.f = 2; //编译错误，Eoo型的引用不能访问Foo的成员	
	}
}

class Eoo{
	int e;
	void show(){}
}
class Foo extends Eoo{
	int f;
	void test(){}
}

1)继承要符合is a的关系
2)问:子类可以继承父类的构造方法吗?
  答:不能，因为父类的构造方法是被子类调用的