回顾:
1.内存管理:JVM
1)堆:new出来的对象以及成员变量
成员变量生命周期:
创建对象时存在，对象被回收时消失
垃圾回收器(GC)不定期回收没有任何引用指向的对象
回收过程是透明的，快一些System.gc()
内存泄露: 不再使用的对象没有被及时的回收
及时将不再使用的对象引用设置为null
2)栈:用到的方法中的所有局部变量
调用方法时在栈中分配该方法对应的栈桢，
栈帧中包含该方法中参数以及方法中的局部变量，
方法调用结束时，栈帧消失，局部变量一并消失
局部变量生命周期:
方法被调用时存在，方法调用结束时消失
3)方法区:字节码文件以及方法
方法只有一份，通过this来区分到底哪个对象访问的
2.引用类型数组:
Cell[] cells = new Cell[4];
cells[0] = new Cell(1,2);
cells[1] = new Cell(2,3);
cells[2] = new Cell(3,4);
cells[3] = new Cell(4,5);
Cell[] cells = new Cell[]{
new Cell(1,2),
new Cell(2,3),
new Cell(3,4),
new Cell(4,5)
};
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[2];
arr[2][1] = 100; //arr中第3个元素中的第2个元素赋值100
int[][] arr = new int[3][4];
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
arr[i][j] = 100;
}
}
class O{
Cell[] cells;
O(){
this(0,0);
}
O(int row,int col){
cells = new Cell[4];
cells[0] = new Cell(row,col);
cells[1] = new Cell(row,col+1);
cells[2] = new Cell(row+1,col);
cells[3] = new Cell(row+1,col+1);
}
void drop(){
for(int i=0;i<cells.length;i++){
cells[i].row++;
}
}
void moveLeft(){
}
void moveRight(){
}
void print(){
}
}
笔记:
1.继承:
1)作用: 代码的重用
2)通过extends实现继承
3)父类/基类:所有子类所共有的变量和方法
子类/派生类:子类所特有的变量的方法
4)当子类继承父类后，子类具有:
------子类所特有的+父类所共有的
5)一个类只能继承一个父类----单一继承
一个父类可以有多个子类
6)继承具有传递性
7)java规定: 构造子类之前必须先构造父类
子类构造方法的第一句默认有个super()调父类的无参构造
若自己通过super调用父类构造的话，则不再默认提供
super调用父类构造，必须位于子类构造的第1句
2.super:指代当前对象的父类对象
用法:
1)super.成员变量名------访问父类的成员变量
2)super.方法名()-----------调用父类的方法
3)super()---------------------调用父类的构造方法
3.向上造型:
1)父类型的引用指向子类的对象
2)能点出来什么，看引用的类型
4.方法的重写(override):
1)发生在父子类中，方法名相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
任务:
1.print()方法的重写
2.看代码中的三个Demo的文件
(重写，向上造型，super的)
3.Cell类，T类，J类，Tetromino类，TJTest类
--------------重写一次
4.课后作业: 第3天的作业做4和5
第4天的作业做1和2
5.每日一练
能点出来什么，看引用的类型
main(){
Aoo o = new Boo(); //向上造型
System.out.println(o.a); //8
System.out.println(o.b); //编译错误，
}
class Aoo{
int a=0;
}
class Boo extends Aoo{
int b;
Boo(){
a = 8;
}
}
Student zs = new Student("zhangsan",25,"廊坊","JSD1507");
zs.sayHi(); //zhangsan,25,廊坊,JSD1507
Teacher wkj = new Student("wangkj",37,"佳木斯",5000);
wkj.sayHi(); //wangkj,37,佳木斯,5000
class Person{
String name;
int age;
String address;
void sayHi(){
System.out.println(name+","+age+","+address);
}
}
class Doctor extends Person{
String level;
}
class Student extends Person{
String className;
void sayHi(){ //方法的重写(重新写，覆盖)
System.out.println(name+","+age+","+address+","+className);
}
}
class Teacher extends Person{
double salary;
void sayHi(){
System.out.println(name+","+age+","+address+","+salary);
}
}
Person p1 = new Student();
Person p2 = new Teacher();
Person p3 = new Doctor();
Student p4 = new Person(); //编译错误
Tetromino o1 = new T(); //向上造型
Tetromino o2 = new J();
Tetromino o3 = new O();
Tetromino o4 = new L();
Tetromino o5 = new I();
Tetromino o4 = new S();
Tetromino o5 = new Z();
Tetromino类型的引用，既可以接收T型对象，
也可以接收J型对象，
也可以接收O型对象，
......
class Tetromino{ //父类
}
class T extends Tetromino{ //子类
}
class J extends Tetromino{
}
class O extends Tetromino{
}
class Animal{ //动物类
}
class Tiger extends Animal{ //老虎类
}
//动物是动物
Animal o1 = new Animal();
//老虎是老虎
Tiger o2 = new Tiger();
//老虎是动物
Animal o3 = new Tiger();
父类型引用指向子类型对象
//动物是老虎--------语义不通
Tiger o4 = new Animal(); //语法也是不允许的
T型参数只能接收T型对象
J型参数只能接收J型对象
O型参数只能接收O型对象
-------------想打印7种图形，则必须做7个方法的重载
假设:
有一种类型，既能接收T型对象，
也能接收J型对象，
也能接收O型对象，
也能接收L型对象，
......
父类型
只要行列配上了，就打*
当4个*都没配上时，才打-
并非一次判断就得到最终结果------开关
假设i=2,j=6
25
26
27
36
大if------优点:效率高
缺点:扩展性不好
开关-----缺点:效率低
优点:扩展性好
还有一种方式------效率高，扩展性好
if(tt.cells[0].row==i && tt.cells[0].col==j
||
tt.cells[1].row==i && tt.cells[01].col==j )
Aoo o1 = new Aoo();
o1.a/say();
Boo o2 = new Boo();
o2.b/show();
o2.a/say();
Coo o3 = new Coo();
o3.c/sayHi(); //本类
o3.b/show(); //直接父类
o3.a/say(); //间接父类
class Aoo{
int a;
void say(){}
}
class Boo extends Aoo{
int b;
void show(){}
}
class Coo extends Boo{
int c;
void sayHi(){}
}
Student zs = new Student();
zs.className/study();
zs.name/age/address/eat()/sleep();
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(){}
}
class T{
}
class J{
}
class O{
}
class L{
}
Tetromino
生活中的继承:
1.继承财产:
钱不需要自己挣，自己也能花
2.继承皇位:
江山不需要自己打，自己也能坐
3.继承工作:
工作不需要自己找，自己也能干