韩顺平java笔记--初级

杂项

基本数据类型：int char bool
引用数据类型：数组、对象

韩老师总爱画的图中，栈存放函数调用、基本数据类型；堆存放引用数据类型

数组

1. 数组赋值，赋值的是地址（值传递vs引用传递）
   在java中两个int转值就是简单的值传递

int a[]={1,2,3}
int b[]=a;
//改b后a也会变
1
2
3

2. 数组拷贝（内容复制）

int a[]={1,2,3}
int b[]=new int[a.length];
for (int i = 0; i < a.length; i++) {
            b[i] = a[i];
        }
1
2
3
4
5

3. 冒泡排序：内层循环每次沉一个元素下去，外层循环控制内层循环边界，因为每沉一个搜索空间变小

4. 二维数组

//动态初始化
int a[][] = new int[2][3];
//java允许每行列数不同
int b[][] = new int[3][];
for(int i=0;i<3;i++){
	b[i] = new int[i+1];
}
//静态初始化
int c[][]={{1,2},{3,4,5,6}};
1
2
3
4
5
6
7
8
9

三种声明方式

int a[][];
int[][] a;
int[] a[];
1
2
3

类与对象

对象和数组一样，是个指针（引用类型）

Cat cat = new Cat();
cat.name; //访问属性
cat.speak(); //调用方法
1
2
3

p213辨析：返回主栈就看主栈里的p引用（对象）

重载

形参列表必须不同，返回类型不同不会构成重载，会报错：方法的重复

可变参数，务必放在实参最后，一个形参只能有一个可变参数：

public int sum(int... nums){
	//然后像访问数组一样访问就行
	//实参可为[0,n]个，也可为数组
}
1
2
3
4

作用域

局部变量： 类内某个方法内的变量（无默认值），可以被本类中任何方法使用，也可以被别的类使用
全局变量： 类内变量，也就是类的属性（有默认值）

构造器/构造方法

负责初始化（赋值）一个对象，而不是创造一个对象
即，构造器被调用的时候，对象已经存在，当前只是在完成对象的属性初始化而已

一旦写了自己的构造器，默认无参构造器会消失，重新定义一份才能回来

对象创建流程：p245
（1）在方法区加载person类
（2）在堆中分配空间（地址）
（3）对象初始化：拿默认值初始化–>显式初始化–>构造器初始化
（4）把对象在堆中的地址返回主函数p

this

指向当前对象，哪个对象调用，this就代表哪个对象
实现在一个构造器中访问另一个构造器（无需写函数名称）：

this(name,age);//必须放在第一条语句
1

匿名对象：没有接着它的东西，调用一次就消失

//Test是个类
new Test.count();
1
2

IDEA

src为源码目录，存放.java文件
out内存储将.java文件编译后得到的.class文件
快捷键：
alt+insert 构造器快捷键
ctrl+h 展示类的继承关系
CTRL+ 跳转

包

包的本质，就是创建不同的文件夹/目录来保存文件

package指令用于声明当前类所在的包，写在文件最前面

访问修饰符

竖着看

封装

参数私有化，提供外界访问的函数
set / get 函数快捷键：alt+insert
将set系列函数写在构造器中，否则分离的话，构造器会绕开set系列函数，相当于set函数不起作用

继承（只有public/proteted可以被继承）

A extends B：B是父类/基类，A是子类

（1）如果父类构造器有无参构造器（没被有参的覆盖过），则子类的任一构造器都会默认先调用super()，且这句话可写可不写；
（2）如果父类的默认无参构造器被有参的覆盖了，那么调用子类构造器时，必须加上super(name,id);这种符合父类某个构造器格式的句子；
总结：super（参数或无）用于调用对应（不同）的父类构造器。super / this都必须放在构造器第一行

Java中所有类都继承object类

子类拥有父类的所有东西，如果子类没覆写的就直接把父类的copy一份用，覆写了父类的方法就调用覆写的方法

super

super（参数或无）用于调用对应（不同）的父类构造器。super / this都必须放在构造器第一行，即super/this二选一出现走构造器的第一行

重写与重载：重载是好多函数，eg：求和函数输入的不同类型/个数，输出对应不同类型结果/运算结果
重写=覆写，是子类覆盖父类的某个函数

构造器第一行，要么是super,要么是this
super用于调用父类构造器（如果调用父类无参构造器，则此句super可省略，即构造器看起来第一行既不是super也不是this）
this用于调用本类其它构造器

super与this比较

重难点–多态

分为两种：

方法的多态： 重载（多种输入相似的功能）与重写（子类覆写父类方法）

对象的多态： 向上/下转型、辅以动态绑定机制

多态的向上转型

多态：父类（爷爷类）的引用指向了子类的对象

	Animals animal = new Cat();
1

等号左侧的父类为引用，在编译阶段就确定了
等号右侧的子类为实际对象，在运行是才能确定

animal可以调用父类的所有成员，但不能调用子类的特有成员，因为animal能调用的函数在编译时就确定了，编译时cat还没出现

总结：函数有没有，由父类在编译期间确定
若有，具体执行哪个函数，取决于子类在运行期间的实际实现

多态的向下转型

如何使用？

	Animals animal = new Cat();
	Cat cat = (Cat) animal; //强转
	// 此时cat的编译类型看等号左边，为Cat
	// 此时cat的运行类型看等号右边，为Cat（强转得到）
1
2
3
4

如何理解第三句话？

因此，向下转型必须配套向上转型使用

有比较复杂的继承/多态现象时（引入属性重写与方法重写），实际访问的是哪个？
（1）访问属性，看编译类型
（2）访问方法，看运行类型

注：isinstanceof 还可以判断当前的 运行类型 是否为 某类型 / 某子类型

动态绑定机制

P314 发生向上转型

看到题先确定编译类型与运行类型

属性没有动态绑定机制，哪里声明哪里使用

多态的应用

P315/316
应用A. 多态数组：数组类型为父类，里面实际保存为指向子类的
（1）遍历数组元素，调用统一被覆写的父类方法

	Person[] persons = new Person[5];
	persons[0] = new Student("jack");//发生向下转型，编译类型为Person，运行类型为Student
	persons[1] = new Teacher("Li");
	...
1
2
3
4

（2）遍历数组元素，调用子类特有方法：借助向下转型

总结：先向上转型，父类引用指向子类对象，此时只能使用父类方法
再向下转型，此时可调用子类方法，恢复子类特有特性

应用B. 多态参数
形参为父类，实参为子类
形参接受后若想调用父类被覆写的方法，直接调用即可（向上转型）
形参接受后若想调用子类特有方法，强转为子类再调用（向下转型）

更好的理解

动态绑定&向上/下转型例题：

向上转型后（父类的引用指向子类的对象），由于编译类型的限制，只能调用父类中含有的方法(run()/eat())。但是对象调用的方法在实际运行时，会按照动态绑定规则，执行运行类型指向的实际函数。即，p.run()

多态与动态绑定总结

源码解读-object类

==与equal

== 基本数据类型比较-看值，引用数据类型比较，看地址

2判断：10==10.0 True
3判断的是运行类型

equals:
此方法为继承object类中的equals用于判断是否指向同一个空间
子类(Integer/String)往往覆写此方法，改为单纯判断值是否相等

hashCode

	object.hashCode() // 获取唯一编码
1

toString

未覆写object自带的toString方法时，返回：包名.类名@16进制的hashCode
一般都会重写toString方法，输出对象的属性

finalize 垃圾回收机制

finalize()函数，不覆写的话就是调用object类默认的
注 ：垃圾回收机制不是一个变量失效后立即被清理，这样的话垃圾回收机制需要一直监控，效率太低，自有一套方法（JVM）
若想主动触发：System.gc()，但不一定成功