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

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个属性设置为private
 private 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){
 //创建Account
 Account 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());//返回的就是 39
 System.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,运行类型Dog
 Animal animal = newDog();
 //因为运行时,执行到改行时，animal运行类型是Dog,所以cry就是Dog的cry
 animal.cry();//小狗汪汪叫
//animal编译类型Animal,运行类型就是Cat
 animal = 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,运行类型是 Cat
 Cat 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);//？看编译类型10
 Sub 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);// true
 System.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);//false
 String 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
 @Override
 public 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方法
@Override
 public 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);
 //循环遍历多态数组，调用say
 for (int i = 0; i < persons.length; i++) {
 System.out.println(persons[i].say());//动态绑定机制
//老师提示:person[i] 编译类型是 Person,运行类型是是根据实际情况有JVM来判断
//这里大家聪明. 使用 类型判断 + 向下转型.
 if(persons[i] instanceof Student) {//判断 person[i] 的运行类型是不是 Student
 Student 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");
 }
 @Override
 public 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);//true
 System.out.println(b==c);//true
 B bObj =a;
 System.out.println(bObj==c);//true
 int num1 =10
 double 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);//false
 System.out.println(integer1.equals(integer2));//true
 String str1 = new String("hspedu");
 String str2 = new String("hspedu");
 System.out.println(str1 == str2);//false
 System.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，反之false
 class Person{ //extends Object
 private String name;
 private int age;
 private char gender;
 //重写Object 的 equals 方法
public boolean equals(Object obj) {
 if(this == obj) {
 //判断如果比较的两个对象是同一个对象，则直接返回true
 return 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 ，则直接返回false
 return 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
 @Override
 return "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
 @Override
 protected void finalize() throws Throwable {
 System.out.println("我们销毁 汽车" + name );
 System.out.println("释放了某些资源...");
 } }

7. 断点调试(debug)

7.1 断点调试介绍

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

7.2 断点调试的快捷键

F7(跳入) F8(跳过) shift+F8(跳出)F9(resume,执行到下一个断点)
F7：跳入方法内
F8: 逐行执行代码.
shift+F8: 跳出方法

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