关于后端:Java面向对象编程中级

IDEA 罕用快捷键

1. 删除以后行, 默认是 ctrl + Y 本人配置 ctrl + d
2. 复制以后行, 本人配置 ctrl + alt + 向下光标
3. 补全代码 alt + /
4. 增加正文和勾销正文 ctrl + /
5. 导入该行须要的类先配置 auto import , 而后应用 alt+enter 即可
6. 疾速格式化代码 ctrl + alt + L
7. 疾速运行程序本人定义 alt + R
8. 生成结构器等 alt + insert [进步开发效率]
9. 查看一个类的层级关系 ctrl + H
10. 将光标放在一个办法上，输出 ctrl + B , 能够定位到办法
11. 主动的调配变量名, 通过在前面加.var

包

包的三大作用

辨别雷同名字的类

当类很多时, 能够很好的治理类[看 Java API 文档]

管制拜访范畴

包根本语法

package com.hspedu;

阐明:

package 关键字, 示意打包

com.hspedu: 示意包名

包的实质剖析

包的实质实际上就是创立不同的文件夹 / 目录来保留类文件

包的命名

命名规定

只能蕴含数字、字母、下划线、小圆点.，但不能用数字结尾，不能是关键字或保留字。
命名标准

个别是小写字母 + 小圆点

个别是 com. 公司名. 我的项目名. 业务模块名

例如：

com.sina.crm.user // 用户模块

com.sina.crm.order // 订单模块

com.sina.crm.utils // 工具类

罕用的包

一个包下, 蕴含很多的类,java 中罕用的包有:

1. java.lang.* //lang 包是根本包，默认引入，不须要再引入.
2. java.util.* //util 包，零碎提供的工具包, 工具类，应用 Scanner
3. java.net.* // 网络包，网络开发
4. java.awt.* // 是做 java 的界面开发，GUI

如何引入包

语法: import 包;

咱们引入一个包的次要目标是要应用该包下的类

比方

import java.util.Scanner;  // 就只是引入一个类

Scanner.import java.util.*;// 示意将 java.util 包所有都引入

倡议：咱们须要应用到哪个类，就导入哪个类即可，不倡议应用 * 导入

注意事项和应用细节

1. package 的作用是申明以后类所在的包，须要放在类的最下面，一个类中最多只有一句 package
2. import 指令地位放在 package 的上面，在类定义后面, 能够有多句且没有程序要求。

//package 的作用是申明以后类所在的包，须要放在类 (或者文件) 的最下面，// 一个类中最多只有一句 package
package com.hspedu.pkg;

//import 指令 地位放在 package 的上面，在类定义后面, 能够有多句且没有程序要求
import java.util.Scanner;
import java.util.Arrays;

拜访修饰符

根本介绍

java 提供四种访问控制润饰符号，用于管制办法和属性 (成员变量) 的拜访权限（范畴）:

1. 公开级别: 用 public 润饰, 对外公开
2. 受爱护级别: 用 protected 润饰, 对子类和同一个包中的类公开
3. 默认级别: 没有润饰符号, 向同一个包的类公开.
4. 公有级别: 用 private 润饰, 只有类自身能够拜访, 不对外公开.

拜访修饰符的拜访范畴!

应用的注意事项

1. 修饰符能够用来润饰类中的属性, 成员办法以及类
2. 只有默认的和 public 能力润饰类!，并且遵循上述拜访权限的特点。
3. 成员办法的拜访规定和属性齐全一样.

面向对象编程三大特色

根本介绍

面向对象编程有三大特色：封装、继承和多态。

封装介绍

封装 (encapsulation) 就是把形象出的数据 [属性] 和对数据的操作 [办法] 封装在一起, 数据被爱护在外部, 程序的其它局部只有通过被受权的操作 [办法] , 能力对数据进行操作。

封装的了解和益处

暗藏实现细节: 办法(连贯数据库) <– 调用(传入参数)

能够对数据进行验证，保障平安正当

Person {name, age}
Person p = new Person();
p.name = "jack" ;
p.age= 1200;

封装的实现步骤(三步)

1. 将属性进行私有化 private【不能间接批改属性】

2. 提供一个公共的(public)set 办法，用于对属性判断并赋值

   public void setXxx(类型参数名){//Xxx 示意某个属性
    // 退出数据验证的业务逻辑
    属性 = 参数名;
   }

3. 提供一个公共的 (public)get 办法，用于获取属性的值

   public 数据类型 getXxx(){ // 权限判断,Xxx 某个属性
    return xx;
   }

疾速入门案例

package com.hspedu.encap;

public class Encapsulation01 {public static void main(String[] args) {
        // 如果要应用快捷键 alt+r, 须要先配置主类
        // 第一次，咱们应用鼠标点击模式运算程序，前面就能够用
        Person person = new Person();
        person.setName("韩顺平");
        person.setAge(30);
        person.setSalary(30000);
        System.out.println(person.info());
        System.out.println(person.getSalary());

        // 如果咱们本人应用结构器指定属性
        Person smith = new Person("smith", 80, 50000);
        System.out.println("====smith 的信息 ======");
        System.out.println(smith.info());


    }
}
/*
那么在 java 中如何实现这种相似的管制呢?
请大家看一个小程序(com.hspedu.encap: Encapsulation01.java),
不能轻易查看人的年龄, 工资等隐衷，并对设置的年龄进行正当的验证。年龄正当就设置，否则给默认
年龄, 必须在 1-120, 年龄，工资不能间接查看，name 的长度在 2- 6 字符 之间

 */
class Person {
    public  String name; // 名字公开
    private int age; //age 私有化
    private double salary; //..

    public void say(int n,String name) { }
    // 结构器 alt+insert
    public Person() {}
    // 有三个属性的结构器
    public Person(String name, int age, double salary) {
//        this.name = name;
//        this.age = age;
//        this.salary = salary;
        // 咱们能够将 set 办法写在结构器中，这样依然能够验证
        setName(name);
        setAge(age);
        setSalary(salary);
    }

    // 本人写 setXxx 和 getXxx 太慢，咱们应用快捷键 Generate --> Getter and Setter
    // 而后依据要求来欠缺咱们的代码.
    public String getName() {return name;}
    public void setName(String name) {
        // 退出对数据的校验, 相当于减少了业务逻辑
        if(name.length() >= 2 && name.length() <=6) {this.name = name;}else {System.out.println("名字的长度不对，须要 (2-6) 个字符，默认名字");
            this.name = "无名人";
        }
    }

    public int getAge() {return age;}

    public void setAge(int age) {
        // 判断
        if(age >= 1 && age <= 120) {// 如果是正当范畴
            this.age = age;
        } else {System.out.println("你设置年龄不对，须要在 (1-120), 给默认年龄 18");
            this.age = 18;// 给一个默认年龄
        }
    }

    public double getSalary() {
        // 能够这里减少对以后对象的权限判断
        return salary;
    }

    public void setSalary(double salary) {this.salary = salary;}
    // 写一个办法，返回属性信息
    public String info() {return "信息为 name=" + name  + "age=" + age + "薪水 =" + salary;}
}

将结构器和 setXxx 联合

能够将 set 办法写在结构器中，这样能够保障验证。

public Person(String name, int age, double salary) {
    // this.name = name;
    // this.age = age;
    // this.salary = salary;
    // 咱们能够将 set 办法写在结构器中，这样依然能够验证
    setName(name);
    setAge(age);
    setSalary(salary);
}

面向对象编程 - 继承

继承能够解决代码复用, 让咱们的编程更加凑近人类思维. 当多个类存在雷同的属性 (变量) 和办法时, 能够从这些类中形象出父类, 在父类中定义这些雷同的属性和办法，所有的子类不须要从新定义这些属性和办法，只须要通过 extends 来申明继承父类即可。

继承的根本语法

class 子类 extends 父类 {}

1)子类就会主动领有父类定义的属性和办法

2)父类又叫超类, 基类。

3)子类又叫派生类。

继承的深刻探讨 / 细节问题

1. 子类继承了所有的属性和办法，非公有的属性和办法能够在子类间接拜访, 然而公有属性和办法不能在子类间接拜访，要 通过父类提供公共的办法去拜访
2. 子类必须调用父类的结构器，实现父类的初始化。先调用父类结构器，再调用子类结构器。
3. 当创立子类对象时，不论应用子类的哪个结构器，默认状况下总会去调用父类的无参结构器，如果父类没有提供无参结构器，则必须在子类的结构器中用 super 去指定应用父类的哪个结构器实现对父类的初始化工作，否则，编译不会通过.
4. 如果心愿指定去调用父类的某个结构器，则显式的调用一下: super(参数列表)
5. super 在应用时，必须放在结构器第一行(super 只能在结构器中应用 )
6. super() 和 this() 都只能放在结构器第一行，因而这两个办法 不能共存在一个结构器。
7. java 所有类都是 Object 类的子类, Object 是所有类的基类.
8. 父类结构器的调用不限于间接父类！将始终往上追溯直到 Object 类(顶级父类)
9. 子类最多只能继承一个父类(指间接继承)，即 java 中是单继承机制。
   思考：如何让 A 类继承 B 类和 C 类？办法：A 继承 B，B 继承 C。
10. 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

package com.hspedu.extend_;

import java.util.Arrays;

// 输出 ctrl + H 能够看到类的继承关系
public class Sub extends Base { // 子类

    public Sub(String name, int age) {//1. 要调用父类的无参结构器, 如下或者什么都不写, 默认就是调用 super()
        //super();// 父类的无参结构器
        //2. 要调用父类的 Base(String name) 结构器
        //super("hsp");
        //3. 要调用父类的 Base(String name, int age) 结构器
        super("king", 20);

        // 细节：super 在应用时，必须放在结构器第一行
        // 细节: super() 和 this() 都只能放在结构器第一行，因而这两个办法不能共存在一个结构器
        //this() 不能再应用了
        System.out.println("子类 Sub(String name, int age)结构器被调用....");


    }

    public Sub() {// 无参结构器
        //super(); // 默认调用父类的无参结构器
        super("smith", 10);
        System.out.println("子类 Sub()结构器被调用....");
    }
    // 当创立子类对象时，不论应用子类的哪个结构器，默认状况下总会去调用父类的无参结构器
    public Sub(String name) {super("tom", 30);
        //do nothing...
        System.out.println("子类 Sub(String name)结构器被调用....");
    }

    public void sayOk() {// 子类办法
        // 非公有的属性和办法能够在子类间接拜访
        // 然而公有属性和办法不能在子类间接拜访
        System.out.println(n1 + "" + n2 +" " + n3);
        test100();
        test200();
        test300();
        //test400(); 谬误
        // 要通过父类提供公共的办法去拜访
        System.out.println("n4=" + getN4());
        callTest400();//}

}

继承的实质剖析!

咱们着一个案例来剖析当子类继承父类，创立子类对象时，内存中到底产生了什么?

当子类对象创立好后，建设查找的关系

1. 最先加载父类，别离是 Object 类，而后加载 Grandpa，再 Father，最初 Son。
2. 而后再调配堆空间：不同类的雷同变量名不会抵触，堆中空间不同。
3. 最初 Son 对象（0x11 都是）返回给 main 中的援用。

那么最初输入什么呢？（还是 就近准则）

package com.hspedu.extend_;

/**
 * 解说继承的实质
 */
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 = "大头爷爷";
    String hobby = "游览";
}

class Father extends GrandPa {// 父类
    String name = "大头爸爸";
    private int age = 39;

    public int getAge() {return age;}
}

class Son extends Father { // 子类
    String name = "大头儿子";
}

super 关键字

根本介绍

super 代表父类的援用，用于拜访父类的属性、办法、结构器

根本语法

1. 拜访父类的属性，但不能拜访父类的 private 属性[案例]

super. 属性名;

2. 拜访父类的办法, 不能拜访父类的 private 办法

super. 办法名(参数列表);

3. 拜访父类的结构器:

super(参数列表); 只能放在结构器的第一句，只能呈现一句!

package com.hspedu.super_;

public class A extends Base{
    // 4 个属性
    //public int n1 = 100;
    protected int n2 = 200;
    int 3 = 300;
    private int n4 = 400;

    public A() {}
    public A(String name) {}
    public A(String name, int age) {}

//    public void cal() {//        System.out.println("A 类的 cal() 办法...");
//    }

    public void test100() {}

    protected void test200() {}

    void test300() {}

    private void test400() {}
}

cal() 和 this.cal() 雷同，就近准则。
super.cal() 的程序是间接查找父类，其余的规定一样

package com.hspedu.super_;

public class B extends A {

    public int n1 = 888;

    // 编写测试方法
    public void test() {
        //super 的拜访不限于间接父类，如果爷爷类和本类中有同名的成员，也能够应用 super 去拜访爷爷类的成员；// 如果多个基类 (下级类) 中都有同名的成员，应用 super 拜访遵循就近准则。A->B->C

        System.out.println("super.n1=" + super.n1);
        super.cal();}

    // 拜访父类的属性 , 但不能拜访父类的 private 属性 [案例]super. 属性名
    public void hi() {System.out.println(super.n1 + "" + super.n2 +" " + super.n3);
    }
    public void cal() {System.out.println("B 类的 cal() 办法...");
    }
    public void sum() {System.out.println("B 类的 sum()");
        // 心愿调用父类 -A 的 cal 办法
        // 这时，因为子类 B 没有 cal 办法，因而我能够应用上面三种形式

        // ! 找 cal 办法时(cal() 和 this.cal())，程序是:
        // (1)先找本类，如果有，则调用
        // (2)如果没有，则找父类(如果有，并能够调用，则调用)
        // (3)如果父类没有，则持续找父类的父类, 整个规定，就是一样的, 直到 Object 类
        // 提醒：如果查找办法的过程中，找到了，然而不能拜访，则报错, cannot access
        //      如果查找办法的过程中，没有找到，则提醒办法不存在
        //cal();
        this.cal(); // 等价 cal

        // ! 找 cal 办法(super.call()) 的程序是间接查找父类，其余的规定一样
        //super.cal();

        // 演示拜访属性的规定
        // !n1 和 this.n1 查找的规定是
        //(1) 先找本类，如果有，则调用
        //(2) 如果没有，则找父类(如果有，并能够调用，则调用)
        //(3) 如果父类没有，则持续找父类的父类, 整个规定，就是一样的, 直到 Object 类
        // 提醒：如果查找属性的过程中，找到了，然而不能拜访，则报错, cannot access
        //      如果查找属性的过程中，没有找到，则提醒属性不存在
        System.out.println(n1);
        System.out.println(this.n1);

        // ! 找 n1 (super.n1) 的程序是间接查找父类属性，其余的规定一样
        System.out.println(super.n1);

    }
    // 拜访父类的办法，不能拜访父类的 private 办法 super. 办法名(参数列表);
    public void ok() {super.test100();
        super.test200();
        super.test300();
        //super.test400();// 不能拜访父类 private 办法}
    // 拜访父类的结构器(这点后面用过)：super(参数列表); 只能放在结构器的第一句，只能呈现一句！public  B() {//super();
        //super("jack", 10);
        super("jack");
    }
}

super 给编程带来的便当 / 细节

1. 调用父类的结构器的益处(分工明确, 父类属性由父类初始化，子类的属性由子
   类初始化)
2. 当子类中有和父类中的成员 (属性和办法) 重名时，为了拜访父类的成员，必须
   通过 super。如果没有重名，应用 super、this、间接拜访是一样的成果!
3. super 的拜访不限于间接父类，如果爷爷类和本类中有同名的成员，也能够应用
   super 去拜访爷爷类的成员; 如果多个基类(下级类) 中都有同名的成员，应用 super 拜访遵循就近准则。A->B->C，当然也须要恪守拜访权限的相干规定

super 和 this 的比拟

办法重写 / 笼罩(override)

简略的说: 办法笼罩 (重写) 就是子类有一个办法, 和父类的某个办法的名称、返回类型、参数一样, 那么咱们就说子类的这个办法笼罩了父类的办法。

注意事项和应用细节

办法重写也叫办法笼罩，须要满足上面的条件

1. 子类的办法的形参列表, 办法名称, 要和父类办法的形参列表办法名称齐全一样。

2. 子类办法的返回类型和父类办法返回类型一样，或者是父类返回类型的子类

   比方交类返回类型是 Object, 子类办法返回类型是 String
   public object getInfo()
   public String getInfo()

3. 子类办法不能放大父类办法的拜访权限。最好大于等于父类的权限。

   public > protected > 默认 >private

重写和重载比拟!

面向对象编程 - 多态

传统的办法带来的问题是什么?

代码的复用性不高，而且不利于代码保护

解决方案：引出咱们要解说的多态

多 [多种] 态[状态]根本介绍

办法或对象具备多种状态。是面向对象的第三大特色，多态是建设在封装和继承根底之上的。

多态的具体体现

办法的多态

重写和重载就体现多态

对象的多态!

(1) 一个对象的 编译类型和运行类型能够不统一

(2) 编译类型在定义对象时，就确定了，不能扭转

(3) 运行类型是能够变动的.

(4) 编译类型看定义时 = 号的右边，运行类型看 = 号的左边

Animal animal = new Dog() // animal 编译类型是 Animal，运行类型 Dog
animal = new Cat();// animal 的运行类型变成了 Cat, 编译类型依然是 Animal

多态注意事项和细节探讨

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

多态的向上转型

1. 实质: 父类的援用指向了子类的对象
2. 语法:父类类型援用名 =new 子类类型();

3. 特点: 编译类型看右边, 运行类型看左边。

   ** 能够调用父类中的所有成员(需恪守拜访权限), 不能调用子类中特有成员;
   最终运行成果看子类的具体实现!**（运行时看运行类型，例如找办法时就是采纳就近准则）

   因为在编译阶段，能调用哪些成员，是由编译类型决定的。

多态向下转型

语法: 子类类型 援用名 = (子类类型) 父类援用;

1. 只能强转父类的援用，不能强转父类的对象
2. 要求父类的援用必须指向的是以后指标类型的对象
3. 当向下转型后，能够调用子类类型中所有的成员

package com.hspedu.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 办法
        // 多态的向下转型
        //(1)语法：子类类型 援用名 =（子类类型）父类援用;
        // 问一个问题? cat 的编译类型 Cat, 运行类型是 Cat
        Cat cat = (Cat) animal;

        cat.catchMouse();// 猫抓老鼠
        //(2)要求父类的援用必须指向的是以后指标类型的对象
        // animal 原本创立时就指向 cat 对象
        // 前面 animal 向下转型 cat 指向 cat 对象
        Dog dog = (Dog) animal;// 能够吗？谬误!

        System.out.println("ok~~");
    }
}

属性没有重写之说

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

package com.hspedu.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.hspedu.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); // true
        System.out.println(aa instanceof BB); // true

        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 {}// 子类

java 的动静绑定机制!!

**1. 当调用对象办法的时候，该办法会和该对象的内存地址 / 运行类型绑定
2. 当调用对象属性时，没有动静绑定机制，哪里申明，哪里应用 **，找不到再去父类中寻找。

package com.hspedu.poly_.dynamic_;

public class DynamicBinding {public static void main(String[] args) {
        //a 的编译类型 A, 运行类型 B
        A a = new B();// 向上转型
        System.out.println(a.sum()); //?40 -> 30 (20 + 10)
        System.out.println(a.sum1());//?30 -> 20 (10 + 10)
    }
}

class A {// 父类
    public int i = 10;
    // 动静绑定机制:

    public int sum() {// 父类 sum()
        return getI() + 10;//20 + 10}

    public int sum1() {// 父类 sum1()
        return i + 10;//10 + 10
    }

    public int getI() {// 父类 getI
        return i;
    }
}

class B extends A {// 子类
    public int i = 20;

//    public int sum() {
//        return i + 20;
//    }

    public int getI() {// 子类 getI()
        return i;
    }

//    public int sum1() {
//        return i + 10;
//    }
}

多态的利用

多态数组

数组的定义类型为父类类型，外面保留的理论元素类型为子类类型。

利用实例: 现有一个继承构造如下：要求创立 1 个 Person 对象、2 个 Student 对象和 2 个 Teacher 对象, 对立放在数组中，并调用每个对象 say 办法.

利用实例降级：如何调用子类特有的办法，比方 Teacher 有一个 teach , Student 有一个 study，怎么调用？

package com.hspedu.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++) {// 老师提醒: person[i] 编译类型是 Person , 运行类型是是依据理论状况有 JVM 来判断
            System.out.println(persons[i].say());// 动静绑定机制
            // 这里聪慧. 应用 类型判断 + 向下转型.!!!!
            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("你的类型有误, 请本人查看...");
            }
        }
    }
}

多态参数

办法定义的形参类型为父类类型，实参类型容许为子类类型利用实例

定义员工类 Employee，蕴含姓名和月工资[private]，以及计算年工资 getAnnual 的办法。普通员工和经理继承了员工，经理类多了奖金 bonus 属性和治理 manage 办法，普通员工类多了 work 办法，普通员工和经理类要求别离重写 getAnnual 办法

测试类中增加一个办法 showEmpAnnual(Employee e)，实现获取任何员工对象的年工资, 并在 main 办法中调用该办法[e.getAnnual()]

测试类中增加一个办法，testWork, 如果是普通员工，则调用 work 办法，如果是经理, 则调用 manage 办法

package com.hspedu.poly_.polyarr_;

public class Person {// 父类
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public int getAge() {return age;}

    public void setAge(int age) {this.age = age;}

    public String say() {// 返回名字和年龄
        return name + "\t" + age;
    }
}

package com.hspedu.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.hspedu.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.hspedu.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++) {// 老师提醒: person[i] 编译类型是 Person , 运行类型是是依据理论状况有 JVM 来判断
            System.out.println(persons[i].say());// 动静绑定机制
            // 这里大家聪慧. 应用 类型判断 + 向下转型.
            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("你的类型有误, 请本人查看...");
            }
        }
    }
}

Object 类详解

equals 办法

== 和 equals 的比照!!!!!

== 是一个比拟运算符

==: 既 能够判断根本类型，又能够判断援用类型

• ==: 如果判断根本类型，判断的是 值是否相等。示例: int i=10; double d=10.0;
• ==: 如果判断援用类型，判断的是地址是否相等，即 断定是不是同一个对象

equals: 是 Object 类中的办法，只能判断援用类型，看 Jdk 源码。（办法：光标放在办法上。而后按 ctrl + B 进行查看源码）

• 默认判断的是地址是否相等，子类中往往重写该办法，用于判断内容是否相等。比方 Integer,String【看看 String 和 Integer 的 equals 源代码】

package com.hspedu.object_;

public class Equals01 {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，然而实质上还是一个地址指向 a
        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;
                char v2[] = anotherString.value;
                int i = 0;
                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 A extends B {}

如何重写 equals 办法

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

查看：com.hspedu.object_ EqualsExercise01

hashCode 办法

public int hashCode()

返回该对象的哈希码值。反对此办法是为了进步哈希表（例如java.util.Hashtable 提供的哈希表）的性能。

hashCode 的惯例协定是：

• 在 Java 应用程序执行期间，在对同一对象屡次调用 hashCode 办法时，必须统一地返回雷同的整数，前提是将对象进行 equals 比拟时所用的信息没有被批改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
• 如果依据 equals(Object) 办法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 办法都必须生成雷同的整数后果。
• 如果依据 equals(java.lang.Object))
  办法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 办法 不
  要求肯定生成不同的整数后果。然而，程序员应该意识到，为不相等的对象生成不同整数后果能够进步哈希表的性能。

实际上，由 Object 类定义的 hashCode
办法的确会针对不同的对象返回不同的整数。（这个别是通过将该对象的外部地址转换成一个整数来实现的，然而 JavaTM 编程语言不须要这种实现技巧。）

返回：

此对象的一个哈希码值。

另请参见：

[equals(java.lang.Object)], [Hashtable]

总结

1. 进步具备哈希构造的容器的效率！
2. 两个援用，如果指向的是同一个对象，则哈希值必定是一样的！
3. 两个援用，如果指向的是不同对象，则哈希值是不一样的（当然也可能存在碰撞）
4. 哈希值次要依据地址号来的！不能齐全将哈希值等价于地址。（java 跑在 JVM 上，无奈真正拿到其外部地址）。
5. 前面在汇合，中 hashCode 如果需要的话，也会重写, 在解说汇合时，具体看如何重写 hashCode()代码。

toString 办法

public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

1. 根本介绍
   默认返回：全类名 +@+ 哈希值的十六进制，子类往往重写 toString 办法，用于返回对象的属性信息（全类名就是包名 + 类名）
2. 重写 toString 办法，打印对象或拼接对象时，都会主动调用该对象的 toString 模式.
3. 当间接输入一个对象时，toString 办法会被默认的调用, 比方 System.out.println(monster)；// 就会默认调用 monster.toString()

finalize 办法

1. 当对象被回收时，零碎主动调用该对象的 finalize 办法。子类能够重写该办法，做一些 开释资源（数据库的连贯，关上或者敞开文件）的操作。
2. 什么时候被回收：当某个对象没有任何援用时，则 jvm 就认为这个对象是一个垃圾对象，就会应用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize 办法。（当然并不是一有垃圾就立马回收，有对应的垃圾回收 GC 算法）。
3. 垃圾回收机制的调用，是由零碎来决定(即有本人的 GC 算法), 也能够通过 System.gc() 被动触发垃圾回收机制。
4. 咱们在理论开发中，简直不会使用 finalize , 所以更多就是为了应酬面试。

package com.hspedu.object_;

// 演示 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("开释了某些资源...");
    }
}

断点调试(debug)

在断点调试过程中，是运行状态，是以对象的运行类型来执行的.

A extends B; Bb = new A(); b.xx();

断点调试介绍

断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，而后你能够一步一步往下调试，调试过程中能够看各个变量以后的值，出错的话，调试到出错的代码行即显示谬误，停下。进行剖析从而找到这个 Bug。

断点调试也能帮忙咱们查看 java 底层源代码的执行过程。

断点调试的快捷键

F7(跳入) F8(跳过) shift+F8(跳出) F9(resume, 执行到下一个断点)

F7：跳入办法内

F8: 逐行执行代码.

shift+F8: 跳出办法

Idea debug 进入 Jdk 源码

办法 1：

应用 force step into : 快捷键 alt + shift + F7

办法 2：

这个配置一下就好了：点击 Setting –> Build,Execution,Deployment –> Debugger –> Stepping 把 Do not step into the classes 中的 java.，javax.勾销勾选。

断点能够在 debug 过程中，动静的下断点。（看简单逻辑时罕用）

我的项目 - 零钱通

package com.hspedu.smallchange;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class SmallChangeSys {

    // 化繁为简
    //1. 先实现显示菜单，并能够抉择菜单，给出对应提醒
    //2. 实现零钱透明细
    //3. 实现收益入账
    //4. 生产
    //5. 退出
    //6. 用户输出 4 退出时，给出提醒 "你确定要退出吗? y/n"，必须输出正确的 y /n，否则循环输出指令，直到输出 y 或者 n
    //7. 在收益入账和生产时，判断金额是否正当，并给出相应的提醒
    public static void main(String[] args) {

        // 定义相干的变量
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);
        String key = "";

        //2. 实现零钱透明细
        // 老韩思路, (1) 能够把收益入账和生产，保留到数组 (2) 能够应用对象 (3) 简略的话能够应用 String 拼接
        String details = "----------------- 零钱透明细 ------------------";

        //3. 实现收益入账  实现性能驱动程序员减少新的变动和代码
        // 老韩思路, 定义新的变量
        double money = 0;
        double balance = 0;
        Date date = null; // date 是 java.util.Date 类型，示意日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm"); // 能够用于日期格式化的

        //4. 生产
        // 定义新变量，保留生产的起因
        String note = "";
        do {System.out.println("\n================ 零钱通菜单 ===============");
            System.out.println("\t\t\t1 零钱透明细");
            System.out.println("\t\t\t2 收益入账");
            System.out.println("\t\t\t3 生产");
            System.out.println("\t\t\t4 退     出");

            System.out.print("请抉择(1-4):");
            key = scanner.next();

            // 应用 switch 分支管制
            switch (key) {
                case "1":
                    System.out.println(details);
                    break;
                case "2":
                    System.out.print("收益入账金额:");
                    money = scanner.nextDouble();
                    //money 的值范畴应该校验 -》一会在欠缺
                    // 老师思路, 编程思维
                    // 找出不正确的金额条件，而后给出提醒, 就间接 break
                    if(money <= 0) {System.out.println("收益入账金额 须要 大于 0");
                        break;
                    }
                    // 找出正确金额的条件
                    balance += money;
                    // 拼接收益入账信息到 details
                    date = new Date(); // 获取以后日期
                    details += "\n 收益入账 \t+" + money + "\t" + sdf.format(date) + "\t" + balance;


                    break;
                case "3":
                    System.out.print("生产金额:");
                    money = scanner.nextDouble();
                    //money 的值范畴应该校验 -》一会在欠缺
                    // 找出金额不正确的状况
                    // 过关斩将 校验形式.
                    if(money <= 0 || money > balance) {System.out.println("你的生产金额 应该在 0-" + balance);
                        break;
                    }
                    System.out.print("生产阐明:");
                    note = scanner.next();
                    balance -= money;
                    // 拼接生产信息到 details
                    date = new Date(); // 获取以后日期
                    details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t" + balance;
                    break;
                case "4":
                    // 用户输出 4 退出时，给出提醒 "你确定要退出吗? y/n"，必须输出正确的 y /n，// 否则循环输出指令，直到输出 y 或者 n
                    // 老韩思路剖析
                    // (1) 定义一个变量 choice, 接管用户的输出
                    // (2) 应用 while + break, 来解决接管到的输出时 y 或者 n
                    // (3) 退出 while 后，再判断 choice 是 y 还是 n , 就能够决定是否退出
                    // (4) 倡议一段代码，实现一个小性能，尽量不要混在一起
                    String choice = "";
                    while (true) { // 要求用户必须输出 y /n , 否则就始终循环
                        System.out.println("你确定要退出吗? y/n");
                        choice = scanner.next();
                        if ("y".equals(choice) || "n".equals(choice)) {break;}
                        // 第二个计划
//                        if("y".equals(choice)) {
//                            loop = false;
//                            break;
//                        } else if ("n".equals(choice)) {
//                            break;
//                        }
                    }

                    // 当用户退出 while , 进行判断
                    if (choice.equals("y")) {loop = false;}
                    break;
                default:
                    System.out.println("抉择有误，请从新抉择");
            }

        } while (loop);

        System.out.println("----- 退出了零钱通我的项目 -----");

    }
}

改成 OOP 版本，领会 OOP 编程带来的益处

package com.hspedu.smallchange.oop;

/**
 * 这里咱们间接调用 SmallChangeSysOOP 对象，显示主菜单即可
 */
public class SmallChangeSysApp {public static void main(String[] args) {System.out.println("====hello 公司 ====");
        new SmallChangeSysOOP().mainMenu();
    }
}

package com.hspedu.smallchange.oop;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/**
 * 该类是实现零钱通的各个性能的类
 * 应用 OOP(面向对象编程)
 * 将各个性能对应一个办法.
 */
public class SmallChangeSysOOP {

    // 属性..
    // 定义相干的变量
    boolean loop = true;
    Scanner scanner = new Scanner(System.in);
    String key = "";

    //2. 实现零钱透明细
    // 老韩思路, (1) 能够把收益入账和生产，保留到数组 (2) 能够应用对象 (3) 简略的话能够应用 String 拼接
    String details = "----------------- 零钱透明细 ------------------";

    //3. 实现收益入账  实现性能驱动程序员减少新的变动和代码
    // 老韩思路, 定义新的变量
    double money = 0;
    double balance = 0;
    Date date = null; // date 是 java.util.Date 类型，示意日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm"); // 能够用于日期格式化的

    //4. 生产
    // 定义新变量，保留生产的起因
    String note = "";

    // 先实现显示菜单，并能够抉择
    public void mainMenu() {
        do {System.out.println("\n================ 零钱通菜单(OOP)===============");
            System.out.println("\t\t\t1 零钱透明细");
            System.out.println("\t\t\t2 收益入账");
            System.out.println("\t\t\t3 生产");
            System.out.println("\t\t\t4 退     出");

            System.out.print("请抉择(1-4):");
            key = scanner.next();

            // 应用 switch 分支管制
            switch (key) {
                case "1":
                    this.detail();
                    break;
                case "2":
                    this.income();
                    break;
                case "3":
                    this.pay();
                   break;
                case "4":
                    this.exit();
                    break;
                default:
                    System.out.println("抉择有误，请从新抉择");
            }

        } while (loop);
    }

    // 实现零钱透明细
    public void detail() {System.out.println(details);
    }
    // 实现收益入账
    public void income() {System.out.print("收益入账金额:");
        money = scanner.nextDouble();
        //money 的值范畴应该校验 -》一会在欠缺
        // 老师思路, 编程思维
        // 找出不正确的金额条件，而后给出提醒, 就间接 return
        if(money <= 0) {System.out.println("收益入账金额 须要 大于 0");
            return; // 退出办法，不在执行前面的代码。}
        // 找出正确金额的条件
        balance += money;
        // 拼接收益入账信息到 details
        date = new Date(); // 获取以后日期
        details += "\n 收益入账 \t+" + money + "\t" + sdf.format(date) + "\t" + balance;

    }
    // 生产
    public void pay() {System.out.print("生产金额:");
        money = scanner.nextDouble();
        //money 的值范畴应该校验 -》一会在欠缺
        // 找出金额不正确的状况
        // 过关斩将 校验形式.
        if(money <= 0 || money > balance) {System.out.println("你的生产金额 应该在 0-" + balance);
            return;
        }
        System.out.print("生产阐明:");
        note = scanner.next();
        balance -= money;
        // 拼接生产信息到 details
        date = new Date(); // 获取以后日期
        details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t" + balance;
    }

    // 退出
    public void exit() {
        // 用户输出 4 退出时，给出提醒 "你确定要退出吗? y/n"，必须输出正确的 y /n，// 否则循环输出指令，直到输出 y 或者 n
        // 老韩思路剖析
        // (1) 定义一个变量 choice, 接管用户的输出
        // (2) 应用 while + break, 来解决接管到的输出时 y 或者 n
        // (3) 退出 while 后，再判断 choice 是 y 还是 n , 就能够决定是否退出
        // (4) 倡议一段代码，实现一个小性能，尽量不要混在一起
        String choice = "";
        while (true) { // 要求用户必须输出 y /n , 否则就始终循环
            System.out.println("你确定要退出吗? y/n");
            choice = scanner.next();
            if ("y".equals(choice) || "n".equals(choice)) {break;}
            // 第二个计划
//                        if("y".equals(choice)) {
//                            loop = false;
//                            break;
//                        } else if ("n".equals(choice)) {
//                            break;
//                        }
        }

        // 当用户退出 while , 进行判断
        if (choice.equals("y")) {loop = false;}
    }
}

文章和代码曾经归档至【Github 仓库：https://github.com/timerring/java-tutorial】或者公众号【AIShareLab】回复 java 也可获取。