第 8 章 面向对象编程(中级部分)
Suriski 9/8/2022 韩顺平java笔记
- 韩顺平 2021零基础学Java的笔记，可在Bilibili同步观看
- 韩顺平-视频观看地址 (opens new window)
# 8.3.4 课堂练习
# 8.3.5 IDEA 常用快捷键
第11点也可以用 alt + enter
# 8.3.6 模板/自定义模板
# 8.4 包
# 8.4.2 包的三大作用
# 8.4.3 包基本语法
# 8.4.4 包的本质分析(原理)
# 8.4.5 快速入门
# 8.4.6 包的命名
# 8.4.7 常用的包
# 8.4.8 如何引入包
package com.hspedu.pkg;
import java.util.Arrays;
public class Import01 {
public static void main(String[] args) {
int[] arr = {-1, 20, 2, 13, 3};
Arrays.sort(arr);
for (int i = 0; i < arr.length ; i++) {
System.out.print(arr[i] + "\t");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# 8.4.9 注意事项和使用细节
# 8.5 访问修饰符
# 8.5.1 基本介绍
# 8.5.2 种访问修饰符的访问范围
# 8.5.3 使用的注意事项
# 8.6 面向对象编程三大特征
# 8.6.1 基本介绍
面向对象编程有三大特征：封装、继承和多态。
# 8.6.2 封装介绍
# 8.6.3 封装的理解和好处
# 8.6.4 封装的实现步骤 (三步)
# 8.7.1 将构造器和 setXxx 结合
看一个案例
public Person(String name, int age, double salary) {
setName(name);
setAge(age);
setSalary(salary);
}
1
2
3
4
5
2
3
4
5
# 8.8 面向对象编程-继承
# 8.8.2 继承基本介绍和示意图
# 8.8.3 继承的基本语法
# 8.8.5 继承给编程带来的便利
- 代码的复用性提高了
- 代码的扩展性和维护性提高了
# 8.8.6 继承的深入讨论/细节问题
# 8.8.7 继承的本质分析(重要)
package com.hspedu.extend_;
public class ExtendsTheory {
public static void main(String[] args) {
Son son = new Son();
System.out.println(son.name);
System.out.println(son.hobby);
}
}
class GrandPa {
String name = "大头爷爷";
String hobby = "旅游";
}
class Father extends GrandPa {
String name = "大头爸爸";
private int age = 39;
public int getAge() {
return age;
}
}
class Son extends Father {
String name = "大头儿子";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
子类创建的内存布局：
如果Father里的age是private，即使GrandPa里也有age，是public，访问age的时候一样到Father就会停止，不会继续查看GrandPa里是否有age。
# 8.8.8 课堂练习
由于B()函数里调用了this函数，所以没有super函数，但B(String name)函数有super()。
# 8.9 super 关键字
# 8.9.1 基本介绍
super 代表父类的引用，用于访问父类的属性、方法、构造器。
# 8.9.2 基本语法
# 8.9.3 super 给编程带来的便利/细节
# 8.9.4 super 和 this 的比较
# 8.10 方法重写/覆盖(override)
# 8.10.1 基本介绍
# 8.10.3 注意事项和使用细节
# 8.10.4 课堂练习
# 8.11 面向对象编程-多态
# 8.11.1 先看一个问题
# 8.11.2 多[多种]态[状态]基本介绍
方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。
# 8.11.3 多态的具体体现
方法的多态
重写和重载就体现多态对象的多态 (核心，困难，重点)
package com.hspedu.poly_.objectpoly_; public class Animal { public void cry() { System.out.println("Animal cry() 动物在叫...."); } } package com.hspedu.poly_.objectpoly_; public class Cat extends Animal { public void cry() { System.out.println("Cat cry() 小猫喵喵叫..."); } } package com.hspedu.poly_.objectpoly_; public class Dog extends Animal { public void cry() { System.out.println("Dog cry() 小狗汪汪叫..."); } } package com.hspedu.poly_.objectpoly_; public class PolyObject { public static void main(String[] args) { Animal animal = new Dog(); animal.cry(); animal = new Cat(); animal.cry(); } }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 8.11.5 多态注意事项和细节讨论
package com.hspedu.poly_.detail_;
public class Animal {
String name = "动物";
int age = 10;
public void sleep(){
System.out.println("睡");
}
public void run(){
System.out.println("跑");
}
public void eat(){
System.out.println("吃");
}
public void show(){
System.out.println("hello,你好");
}
}
package com.hspedu.poly_.detail_;
public class Cat extends Animal {
public void eat(){
System.out.println("猫吃鱼");
}
public void catchMouse(){
System.out.println("猫抓老鼠");
}
}
package com.hspedu.poly_.detail_;
public class Dog extends Animal {
}
package com.hspedu.poly_.detail_;
public class PolyDetail {
public static void main(String[] args) {
Animal animal = new Cat();
Object obj = new Cat();
animal.eat();
animal.run();
animal.show();
animal.sleep();
Cat cat = (Cat) animal;
cat.catchMouse();
Dog dog = (Dog) animal;
System.out.println("ok~~");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
向下转型图解：
animal本来就指向cat对象，所以对animal向下转型为cat是没有问题的，用cat类型指向cat对象。
属性没有重写之说！属性的值看编译类型：
package com.hspedu.poly_.detail_;
public class PolyDetail02 {
public static void main(String[] args) {
Base base = new Sub();
System.out.println(base.count);
Sub sub = new Sub();
System.out.println(sub.count);
}
}
class Base {
int count = 10;
}
class Sub extends Base {
int count = 20;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
instanceOf 比较操作符，用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型：
package com.hspedu.poly_.detail_;
public class PolyDetail03 {
public static void main(String[] args) {
BB bb = new BB();
System.out.println(bb instanceof BB);
System.out.println(bb instanceof AA);
AA aa = new BB();
System.out.println(aa instanceof AA);
System.out.println(aa instanceof BB);
Object obj = new Object();
System.out.println(obj instanceof AA);
String str = "hello";
System.out.println(str instanceof Object);
}
}
class AA {
}
class BB extends AA {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 8.11.6 课堂练习
# 8.11.7 java 的动态绑定机制(非常非常重要.)
package com.hspedu.poly_.dynamic_;
public class DynamicBinding {
public static void main(String[] args) {
A a = new B();
System.out.println(a.sum());
System.out.println(a.sum1());
}
}
class A {
public int i = 10;
public int sum() {
return getI() + 10;
}
public int sum1() {
return i + 10;
}
public int getI() {
return i;
}
}
class B extends A {
public int i = 20;
public int getI() {
return i;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 8.11.8 多态的应用
package com.hspedu.poly_.polyarr_;
public class PloyArray {
public static void main(String[] args) {
Person[] persons = new Person[5];
persons[0] = new Person("jack", 20);
persons[1] = new Student("mary", 18, 100);
persons[2] = new Student("smith", 19, 30.1);
persons[3] = new Teacher("scott", 30, 20000);
persons[4] = new Teacher("king", 50, 25000);
for (int i = 0; i < persons.length; i++) {
System.out.println(persons[i].say());
if(persons[i] instanceof Student) {
Student student = (Student)persons[i];
student.study();
} else if(persons[i] instanceof Teacher) {
Teacher teacher = (Teacher)persons[i];
teacher.teach();
} else if(persons[i] instanceof Person){
} else {
System.out.println("你的类型有误, 请自己检查...");
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 8.12 Object 类详解
# 8.12.1 equals 方法
查看jdk源码之前需要配置如下，不过系统已经默认自动帮你配置了：
# 8.12.2 如何重写 equals 方法
应用实例: 判断两个 Person 对象的内容是否相等，如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false。
package com.hspedu.object_;
public class EqualsExercise01 {
public static void main(String[] args) {
Person person1 = new Person("jack", 10, '男');
Person person2 = new Person("jack", 20, '男');
System.out.println(person1.equals(person2));
}
}
class Person{
private String name;
private int age;
private char gender;
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(obj instanceof Person) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
}
return false;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 8.12.4 hashCode 方法
# 8.12.5 toString 方法
package com.hspedu.object_;
public class ToString_ {
public static void main(String[] args) {
Monster monster = new Monster("小妖怪", "巡山的", 1000);
System.out.println(monster.toString() + " hashcode=" + monster.hashCode());
System.out.println("==当直接输出一个对象时，toString 方法会被默认的调用==");
System.out.println(monster);
}
}
class Monster {
private String name;
private String job;
private double sal;
public Monster(String name, String job, double sal) {
this.name = name;
this.job = job;
this.sal = sal;
}
@Override
public String toString() {
return "Monster{" + "name='" + name + '\'' +
", job='" + job + '\'' +
", sal=" + sal +
'}';
}
@Override
protected void finalize() throws Throwable {
System.out.println("fin..");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 8.12.6 finalize 方法
package com.hspedu.object_;
public class Finalize_ {
public static void main(String[] args) {
Car bmw = new Car("宝马");
bmw = null;
System.gc();
System.out.println("程序退出了....");
}
}
class Car {
private String name;
public Car(String name) {
this.name = name;
}
@Override
protected void finalize() throws Throwable {
System.out.println("我们销毁 汽车" + name );
System.out.println("释放了某些资源...");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 8.13 断点调试(debug)
# 8.13.1 一个实际需求
8.13.3 断点调试的快捷键
小技巧：将光标放在某个变量上，可以看到最新的数据。
老韩小技巧：断点可以在 debug 过程中，动态的下断点
# 8.15 本章作业
