面向对象编程三大特征：封装、继承、多态

封装、继承、多态

1. 封装

1.1 介绍

封装(encapsulation)就是把抽象出的数据 [属性] 和对数据的操作 [方法] 封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作 [方法] ,才能对数据进行操作。

1.2 封装的理解和好处

1) 隐藏实现细节:方法(连接数据库)<--调用(传入参数..)
2) 可以对数据进行验证，保证安全合理
                Person {name, age}
                Person p = new Person();
                p.name = "jack" ;
                p.age = 1200;

1.3 封装的实现步骤 (三步)

1) 将属性进行私有化private【不能直接修改属性】
2) 提供一个公共的(public) set 方法，用于对属性判断并赋值
        public void setXxx (类型参数名)0/Xx表示某个属性
                //加入数据验证的业务逻辑
                属性 = 参数名;
        }
3) 提供一个公共的(public)get方法，用于获取属性的值
        public 数据类型 getXxx() { //权限判断,Xx某个属性
                return xx;
        }

案例练习：
创建程序,在其中定义两个类: Account和AccountTest类体会Java的封装性。
1. Account类要求具有属性: 姓名（长度为2位3位或4位)、余额(必须>20)、密码(必须是六位)，如果不满足，则给出提示信息,并给默认值(程序员自己定)
2. 通过setXxx的方法给Account的属性赋值。
3. 在AccountTest中测试

package com.zakedu.encap;/***创建程序,在其中定义两个类：Account和AccountTest类体会Java的封装性。
*Account类要求具有属性：姓名（长度为2位3位或4位）、余额(必须>20)、
*密码（必须是六位）,如果不满足，则给出提示信息，并给默认值(程序员自己定)*通过setXxx的方法给Account的属性赋值。
*在AccountTest中测试 
*/public class Account {//为了封装，将3个属性设置为privateprivate String name;private double balance;private String pwd;//提供两个构造器
public Account() {}public Account(String name, double balance, String pwd) {this.setName(name);this.setBalance(balance);this.setPwd(pwd);}public String getName() {return name;}//姓名（长度为2位3位或4位）
public void setName(String name) {if (name.length() >= 2 && name.length() <= 4) {this.name = name;} else {
System.out.println("姓名要求（长度为 2 位 3 位或4位），默认值 无名");this.name = "无名";}}public double getBalance() {return balance;}//余额(必须>20)public void setBalance(double balance) {if (balance > 20) {this.balance = balance;} else {System.out.println("余额(必须>20) 默认为 0");} }public String getPwd() {return pwd;}//密码（必须是六位）
public void setPwd(String pwd) {if (pwd.length() == 6) {this.pwd = pwd;
}else{System.out.println("密码（必须是六位）默认密码为000000");this.pwd="000000";}}//显示账号信息
public void showInfo(){//可以增加权限的校验
System.out.println("账号信息name="+name+"余额="+balance+"密码"+pwd);// if(){// System.out.println("账号信息name="+name+"余额="+balance+"密码");// }else{// System.out.println("你无权查看...");// }
} }package com.zakedu.encap;public class TestAccount{public static void main(String[]args){//创建AccountAccount account =new Account();account.setName("jack");account.setBalance(60);account.setPwd("123456");account.showInfo();} }

2. 继承

2.1 继承基本介绍

继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。

2.2 继承的基本语法

继承给编程带来的便利:
1) 代码的复用性提高了 2) 代码的扩展性和维护性提高了

2.3 继承的细节问题

1) 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问,但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
2) 子类必须调用父类的构造器，完成父类的初始化
3) 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。
4) 如果希望指定去调用父类的某个构造器，则显式的调用一下:super(参数列表)
5) super在使用时，必须放在构造器第一行 (super只能在构造器中使用)
6) super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
7) java所有类都是Object类的子类,Object是所有类的基类.
8) 父类构造器的调用不限于直接父类！将一直往上追溯直到Object类(顶级父类)
9) 子类最多只能继承一个父类(指直接继承)，即java中是单继承机制。
10) 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

2.4 继承的本质分析：

案例：

 public class ExtendsTheory {public static void main(String[] args) {Son son = new Son();//内存的布局
//?-> 这时请大家注意，要按照查找关系来返回信息
//(1) 首先看子类是否有该属性
//(2) 如果子类有这个属性，并且可以访问，则返回信息
//(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息..)
//(4) 如果父类没有就按照(3)的规则，继续找上级父类，直到Object...
System.out.println(son.name);//返回就是大头儿子
//System.out.println(son.age);//返回的就是 39
//System.out.println(son.getAge());//返回的就是 39System.out.println(son.hobby);//返回的就是旅游
}}class GrandPa { //爷类
String name = "大头爷爷";
Stringhobby="旅游";}classFatherextendsGrandPa{//父类
Stringname="大头爸爸";privateintage=39;publicintgetAge(){returnage;} }classSonextendsFather{//子类
Stringname="大头儿子";}

3. super关键字

3.1 基本介绍

super代表父类的引用，用于访问父类的属性、方法、构造器

3.2 基本语法

1. 访问父类的属性，但不能访问父类的private属性
        super . 属性名;
2. 访问父类的方法,不能访问父类的private方法
        super . 方法名(参数列表);
3. 访问父类的构造器:
        super(参数列表) ; // 只能放在构造器的第一句，只能出现一句!

3.3 super 给编程带来的便利

1. 调用父类的构造器的好处 (分工明确,父类属性由父类初始化，子类的属性由子类初始化)
2. 当子类中有和父类中的成员 (属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果!
3. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员; 如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则。A->B->C，当然也需要遵守访问权限的相关规则

3.4 super 和 this 的比较

4. 方法重写/覆盖

4.1 基本介绍

简单的说: 方法覆盖(重写)就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的方法

4.2 注意事项

方法重写也叫方法覆盖，需要满足下面的条件：

1. 子类的方法的形参列表,方法名称, 要和父类方法的形参列表，方法名称完全一样。
2. 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
        比如父类返回类型是Object,子类方法返回类型是String
        public object getInfo(){ } 与 public String getInfo(){ }
3. 子类方法不能缩小父类方法的访问权限
        public > protected >默认>private
        void sayok(){ } public void sayok(){ }

重写和重载比较：

5. 多态

5.1 多[多种]态[状态]基本介绍

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

5.2 多态的具体体现

5.2.1 方法的多态

重写和重载就体现多态
案例：

publicclassPloyMethod{
publicstaticvoidmain(String[]args){//方法重载体现多态
Aa=newA();//这里我们传入不同的参数，就会调用不同sum方法，就体现多态
System.out.println(a.sum(10,20));System.out.println(a.sum(10,20,30));//方法重写体现多态
Bb=newB();a.say();b.say();
}}
classB{//父类
publicvoidsay(){System.out.println("Bsay()方法被调用...");} }
classAextendsB{//子类
publicintsum(intn1,intn2){//和下面sum构成重载
returnn1+n2;}publicintsum(intn1,intn2,intn3){returnn1+n2+n3;}publicvoidsay(){System.out.println("Asay()方法被调用...");}}

5.2.2 对象的多态(核心，困难，重点)

(1) 一个对象的编译类型和运行类型可以不一致
(2) 编译类型在定义对象时，就确定了，不能改变
(3) 运行类型是可以变化的.
(4) 编译类型看定义时 =号的左边，运行类型看 =号的右边
案例：

package com.zakedu.poly_.objectpoly_;
public class Animal{public void cry(){System.out.println("Animalcry()动物在叫....");}}package com.zakedu.poly_.objectpoly_;public class Cat extends Animal{public void cry(){System.out.println("Catcry()小猫喵喵叫...");}}package com.zakedu.poly_.objectpoly_;public class Dog extends Animal{public void cry(){System.out.println("Dogcry()小狗汪汪叫...");}}packagecom.zakedu.poly_.objectpoly_;public class PolyObject{public static void main(String[]args){//体验对象多态特点
//animal编译类型就是Animal,运行类型DogAnimal animal = newDog();//因为运行时,执行到改行时，animal运行类型是Dog,所以cry就是Dog的cryanimal.cry();//小狗汪汪叫
//animal编译类型Animal,运行类型就是Catanimal = new Cat();animal.cry();//小猫喵喵叫
}}

5.3 多态注意事项

多态的前提是：两个对象(类)存在继承关系
多态的向上转型：

多态向下转型：

packagecom.zakedu.poly_.detail_;
public class Animal{String name="动物";intage=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.zakedu.poly_.detail_;public class Cat extends Animal {public void eat(){//方法重写
System.out.println("猫吃鱼");}public void catchMouse(){//Cat 特有方法
System.out.println("猫抓老鼠");} }package com.zakedu.poly_.detail_;public class Dog extends Animal {//Dog 是 Animal 的子类
}package com.zakedu.poly_.detail_;public class PolyDetail {
public static void main(String[] args) {//向上转型: 父类的引用指向了子类的对象
//语法：父类类型引用名 =new 子类类型();Animal animal = new Cat();Object obj = new Cat();//可以吗? 可以 Object 也是 Cat 的父类
//向上转型调用方法的规则如下://(1)可以调用父类中的所有成员(需遵守访问权限)//(2)但是不能调用子类的特有的成员
//(#)因为在编译阶段，能调用哪些成员,是由编译类型来决定的
//animal.catchMouse();错误
//(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法
//，然后调用，规则我前面我们讲的方法调用规则一致。
animal.eat();//猫吃鱼..animal.run();//跑
animal.show();//hello,你好
animal.sleep();//睡//可以调用Cat的 catchMouse方法
//多态的向下转型
//老师希望，可以调用Cat的 catchMouse方法
//(1)语法：子类类型 引用名 =（子类类型）父类引用;//问一个问题?cat 的编译类型 Cat,运行类型是 CatCat cat = (Cat) animal;cat.catchMouse();//猫抓老鼠
//(2)要求父类的引用必须指向的是当前目标类型的对象
Dog dog=(Dog)animal;//可以吗？
System.out.println("ok~~");} }

属性没有重写之说！属性的值看编译类型：

 packagecom.zakedu.poly_.detail_;public class PolyDetail02{public static void main(String[]args){//属性没有重写之说！属性的值看编译类型
Base base = new Sub();//向上转型
System.out.println(base.count);//？看编译类型10Sub sub = new Sub();System.out.println(sub.count);//? 20} }class Base{//父类
int count=10;//属性
}class Sub extends Base{//子类
int count=20;//属性
}

instanceOf 比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型：

package com.zakedu.poly_.detail_;public class PolyDetail03 {public static void main(String[] args) {BB bb = new BB();System.out.println(bb instanceof BB);// trueSystem.out.println(bb instanceof AA);// true//aa 编译类型 AA, 运行类型是BB//BB 是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);//falseString str = "hello";//System.out.println(str instanceof AA);System.out.println(str instanceof Object);//true} }class AA{} //父类
class BB extends AA{}//子类

5.4 java 的动态绑定机制(非常非常重要.)

5.5 多态的应用

5.5.1 多态数组：

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

应用实例：
现有一个继承结构如下：要求创建1个Person对象、2个Student对象和2个Teacher对象,统一放在数组中，并调用每个对象say方法.
应用实例升级：如何调用子类特有的方法，比如 Teacher有一个teach,Student有一个study 怎么调用？
代码:

 package com.zakedu.poly_.polyarr_;public class Person{//父类private String name;private int age;public Person(Stringname,intage){this.name=name;this.age=age;}public String getName(){return name;}public voidsetName(String name){this.name=name;}public int getAge(){return age;}public void setAge(intage){this.age=age;}public String say(){//返回名字和年龄
return name+"\t"+age;} }packagecom.zakedu.poly_.polyarr_;public class Student extends Person{private double score;public Student(String name,int age,double score){super(name, age);this.score = score;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}//重写父类say@Overridepublic String say() {return "学生 " + super.say() + " score=" + score;}//特有的方法
public void study() {System.out.println("学生 " + getName() + " 正在学 java...");} }package com.zakedu.poly_.polyarr_;public class Teacher extends Person {private double salary;public Teacher(String name, int age, double salary) {super(name, age);this.salary = salary;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}//写重写父类的say方法
@Overridepublic String say() {return "老师 " + super.say() + " salary=" + salary;}//特有方法
public void teach() {System.out.println("老师 " + getName() + " 正在讲 java 课程...");} }

package com.zakedu.poly_.polyarr_;public class PloyArray {public static void main(String[] args) {//应用实例:现有一个继承结构如下：要求创建1个Person对象、
// 2 个Student 对象和2个Teacher 对象, 统一放在数组中，并调用每个对象say方法
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);//循环遍历多态数组，调用sayfor (int i = 0; i < persons.length; i++) {System.out.println(persons[i].say());//动态绑定机制
//老师提示:person[i] 编译类型是 Person,运行类型是是根据实际情况有JVM来判断
//这里大家聪明. 使用 类型判断 + 向下转型.if(persons[i] instanceof Student) {//判断 person[i] 的运行类型是不是 StudentStudent student = (Student)persons[i];//向下转型student.study();//小伙伴也可以使用一条语句 ((Student)persons[i]).study();} else if(persons[i] instanceof Teacher) {Teacher teacher = (Teacher)persons[i];teacher.teach();
} else if(persons[i] instanceof Person){//System.out.println("你的类型有误, 请自己检查...");} else {System.out.println("你的类型有误, 请自己检查...");} } } }

5.5.2 多态参数

代码：

 package com.zakedu.poly_.polyparameter_;public class Employee {private String name;private double salary;public Employee(String name, double salary) {this.name = name;this.salary = salary;}//得到年工资的方法
public double getAnnual() {return 12 * salary;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;
} }package com.zakedu.poly_.polyparameter_;public class Manager extends Employee{private double bonus;public Manager(String name, double salary, double bonus) {super(name, salary);this.bonus = bonus;}public double getBonus() {return bonus;}public void setBonus(double bonus) {this.bonus = bonus;}public void manage() {System.out.println("经理 " + getName() + " is managing");}//重写获取年薪方法
@Override
public double getAnnual(){returnsuper.getAnnual()+bonus;} }packagecom.zakedu.poly_.polyparameter_;public class Worker extends Employee{public Worker(Stringname,doublesalary){super(name,salary);}public void work(){System.out.println("普通员工"+getName()+"isworking");}@Overridepublic double getAnnual(){//因为普通员工没有其它收入，则直接调用父类方法
return super.getAnnual();} }packagecom.zakedu.poly_.polyparameter_;public class PloyParameter{public static void main(String[]args){Worker tom=new Worker("tom",2500);
Manager milan = new Manager("milan", 5000, 200000);PloyParameter ployParameter = new PloyParameter();ployParameter.showEmpAnnual(tom);ployParameter.showEmpAnnual(milan);ployParameter.testWork(tom);ployParameter.testWork(milan);}//showEmpAnnual(Employee e)//实现获取任何员工对象的年工资,并在main方法中调用该方法 [e.getAnnual()]public void showEmpAnnual(Employee e) {System.out.println(e.getAnnual());//动态绑定机制.}public void testWork(Employee e) {if(e instanceof Worker) {((Worker) e).work();//有向下转型操作
} else if(e instanceof Manager) {} else {//添加一个方法，testWork,如果是普通员工，则调用work方法，如果是经理，则调用manage方法
((Manager) e).manage();//有向下转型操作
System.out.println("不做处理...");} } }

6. Object类详解

6.1 equals方法

== 和 equals的对比（面试题）：
==是一个比较运算符
1. ==:既可以判断基本类型,又可以判断引用类型；
2. ==:如果判断基本类型，判断的是值是否相等。示例: int i=10; double d=10.0;
3. ==:如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象；
4. equals:是Object类中的方法，只能判断引用类型；
5. 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如
lnteger,String【看看String和Integer的equals源代码】。
代码：

publicclassEquals01{
public static void main(String[]args){A a = new A();A b=a;A c=b;System.out.println(a==c);//trueSystem.out.println(b==c);//trueB bObj =a;System.out.println(bObj==c);//trueint num1 =10double num2 = 10.0;System.out.println(num1 == num2);//基本数据类型，判断值是否相等
//equals 方法，源码怎么查看.//把光标放在equals 方法，直接输入ctrl+b//如果你使用不了. 自己配置. 即可使用./*//带大家看看Jdk的源码 String类的 equals方法
//把 Object 的 equals 方法重写了,变成了比较两个字符串值是否相同
public boolean equals(Object anObject) {if (this == anObject) {//如果是同一个对象
return true;//返回 true}if (anObject instanceof String) {//判断类型
String anotherString = (String)anObject;//向下转型
int n = value.length;if (n == anotherString.value.length) {//如果长度相同
char v1[] = value;int i = 0;char v2[] = anotherString.value;while (n-- != 0) {//然后一个一个的比较字符
if (v1[i] != v2[i])return false;i++;}
return true;//如果两个字符串的所有字符都相等，则返回true}}return false;//如果比较的不是字符串，则直接返回false}*/"hello".equals("abc");//看看Object 类的 equals 是
/*//即 Object 的 equals 方法默认就是比较对象地址是否相同
//也就是判断两个对象是不是同一个对象.public boolean equals(Object obj) {return (this == obj);}*//*//从源码可以看到 Integer 也重写了Object的equals方法,//变成了判断两个值是否相同
public boolean equals(Object obj) {if (obj instanceof Integer) {return value == ((Integer)obj).intValue()
}return false;}*/Integer integer1 = new Integer(1000);Integer integer2 = new Integer(1000);System.out.println(integer1 == integer2);//falseSystem.out.println(integer1.equals(integer2));//trueString str1 = new String("hspedu");String str2 = new String("hspedu");System.out.println(str1 == str2);//falseSystem.out.println(str1.equals(str2));//true}}class B {}class Aextends B {}

6.2 如何重写equals方法

应用实例: 判断两个Person对象的内容是否相等，如果两个Person对象的各个属性值都一样，则返回true，反之false。

 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));//假
}}//判断两个Person对象的内容是否相等，
//如果两个Person对象的各个属性值都一样，则返回true，反之falseclass Person{ //extends Objectprivate String name;private int age;private char gender;//重写Object 的 equals 方法
public boolean equals(Object obj) {if(this == obj) {//判断如果比较的两个对象是同一个对象，则直接返回truereturn true;}//类型判断
if(obj instanceof Person) {//是 Person，我们才比较
//进行 向下转型, 因为我需要得到obj的 各个属性
Person p = (Person)obj;return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;}//如果不是Person ，则直接返回falsereturn false;}public Person(String name, int age, char gender) {this.name = name;this.age = age;this.gender = gender;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;
}public void setAge(intage){this.age=age;}public char getGender(){return gender;}public void setGender(chargender){this.gender=gender;} }

6.3 hashCode 方法

6个小结:
1) 提高具有哈希结构的容器的效率！
2) 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的！
3) 两个引用，如果指向的是不同对象，则哈希值是不一样的
4) 哈希值主要根据地址号来的！，不能完全将哈希值等价于地址。
5)案例演示[HashCode_.java]:obj.hashCode() [测试：Aobj1=newA();Aobj2=newA();Aobj3=obj1]
代码：

public class HashCode_{public static void main(String[]args){AA aa= new AA();AA aa2= new AA();AA aa3=aa;System.out.println("aa.hashCode()="+aa.hashCode());System.out.println("aa2.hashCode()="+aa2.hashCode());System.out.println("aa3.hashCode()="+aa3.hashCode());} }class AA{}

6.4 toString方法

1. 基本介绍：
默认返回：全类名+@+哈希值的十六进制，【查看Object的toString方法】子类往往重写toString方法，用于返回对象的属性信息
2. 重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式
3. 当直接输出一个对象时，toString 方法会被默认的调用, 比如 System.out.println(monster)；就会默认调用 monster.toString()
代码：

 public class ToString_ {public static void main(String[] args) {/*Object 的 toString() 源码
(1)getClass().getName() 类的全类名(包名+类名 )(2)Integer.toHexString(hashCode()) 将对象的 hashCode 值转成 16 进制字符串
public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}*/Monster monster = new Monster("小妖怪", "巡山的", 1000);System.out.println(monster.toString() + " hashcode=" + monster.hashCode());System.out.println("==当直接输出一个对象时，toString 方法会被默认的调用==");System.out.println(monster); //等价 monster.toString()
} }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;}//重写toString 方法, 输出对象的属性
//使用快捷键即可 alt+insert-> toString@Overridereturn "Monster{" +"name='" + name + '\' +public String toString() { //重写后，一般是把对象的属性值输出，当然程序员也可以自己定制
", job='" + job + '\' +", sal=" + sal +'}';}@Override
protectedvoidfinalize()throwsThrowable{System.out.println("fin..");} }

6.5 finalize方法

1) 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作
2) 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。
3) 垃圾回收机制的调用，是由系统来决定(即有自己的GC算法),也可以通过System.gc()主动触发垃圾回收机制，测试：Car[name]
提示：我们在实际开发中，几乎不会运用finalize,所以更多就是为了应付面试.
代码：

//演示Finalize的用法
public class Finalize_{public static void main(String[]args){Car bmw =new Car("宝马");//这时car对象就是一个垃圾,垃圾回收器就会回收(销毁)对象,在销毁对象前，会调用该对象的finalize方法
//,程序员就可以在finalize中，写自己的业务逻辑代码(比如释放资源：数据库连接,或者打开文件..)//,如果程序员不重写finalize,那么就会调用Object类的finalize,即默认处理
//,如果程序员重写了finalize, 就可以实现自己的逻辑bmw =null;System.gc();//主动调用垃圾回收器
System.out.println("程序退出了....");} }class Car {private String name;//属性, 资源。。
public Car(String name) {this.name = name;}//重写finalize@Overrideprotected void finalize() throws Throwable {System.out.println("我们销毁 汽车" + name );System.out.println("释放了某些资源...");} }

7. 断点调试(debug)

7.1 断点调试介绍

1. 断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住,然后你可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码行即显示错误，停下。进行分析从而找到这个Bug
2. 断点调试是程序员必须掌握的技能。
3. 断点调试也能帮助我们查看java底层源代码的执行过程，提高程序员的Java水平。