05.java面向对象中级

5 面向对象中级

5.1 包

5.1.1 包的作用

1、区分相同名字的类

2、当类很多时，可以管理类

3、控制访问范围

5.1.2 包的基本语法

1、package 关键字 表示打包

2、com.java.test：表示包名

5.1.3 包的本质

包的本质就是创建不同的文件夹来保存类文件

5.1.4 包的命名规范

只能包含数字，字母下划线，小圆点，但是数字不能开头，不能是关键字和保留字；公司一般com.公司名.项目名.业务模块名

5.1.5 常用的包

java.lang.* //lang 包是基本包，默认引入，不需要再引入

java.util.* //util 包，系统提供的工具包, 工具类，使用 Scanner

java.net.* //网络包，网络开发

java.awt.* //是做 java 的界面开发，GUI

5.1.6 如何引入包

语法： import 包名

5.1.7 细节说明

package 的作用是声明当前类所在的包，需要放在类(或者文件)的最上面， 一个类中最多只有一句 package；

import 指令 位置放在 package 的下面，在类定义前面,可以有多句且没有顺序要求

5.2 访问修饰符

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

1. 公开级别:用 public 修饰,对外公开
2. 受保护级别:用 protected 修饰,对子类和同一个包中的类公开
3. 默认级别:没有修饰符号,向同一个包的类公开.
4. 私有级别:用 private 修饰,只有类本身可以访问,不对外公开
   

使用的注意事项：

1.修饰符可以用来修饰类中的属性,成员方法和类

2.只有默认的和public才能修饰类,并且遵循上述访问权限的特点

3.因为没有学习继承,因此关于在子类中的访问权限,继承后再讲

4.成员方法的访问规则和属性完全一样

5.3 封装

5.3.1 封装简介

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

好处：1、隐藏实现细节：方法（链接数据库）< -- 调用（传入参数..）;2、可以对数据进行验证，保证合理安全

封装实现的步骤：

1.将属性进行私有化private

2.提供一个公共的set方法,用于对属性判断并赋值，加入数据验证

3.提供一个公共的get方法,用于获取属性的值，加入权限判断

/*入门案例：不能随便查看人的年龄，工资等隐私，并对设置的年龄进行合理的验证。年龄合理就设置，否则给默认年龄, 必须在 1-120，年龄，工资不能直接查看 ， name的长度在 2-6 字符之间*/

public class Encapsulation01 {
    public static void main(String[] args){

        Person person = new Person();
//        person.age = 10; //age访问private失敗
        person.setName("张丹");
        person.setAge(50);
        person.setSalary(500.0);
        System.out.println(person.info());
    }
}

class Person{
    public String name;
    private int age;
    private double salary;

    public void setName(String name){
        // name.length() :  返回字符串长度
        if(name.length() >=2 && name.length() <= 6){
            this.name = name;
        }else {
            System.out.println("name的长度不在 2-6 字符之间,设置默认值无名");
            this.name = "无名";
        }
    }
    public void setAge(int age){
        if(age >=1 && age <= 120){
            this.age = age;
        }else{
            System.out.println("年龄输入不合法(1-120),设置默认值18");
            this.age = 18;
        }
    }
    public void setSalary(double salary){
        this.salary = salary;
    }

    public int getAge(){
        return age;
    }
    public double getSalary(){
        // 这里可以增加权限判断
        return salary;
    }

    // 写一个方法,返回属性信息
    public String info(){

        return "信息为: 名称" + name + ", 年龄: " + getAge() + ", 工资为: " + getSalary();
    }
}

5.3.2 封装结合构造器

// 如果通过构造器就可以跳过验证怎么办呢?

//有三个属性的构造器
public Person(String name, int age, double salary) {
 // this.name = name;
 // this.age = age;
 // this.salary = salary;
 //我们可以将 set 方法写在构造器中，这样仍然可以验证
 setName(name);
 setAge(age);
 setSalary(salary);
}

5.3.3 作业练习

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

5.4 继承

5.4.1 继承的定义

当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法， 所有的子类不需要重新定义这些属性和方法, 只需要通过 extends 来声明继承父类即可

5.4.2 继承的语法

class 子类 extends 父类{

}

5.4.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 的逻辑关系

5.4.4 继承的本质分析

当子类对象创建好后, 建议 查找关系

(1) 首先看子类是否有该属性
(2) 如果子类有这个属性，并且可以访问，则返回信息
(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息..)
(4) 如果父类没有就按照(3)的规则，继续找上级父类，直到 Object...

// 案例说明
/*
测试类
*/
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 = "旅游";
     // public age = 50  注意在子类(father)中就已经找到了私有的age属性,就会报错,不会再访问父类公有的age属性
}

class Father extends GrandPa {//父类
 String name = "大头爸爸";
 private int age = 39;
 public int getAge() {
  return age;
 }
}

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

// 练习题:

/*
编写 Computer 类，包含 CPU、内存、硬盘等属性，getDetails 方法用于返回 Computer 的详细信息
编写 PC 子类，继承 Computer 类，添加特有属性【品牌 brand】
编写 NotePad 子类，继承 Computer 类，添加特有属性【color】
编写 Test 类，在 main 方法中创建 PC 和 NotePad 对象，分别给对象中特有的属性赋值，以及从 Computer 类继承的
属性赋值，并使用方法并打印输出信息
 */
public class Demo03 {
    public static void main(String[] args){

        PC pc = new PC("因特尔", "12G", "1T", "联想");
        System.out.println(pc.infoCpu());
        NotePad notePad = new NotePad("arm", "8G", "500G", "小米");
        System.out.println(notePad.infoNotePad());
    }
}

class Computer{

    private String cpu;
    private String memery;
    private String disk;

    public Computer() {}

    public Computer(String cpu, String memery, String disk) {
        setCpu(cpu);
        setMemery(memery);
        setDisk(disk);
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMemery() {
        return memery;
    }

    public void setMemery(String memery) {
        this.memery = memery;
    }

    public String getDisk() {
        return disk;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    public String getDetails(){
        return "信息: " + getCpu() + " " + getMemery() + " " + getDisk();
    }
}


class PC extends Computer{

    private String brand;

    public PC() {

    }
    public PC(String cpu, String memery, String disk, String brand){
        super(cpu, memery, disk);
        setBrand(brand);
    }
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String infoCpu(){
        return  getDetails() + " " + getBrand();
    }
}



class NotePad extends Computer{

    private String color;

    public NotePad() {

    }
    // 这里可以体现出: 父类文成父类的初始化,子类完成子类的初始化
    public NotePad(String cpu, String memery, String disk, String color){
        super(cpu, memery, disk);
        setColor(color);
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String infoNotePad(){
        return  getDetails() + " " + getColor();
    }
}

5.5 super

5.5.1 super的基本介绍

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

1.访问父类的属性,但是不能访问父类的私有属性: super.属性名

2.访问父类的方法,不能访问父类的private方法: super.方法名(参数列表)

3.super访问父类的构造器: super(形参列表),只能放在构造器的第一句

5.5.2 super的细节

1.调用父类的构造器的好处(分工明确); 父类属性由父类初始化,子类的属性由子类初始化

2.当子类中有和父类的成员(属性和方法)重名时,为了访问父类的成员方法和属性,必须通过super;如果没有重名,使用super/this直接访问是一样的效果

3.super的访问不限于直接父类,如果爷爷类和本类中有相同名的成员(变量+方法),也可以使用super区访问爷爷类的成员; 如果多个基类(上层)中都有相同名的成员,使用super访问遵循就近原则: A -> B -> C(先从第一父类开始找);当然也需要遵守访问权限的相关规则

5.5.3 super与this的比较

序号	区别点	this	super
1	访问属性	访问本类的属性,如果本类没有此属性,则从父类中继续查找	从父类开始查找属性
2	调用方法	访问本类的方法,如果本类中没有次方法,则从父类中继续查找	从父类还是查找方法
3	调用构造器	调用本类的构造器,必须放在构造器的首行	调用父类的构造器,必须放在子类构造器首行
4	特殊	表示当前对象	子类中访问父类对象

5.6 方法重写/覆盖(override)

方法覆盖(重写)就是子类有一个方法,和父类的某个方法的方法名, 返回值类型, 形参列表相同,那么我们就说子类重写了父类的方法;注意 这个父类子类并不指的是一层关系

5.6.1方法重写细节

1.子类的 方法参数, 方法名称,要和父类方法的参数,方法名称完全一样

2.子类方法的返回类型和父类方法的返回类型一样,或者是父类返回类型的子类;比如: 父类的方法返回类型是Object,子类的方法返回类型是String

3.子类方法不能缩小父类方法的权限: public > protected > default > private

5.6.2 方法重写与方法重载的区别

名称	发生范围	方法名	返回类型	修饰符	形参列表
overload	本类中	相同	无要求	无要求	不同(类型,数量,顺序)
override	父子类中	相同	相同或子类	相同或高权限	相同

5.7 多态

5.7.1 多态的引入

引入一个问题:实现主人类喂xx动物吃xx食物

/*
 动物的3个类
*/
public class Animal {

    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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


public class Dog extends Animal{

    public Dog(String name) {
        super(name);
    }
}

public class Dog extends Animal{

    public Dog(String name) {
        super(name);
    }
}

/*
 食物的3个类
*/
public class Food {

    private String name;

    public Food(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

public class Fish extends Food{

    public Fish(String name) {

        super(name);
    }
}

public class Bone extends Food{

    public Bone(String name) {
        super(name);
    }
}

/*
 主人类实现feed();
*/
public class Master {

    private String name;

    public Master(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    // 需求1: 主人给小狗喂食
    public void feed(Dog dog, Fish fish){
        System.out.println("主人" + name + "给" + dog.getName() +  "喂" + fish.getName());
    }

    // 需求2: 主人给小猫喂骨头
    public void feed(Cat cat, Bone bone){
        System.out.println("主人" + name + "给" + cat.getName() +  "喂" + bone.getName());
    }

    // 可以看出 feed方法后面越来越多,都是重载 --- > 引出多态
}

// 测试类
public class poly01 {
    public static void main(String[] args){

        // 需求1
        Dog dog = new Dog("狗");
        Fish fish = new Fish("鱼");

        Master master = new Master("张三");
        master.feed(dog, fish);

        // 需求2
        Cat cat = new Cat("猫");
        Bone bone = new Bone("骨头");
        master.feed(cat, bone);

    }
}

5.7.2 多态的介绍

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

5.7.3 多态的具体体现

1.方法的多态 : 重写和重载

2.对象的多态(核心): 父类的引用指向子类

(1) 一个对象的编译类型和运行类型可以不一致

(2) 编译类型在定义对象时,就确定了,不能改变

(3) 运行类型是可以变化的

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

5.7.4 多态的细节讨论

1.多态的前提: 两个对象(类)存在继承关系

2.多态的向上转型:

(1) 本质: 父类的引用指向子类

(2) 语法: 父类类型 引用名 = new 子类类型();

(3) 特点: 编译类型看左边,运行类型看右边; 可以调用父类中的所有成员(遵循访问权限), 不能调用子类的特有成员(因为在编译阶段,能调用那些成员是通过编译类型来决定的); 最终运行效果看子类的具体实现(按照从子类开始查找方法,规则一致)

3.多态的向下转型

(1) 语法: 子类类型 引用名 = (子类类型)父类的引用

(2) 只能强转父类的引用,不能强转父类的对象

(3) 要求父类的引用必须指向当前目标类型的对象: 简单说就是, 必须是当前运行类型的对象才能进行强转(此时编译不会错,但是运行会报错:ClassCastException)

(4) 向下转型后,就可以调用子类类型中所有的成员

4.属性没有重写的说法,属性的值看编译类型

5.instance of 比较操作符: 用于 判断对象的运行类型是否为XX类型或者XX类型的子类型

// 向上转型,向下转型
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,你好");
 }
}

public class Cat extends Animal {
 public void eat(){//方法重写
  System.out.println("猫吃鱼");
 }
 public void catchMouse(){//Cat 特有方法
  System.out.println("猫抓老鼠");
 }
}

public class Dog extends Animal {//Dog 是 Animal 的子类
}

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)要求父类的引用必须指向的是当前目标类型的对象
        Dog dog = (Dog) animal; //可以吗？
        System.out.println("ok~~");
 }
}

// 属性没有重写的说法,属性的值看编译类型
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: 
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 extendsAA{}//子类

5.7.5 多态练习题

// 1.请说出下面那些是正确的哪些是错误的
public calss PolyExecise01{
    public static void main(String[] args){
        double d = 13.4; // ok
        long l = (long)d; // ok
        System.out.println(l); // 13
        
        int in =5; // ok
        boolean b = (boolean)in; // false
        Object obj = "hello";  // ok  多态向上转型
        String objStr = (String)obj;  // ok 多态向下转型
        System.out.println(objStr); // "hello"
        
        Object objPri = new Integer(5); // ok 向上转型
        String str = (String)objPri; // false
        Integer str1 = (Integer)objPri; // ok 向下转型
    }
}

// 2.编译看结果
class Base{
    int count = 10;
    public void display(){
        System.out.println(this.count);
    }
}

class Sub extends Base{
    int count = 20;
    public void dispaly(){
        System.out.println(this.count);
    }
}

public class PolyExecise02{
    public static void main(String[] args){
        Sub s = new Sub();
        System.out.println(s.count); // 20
        s.display(); // 20
        
        Base b = s;
        System.out.println(b == s); // true 同一个对象地址相同
        System.out.println(b.count); // 10 走编译类型
        b.display(); // 20  这个地方b走的运行类型
    }
}

5.7.6 动态绑定机制(***)

1.当调用对象方法的时候,该方法会和该对象的 内存地址/运行类型绑定

2.当调用对象属性时,没有动态绑定机制,哪里声明,哪里调用

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

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;
    // }
}   

5.7.7 多态的应用1-多态数组

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

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 getName() + "\t" + getAge();
    }
}

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;
    }
 // 重写父类的方法
    public String say(){
        return super.say() + "\t" + getScore();
    }
 // 独有的方法
    public void study(){
        System.out.println("学生" + getName() + "正在学习");
    }
}

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;
    }

    @Override
    public String say() {
        return super.say() + "\t" + getSalary();
    }

    public void teach(){
        System.out.println("老师" + getName() + "正在学习");
    }
}

public class polyArray {
    public static void main(String[] args){

//        应用实例:现有一个继承结构如下：要求创建 1 个 Person 对象、2 个 Student 对象和 2 个 Teacher 对象, 统一放在数组中，并调用每个对象say 方法.

        // 此时可以看出使用多态
        Person[] persons = new Person[5];
        persons[0] = new Person("a", 18);
        persons[1] = new Student("b", 19, 89);
        persons[2] = new Student("c", 20, 90);
        persons[3] = new Teacher("d", 39, 2000);
        persons[4] = new Teacher("e", 40,3000);

        // 循环遍历数组,调用每个对象的say();
        for(int i= 0; i < persons.length; i++){
            // 不管是哪个元素,编译类型都是Person,运行类型是实际情况根据jvm机实现
            System.out.println(persons[i].say() + " "); // 此处就是动态绑定机制
        }

        // 调用子类特有的方法 -- 向下转型
        for(int i= 0; i < persons.length; i++){
            if (persons[i] instanceof Student) {
                Student st = (Student)persons[i];
                st.study();
            }else if(persons[i] instanceof Teacher){
                ((Teacher)persons[i]).teach();
            }else{
                System.out.println("我是人,没有自己的方法");
            }
        }
    }
}

5.7.8 多态的应用2-多态参数

方法定义的形参为父类类型,传递的实参类型允许为子类类型

public class Employee {

    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = 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;
    }

    // 计算年工资的方法
    public double getAnnual(){
        return getSalary() * 12;
    }
}

5.8 Object类

5.8.1 equals()

==:是一个比较运算符

1. ==: 既可以判断基本数据类型,又可以判断引用数据类型
2. ==:如果判断基本数据类型,判断的值是否相等
3. ==:如果判断的是引用数据类型,判断的是地址是否相等,即判定的是不是同一个对象

public class Equals01 {
    public static void main(String[] args) {
        Aa = new A();
        Ab = a;
        Ac = b;
        System.out.println(a == c);//true
        System.out.println(b == c);//true
        B bObj = a;
        System.out.println(bObj == c);//true
    }
}
class B {}
class Aextends B {}

equals方法:

1.equals是Object类中的方法，只能判断引用数据类型

2.equals默认判断的是地址值是否相等，子类中往往重写该方法，用于判断内容是否相等（Integer 、 String）

// 查看equals()源码
// object类
public boolean equals(Object obj) {
        return (this == obj);
    }

// String类重写方法
public boolean equals(Object anObject) {
        if (this == anObject) { //是否是同一个对象
            return true;
        }
        if (anObject instanceof String) { // 运行类型是否是String及其子类
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) { // 如果两个String的长度相等
                char v1[] = value; 
                char v2[] = anotherString.value; // 分别保存至数组
                int i = 0;
                while (n-- != 0) { // 遍历
                    if (v1[i] != v2[i]) // 如果其中一个字符不相等
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

// Integer类重写equals()
public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

// 练习如何重写equals()
package com.java.study10_面向对象中级;
//  判断两个 Person 对象的内容是否相等，如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false。

public class Demo05 {
    public static void main(String[] args){

        Person1 p1 = new Person1("jack", 16, '男');
        Person1 p2 = new Person1("jack", 15, '男');
        String p3 = null;
        if(p2.equals(null)){
            System.out.println("两个人属性相同");
        }else {
            System.out.println("两个人属性不相同");
        }
    }
}


class Person1{

    private String name;
    private int age;
    private char gender;

    public Person1(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(int age) {
        this.age = age;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public boolean equals(Object obj){

        if(this == obj){
            return true;
        }

        if (obj instanceof Person1){
            Person1 p = (Person1)obj; // 向下转型 得到子类独有的属性和方法
            return this.getName().equals(p.getName()) && this.getAge() == p.getAge() && this.getGender() == p.getGender();
        }
        return false;
    }
}

5.8.2 hashCode()

1. 提高具有哈希结构的容器的效率！

2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的！

3. 两个引用，如果指向的是不同对象，则哈希值是不一样的

4. 哈希值主要根据地址号来的！， 不能完全将哈希值等价于地址

5. 后面在集合，中 hashCode 如果需要的话，也会重写, 在讲解集合时，在说如何重写 hashCode()

5.8.3 toString()

// 默认返回：全类名+@+哈希值的十六进制
public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
// 一般会重写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
public String toString() { //重写后，一般是把对象的属性值输出，当然程序员也可以自己定制
return "Monster{" +
"name='" + name + '\'' +
", job='" + job + '\'' +
", sal=" + sal +
'}';
}
    
// 当直接输出一个对象时，toString 方法会被默认的调用
Monster monster = new Monster("小妖怪", "巡山的", 1000);
System.out.println(monster.toString() + " hashcode=" + monster.hashCode());
System.out.println("==当直接输出一个对象时，toString 方法会被默认的调用==");
System.out.println(monster); //等价 monster.toString()

5.8.4 finalize()

1. 当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作

2. 什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize 方法

3. 垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制

5.9 断点调试

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

F7：跳入方法内

F8: 逐行执行代码.

shift+F8: 跳出方法

执行到下一个断点 F9 resume; 断点可以在 debug 过程中，动态的下断点

5.10 零钱通小项目

package com.java.study10_面向对象中级.project;
import java.text.SimpleDateFormat;
import java.util.Scanner;
import java.util.Date;


public class SmallChangeSys {
    public static void main(String[] args){

        Scanner sc =new Scanner(System.in);
        boolean isFlag = true;
        double money = 0; // 金额
        double balance = 0; // 余额
        String details = ""; // 详情
        do{
            System.out.println("--------零钱通菜单--------");
            System.out.println("\t1 零钱通明细");
            System.out.println("\t2 收益入账");
            System.out.println("\t3 消费");
            System.out.println("\t4 退     出");
            System.out.print("请选择(1-4): ");
            int inputText = sc.nextInt();

            switch(inputText){
                case 1 :
                    System.out.println("--------零钱通明细--------");
                    System.out.println(details);
                    break;
                case 2 :
                    System.out.println("请输入你的收益金额: ");
                    money = sc.nextDouble();
                    // 但是这样的写法不好,直接反判断更加清晰
//                   if(money > 0 && money < 10000){
//                       Date date = new Date();
//                       SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
//                       String nowTime = simpleDateFormat.format(date);
//                    System.out.println(nowTime);
//                       balance += money;
//                        details += "收益入账\t+" + money + "\t" + nowTime + "\t余额:" + balance + "\n";
//                        break;
//                    }else {
//                        System.out.println("输入金额不合理,范围(0-10000)");
//                       break;
//                   }
                    
                    // 这样没有那么多if else 更清晰
                    if(money < 0){
                        System.out.println("输入金额不合理,范围(0-10000)");
                        break;
                    }
                    Date date = new Date();
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                    String nowTime = simpleDateFormat.format(date);
                    System.out.println(nowTime);
                    balance += money;
                    details += "收益入账\t+" + money + "\t" + nowTime + "\t余额:" + balance + "\n";
                    break;
                case 3 :
                    System.out.println("请输入你的消费地址: ");
                    String address = sc.next();
                    System.out.println("请输入你的消费金额: ");
                    money = sc.nextDouble();
                    if( money <= 0 || money > balance){
                        System.out.println("消费金额在0-" + balance + "之间");
                        break;
                    }
                        Date date1 = new Date(); // 获取当前时间
                        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm"); // 用于日期格式化
                        String nowTime1 = simpleDateFormat1.format(date1);
//                    System.out.println(nowTime);
                        balance -= money;
                        details += address + "\t-" + money + "\t" + nowTime1 + "\t余额:" + balance + "\n";
                        break;
                case 4 :
                    char select; // 接收用户输入
                    for(;;) {
                        System.out.println("你确定要退出吗?y/n"); 
                        select = sc.next().charAt(0);
                        if (select == 'y' || select == 'n'){ // 只有等到y/n才退出循环
                            break;
                        }
                    }
                    // 当用户退出循环后,再判断是y/n?
                    if(select == 'y'){
                        isFlag = false;
                    }
                    break;
                default:
                    System.out.println("选择有误请重新输入!");

            }

        }while(isFlag);
    }
}

5.11章节练习

1.定义一个Persons类{name, age, job},初始化Person对象数组,有3个person对象,并按照age从大到小进行排序,提示:使用冒泡排序

2.编写老师类,要求:

1. 要求有属性"姓名 name", "年龄 age", "职称 post", "接班工资salary";
2. 编写业务方法,introduce(),实现输出一个教师的信息
3. 编写教师类的三个子类: 教授类(Professor),副教授类,讲师类,工资级别分别为"教授1.3,副教授1.2,讲师1.1;在三个子类中都重写父类的introduce();
4. 定义初始化一个老师对象,调用业务方法,实现对象基本信息的后台打印

3.通过继承实现员工工资核算打印功能:
父类 : 员工类(Employee)
子类 : 部门经理类(Manager), 普通员工类(Worker)

1. 部门经理工资 = 1000 + 单日工资 天数 等级(1.2) ==> 奖金 + 基本工资
2. 普通员工工资 = 单日工资 天数 等级(1.0) ==> 基本工资
3. 员工属性: 姓名 ,单日工资, 工作天数
4. 员工方法: (打印工资)
5. 普通员工及部门经理都是员工子类,需要重写打印工资方法
6. 定义初始化普通员工对象,调用打印工资方法输出工资,定义并初始化部门经理对象,调用打印工资方法输出工资

4.设计父类 - 员工类,子类:工人类(Worker),农民(Peasant), 教师类(Teacher),科学家类(Scientist),服务生类(Waiter)
其中工人,农民,服务生只有基本工资 sal
教师除基本工资外还有课酬(元/天) classDay, classSal
科学家除基本工资外还有年终奖 bonus
编写一个测试类,将各个类型的员工的全年工资打印出来

5.设计一个Point类,其x和y坐标可以通过构造器提供,提供一个子类LabeledPoint,其构造器接受一个标签值和x,y坐标,比如:
new LabelPoint("Blank", 1929, 230.37);

6.编写Doctor类{name, age, job, gender, sal}
相应的get,set方法,5个参数的构造器,重写父类对象(Object)的equals方法
public boolean equals(Object obj),并判断测试类中创建的两个对象是否相等