java--面向对象编程(中级部分)

IDE(集成开发环境)

java-----IDE(集成开发环境)-CSDN博客

包的三大作用

  • 区分相同名字的类

  • 当类很多时,可以很好的管理类[看Java API 文档]

  • 控制访问范围

包基本语

java 复制代码
package com.hsppedu;
说明:
1. package 关键字,表示打包
2. com.haspedu:表示包名

包的本质分析(原理)

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

示例

java 复制代码
package com.use;

import com.xiaoqiang.Dog;

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog();
        System.out.println(dog);
        com.xiaoming.Dog dog1=new com.xiaoming.Dog(); 
    }
}

包的命名

命名规则:只能包含数字,字母,下划线,小圆点,但不能数字开头,不能是关键字或保留字

命名规范

一般是小写字母+小圆点

com.公司名.项目名.业务模块名

常用的包

  • java.lang.* lang包是基本包,默认引入,不需要再引入
  • java.util.* util包系统提供的工具包,工具类,使用Scanner
  • java.net.* 网络包,网络开发
  • java.awt.*是做Java界面开发GUI

如何引入包

语法:import 包

引入包主要是使用该包下面的类

可以只引入某个包下面的一个类,也可以引入某个包下面所有的类

例如:import java.util.Scanner 和 import java.util.*

注意事项和使用细节

1.package的作用是声明当前类所在的包,需要放在类的最上面,一个类中最多只有语句package

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

访问修饰符

基本介绍

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

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

四种访问修饰符的访问范围

java 复制代码
public       公有的   当前工程的任意位置访问 
protected    保护的   本类   同包   子类 
默认不写      默认的   本类   同包
private      私有的   本类

使用的注意事项

  • 1.修饰符可以用来修饰类以及类中的属性,成员方法
  • 2.只有默认的和public才可以修饰类
  • 3.成员方法的访问规则和属性完全一样

面向对象编程三大特征

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

面向对象编程-封装

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

封装的理解和好处

1.隐藏实现细节,方法(连接数据库) < --调用(传入参数..)

2.可以对数据进行验证,保证安全合理

封装的实现步骤 (三步)

  • 1.将属性私有化(不能直接修改属性)
  • 2.提供一个公共的set方法,用于对属性判断并赋值(加入数据验证的业务逻辑)
  • 3.提供哦那个一个公共的get方法,用于获取属性的值
java 复制代码
public void setXXX(类型,参数名){
//加入数据验证的业务逻辑
属性=参数名;
}
public 数据类型 getXXX(){
//权限判断
return XX;
}

面向对象编程-继承

继承基本介绍和示意图

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

继承的基本语法

java 复制代码
class 子类 extends 父类{
}
  • 1.子类就会自动拥有父类定义的属性和方法
  • 2.父类又叫基类,超类
  • 3.子类又叫派生类

继承给编程带来的便利

  • 1)代码的复用性提高了
  • 2)代码的扩展性和维护性提高了

继承的深入讨论/细节问题

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

继承的本质分析**(重要)**

java 复制代码
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 = "大头儿子";
}

按照查找关系返回信息

1.首先查看子类是否有该属性

2.如果子类有这个属性,并且可以访问,则返回信息

3.如果子类没有这个属性。就看父类有没有这个属性(如果父类有该属性,并且可以访问,就返回信息)

4.如果父类没有就继续赵上一级父类,直到Object

super关键字

基本介绍

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

基本语法

  • 1.访问父类的属性,单不能访问父类的private属性:super.属性
  • 2.访问父类的方法,但不能访问父类发private方法:super.方法
  • 3.访问父类的构造器:super(参数列表)
    只能放在构造器的第一句,只能出现那一句,只能再构造器中调用,不能与this语句同时使用

使用细节

  • 1.调用父类构造器的好处:分工明确,父类的属性由父类初始化,子类的属性由子类初始化
  • 2.当子类中有和父类中的成员重名时,未来访问父类的成员,必须通过super,如果没有重名,使用super,this,直接访问都是一样的
  • 3.super的访问不限于直接父类,如果爷爷类和奔雷中有同名的成员,有可以用super去访问爷爷类的成员,如果多个基类中都有同名的成员,使用super访问遵循就近原则

super 和 this 的比较

方法重写/覆盖(override)

基本介绍:方法覆盖就是子类有一个方法和父类的莫格方法的名称,返回类,参数一模一样,我们就说子类的中国方法覆盖率父类的方法

需要满足的条件

  • 1.子类的方法的参数,方法名称,要和父类方法的参数,方法名称玩去哪一样
  • 2.子类方法的返回类型和父类方法的返回类型一样,或者是父类返回类型的子类,比如:父类的返回类型是Object,子类方法的返回类型但是String
  • 3.子类方法不能缩小父类方法的访问权限

方法重写和方法重载的区别

面向对象编程-多态

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

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

具体体现

1.方法的多态

  • 重写和重载就体现多态
  • 重载:通过传入不同的参数调用同名的不同的方法,对于该方法来说就是多种状态的体现
  • 重写:根据不同的对象调用同名的不同的方法,对于该方法来说就是多种状态的体现

2.对象的多态

  • 一个对象的编译类型和运行类型可以不一致{父类的引用可以指向子类的对象)
  • 编译类型在定义对象时就确定了,不能改变
  • 运行类型是可以变化的
  • 编译类型看定义时=号的左边,运行类型看=号的右边

多态快速入门案例

使用多态的机制来解决主人喂食物的问题

java 复制代码
package com.hspedu.poly_;

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

        Master tom = new Master("汤姆");
        Dog dog = new Dog("大黄~");
        Bone bone = new Bone("大棒骨~");
        tom.feed(dog, bone);

        Cat cat = new Cat("小花猫~");
        Fish fish = new Fish("黄花鱼~");
        System.out.println("===========-------");
        tom.feed(cat, fish);

        //添加 给小猪为米饭
        Pig pig = new Pig("小花猪");
        Rice rice = new Rice("米饭");
        System.out.println("===================");
        tom.feed(pig, rice);
    }
}
java 复制代码
package com.hspedu.poly_;

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;
    }
}
java 复制代码
package com.hspedu.poly_;

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
}
java 复制代码
package com.hspedu.poly_;

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
}
java 复制代码
package com.hspedu.poly_;

public class Pig extends Animal {
    public Pig(String name) {
        super(name);
    }
}
java 复制代码
package com.hspedu.poly_;

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;
    }
}
java 复制代码
package com.hspedu.poly_;

public class Bone extends Food {
    public Bone(String name) {
        super(name);
    }
}
java 复制代码
package com.hspedu.poly_;

public class Fish extends Food {
    public Fish(String name) {
        super(name);
    }
}
java 复制代码
package com.hspedu.poly_;

public class Rice extends Food {
    public Rice(String name) {
        super(name);
    }
}
java 复制代码
package com.hspedu.poly_;

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

    //使用多态机制,可以统一的管理主人喂食的问题
    //animal 编译类型是Animal,可以指向(接收) Animal子类的对象
    //food 编译类型是Food ,可以指向(接收) Food子类的对象
    public void feed(Animal animal, Food food) {
        System.out.println("主人 " + name + " 给 " + animal.getName() + " 吃 " + food.getName());
    }

    //主人给小狗 喂食 骨头
//    public void feed(Dog dog, Bone bone) {
//        System.out.println("主人 " + name + " 给 " + dog.getName() + " 吃 " + bone.getName());
//    }
//    //主人给 小猫喂 黄花鱼
//    public void feed(Cat cat, Fish fish) {
//        System.out.println("主人 " + name + " 给 " + cat.getName() + " 吃 " + fish.getName());
//    }

    //如果动物很多,食物很多
    //===> feed 方法很多,不利于管理和维护
    //Pig --> Rice
    //Tiger ---> meat ...
    //...

}

多态注意事项和细节讨论

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

多态的向上转型
  • 1.本质: 父类引用指向了子类的对象
  • 2.语法:父类类型 引用名=new 子类类型()
  • 3.特点:编译类型看左边,运行类型看右边
    可以调用父类中的所有成员(需要遵守访问权限)
    不能调用子类中的特有成员(因为在编译阶段,能调用哪些成员,是由编译类型决定的
    最终运行效果看子类的具体实现,运行是关心运行类型,不关心编译类型
    调用运行的方法遵循就近原则,先从运行时的子类类型开始查找,未能找到时逐级向父类递增
多态向下转型
  • 1.语法:子类类型 引用名=(子类类型)父类引用
  • 2.只能强转父类的引用,不能强转父类的对象
  • 3.要求父类的引用必须指向的是当前目标类型的对象
  • 4.当向下转型后,可以调用子类类型中的所有成员

代码示例

java 复制代码
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)要求父类的引用必须指向的是当前目标类型的对象
        Dog dog = (Dog) animal; //可以吗?

        System.out.println("ok~~");
    }
}
java 复制代码
package com.hspedu.poly_.detail_;

public class Animal {
    String name = "动物";
    int age = 10;
    public void sleep(){
        System.out.println("睡");
    }
    public void run(){
        System.out.println("跑");
    }
    public void eat(){
        System.out.println("吃");
    }
    public void show(){
        System.out.println("hello,你好");
    }

}
java 复制代码
package com.hspedu.poly_.detail_;

public class Cat extends Animal {
    public void eat(){//方法重写
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){//Cat特有方法
        System.out.println("猫抓老鼠");
    }
}
java 复制代码
package com.hspedu.poly_.detail_;

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

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

java 复制代码
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类型的子类型

java 复制代码
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);
        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 {}//子类

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

Java 重要特性: 动态绑定机制

  • 1.当调用对象方法的时候,该方法会对该对象的内存地址/运行类型进行绑定
  • 2.当调用对象属性时,没有动态绑定机制,哪里声明,哪里使用

多态的应用

多态数组

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

调用各元素的特有方法时,借助instanceOf判断类型后进行向下转型

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

代码

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("你的类型有误, 请自己检查...");
            }

        }

    }
}
java 复制代码
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;
    }
}
java 复制代码
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...");
    }
}
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课程...");
    }
}
多态参数

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

Object类详解

object类是类层次结构的根类,每个类都使用object作为超类,所有对象(包括数组)都要实现这个类的方法

equals方法

==和equals的对比[面试题]

==是一个比较运算符

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

equals是Object类中的方法

  • 1**.**只能判断引用类型
  • 2.默认判断的是地址是否相等,子类中往往重写该方法,用于判断内容是否相等
java 复制代码
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 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。

java 复制代码
package com.hspedu.object_;

public class EqualsExercise01 {
    public static void main(String[] args) {
        Person person1 = new Person("jack", 10, '男');
        Person person2 = new Person("jack", 20, '男');

        System.out.println(person1.equals(person2));//假
    }
}
//判断两个Person对象的内容是否相等,
//如果两个Person对象的各个属性值都一样,则返回true,反之false
class Person{ //extends Object
    private String name;
    private int age;
    private char gender;

    //重写Object 的 equals方法
    public boolean equals(Object obj) {
        //判断如果比较的两个对象是同一个对象,则直接返回true
        if(this == obj) {
            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(int age) {
        this.age = age;
    }

    public char getGender() {
        return gender;
    }

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

}

hashCode 方法

hashCode方法返回对象的哈希码值,该方法是为了提高哈希表的性能

作用

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

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

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

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

5.集合中的hashCode根据需要可以进行重写

java 复制代码
package com.hspedu.object_;

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

toString方法

基本介绍

  • toString方法返回对象的字符串表示
    默认返回:全类名(包名+类名getClass().getName())+@+哈希值的十六进制
  • 子类往往会重写toString方法,用于返回对象的属性信息
    重写toString方法,打印对象或拼接对象时,会自动调用该对象的toString形式
  • 当直接输出一个对象时,toString方法会被默认调用

System.out.println(monster);//等价于调用monster.toString();

java 复制代码
package com.hspedu.object_;

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
    public String toString() { //重写后,一般是把对象的属性值输出,当然程序员也可以自己定制
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                '}';
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("fin..");
    }
}

finalize方法

当垃圾回收期确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法

  • 1.当对象被回收时,系统会自动调用该方法的finalize方法,子类考研重写该方法,做一些释放资源,数据库连接,打开文件的操作
  • 2.什么时候被回收:当某个对象没有任何引用时,jvm就认为这个对象是一个垃圾对象,就会使用回收机制来销毁该对象,在销毁该对象前,会先调用finalize方法
  • 3.垃圾回收机制的调用,是由系统来决定的,即有自己的GC,也可以通过System.gc()触发垃圾回收机制
java 复制代码
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("释放了某些资源...");

    }
}
相关推荐
捕鲸叉8 分钟前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer13 分钟前
【C++】vector 类深度解析:探索动态数组的奥秘
开发语言·c++·算法
Peter_chq15 分钟前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
Yaml438 分钟前
Spring Boot 与 Vue 共筑二手书籍交易卓越平台
java·spring boot·后端·mysql·spring·vue·二手书籍
小小小妮子~39 分钟前
Spring Boot详解:从入门到精通
java·spring boot·后端
hong16168841 分钟前
Spring Boot中实现多数据源连接和切换的方案
java·spring boot·后端
aloha_7891 小时前
从零记录搭建一个干净的mybatis环境
java·笔记·spring·spring cloud·maven·mybatis·springboot
记录成长java2 小时前
ServletContext,Cookie,HttpSession的使用
java·开发语言·servlet
前端青山2 小时前
Node.js-增强 API 安全性和性能优化
开发语言·前端·javascript·性能优化·前端框架·node.js
睡觉谁叫~~~2 小时前
一文解秘Rust如何与Java互操作
java·开发语言·后端·rust