当前位置： 首页>编程语言>正文

idea怎么删除java文件中未使用的import idea删除java类

编程语言2024-06-04 20:48:36

java基础–面向对象（中级）

IDEA

  • IDEA介绍
  • idea全称 Intellij IDEA
  • 在业界被公认为最好的java开发工具
  • IDEA是JetBrains公司的产品，总部位于杰克的首都布拉格
  • 除了支持java开发，还支持HTML，css，PHP，mysql，python等
  • IDEA的安装
  • 官网:https://www.jetbrains.com/
  • IDEA下载后，就可以开始安装
  • IDEA的使用
  • Idea的基本介绍和使用
    使用idea创建java项目（project），看看idea是如何使用的，idea是以项目概念，来管理我们的java源码的
  • 设置字体—>菜单 file --> settings
  • 设置字符编码
  • IDEA常用快捷键
  • 删除当前行：ctrl+Y
  • 复制当前行 ctrl+d
  • 移动当前行 ctrl + shift + 上下箭头
  • 补全代码 alt+/
  • 添加注释和取消注释ctrl+/ (第一次是添加注释，第二次是取消指数)
  • 导入需要的包：atl+enter
  • 快速运行程序 ctrl + shift + F10
  • 生成构造方法等 alt+ insert
  • 查看一个类的层级关系 ctrl + H(学习继承后，非常有用)
  • 讲光标放在一个方法上，输入ctrl+b，可以选择定位到哪个类的方法（学习继承后，非常有用）
  • 自己的分配变量名，通过在后面.var 或者 ctrl + alt + V
  • 模板
  • File --> settings --> editor --> live templates -->查看有哪些模板快捷键/可以自己增加模板
  • 模板可以高效的完成开发，提高效率
package com.demo.a;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/19 17:19
 */
public class TemplateDemo {
    //main模板快捷键
    public static void main(String[] args) {
        //sout模板快捷键
        System.out.println("1");

        //fori模板快捷键
    }
}

包

包的三大作用

  1. 区分相同名字的类
  2. 当类很多时，可以很好的管理类（看java API文档）
  3. 控制访问范围

包的基本语法

  1. package 关键字，表示打包
  2. com.demo:表示包名

包的本质分析

  • 实际上就是创建不同的文件夹来保存类文件

包的命名

  1. 命名规则
  1. 只能包含数字、字母、下划线、小圆点.，但不能用数字开头，不能时关键字或保留字
  1. 命名规范
  1. 一般是小写字母+小圆点一般是：com.公司名.项目名.业务模块名
    比如：com.demo.oa.controller
    举例:
    com.demo.user
    com.demo.util
  1. java常用的包
  1. 一个包下，包含很多的类，常用的包有
  1. java.lang.*//lang包是基本包，默认引入，不需要在引入
  2. java.util.*//util包，系统提供的工具包，比如scanner
  3. java.net.*//网络包，网络开发
  4. java.awt. //是做java界面开发，GUI*

访问修饰符

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

  1. 公开级别：public，对外公开
  2. 受保护级别：protected，对子类和同一个包中的类公开
  3. 默认级别：default ，向同一个包的类公开
  4. 私有级别：private，只有类本身可以访问，不对外公开

访问级别

访问控制修饰符

同类

同包

子类

不同包

公开

public

√

√

√

√

受保护

protected

√

√

√

×

默认

default

√

√

×

×

私有

private

√

×

×

×

  1. 使用注意事项
  1. 修饰符可以修饰类中的属性，成员方法以及类
  2. 只有默认的和public才可以修饰类，并遵循上述访问权限的特点
  3. 成员方法的访问规则和属性完全一样
package com.demo.a.b;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/19 18:17
 */
public class A {

    //四个属性，分别使用不同的访问修饰符来修饰
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;

    public void m1() {
        //该方法可以访问四个属性
        System.out.println("n1:" + n1 + "n2:" + n2 + "n3:" + n3 + "n4:" + n4);
    }
}


package com.demo.a.b;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/19 18:21
 */
public class B {
    public void say(){
        A a = new A();
        //在同一个包下，可以访问public ,protected，默认，不能访问private
        System.out.println("n1:" + a.n1);
        System.out.println("n2:" + a.n2);
        System.out.println("n3:" + a.n3);
//        System.out.println("n4:" + a.n4);
    }
}



package com.demo.a.b;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/19 18:20
 */
public class Test {
    public static void main(String[] args) {
        A a = new A();
        a.m1();//n1:100n2:200n3:300n4:400
        B b = new B();
        b.say();
    }
}


package com.demo.a.c.pkg;

import com.demo.a.b.A;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/19 18:25
 */
public class Test {
    public static void main(String[] args) {
        A a = new A();
        //在不同包下，可以访问public修饰的属性或方法
        //不能访问其他修饰符修饰的属性或方法
        System.out.println(a.n1);
    }
}

面向对象的三大特征

  • 基本介绍

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

面向对象–封装

  • 封装介绍

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

  • 封装的理解和好处
  • 隐藏实现细节
  • 可以对数据进行验证，保证安全合理
  • 封装的实现步骤
  • 将属性私有化【不能直接修改属性】
  • 提供一个公共的set方法，用于对属性判断并复制
    public void setXxx(类型 参数名){
    //加入数据验证的业务逻辑
    属性 = 参数名
    }
  • 提供一个公共的get方法，用于获取属性的值
    public XX getXxx(){
    //权限判断
    return xx;
    }
  • 快速入门案例
  • 看一个案例
    不能随便查看人的年龄，工资等隐私。并对设置的年龄进行合理的验证，年龄合理就设置，否则给默认年龄必须在1120，年龄、工资不能直接查看，name的长度在26之间
package com.demo.a.b;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/19 18:41
 */
public class EncapDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("12");
        person.setAge(233);
        person.setSalary(214);
        System.out.println(person.info());
    }
}

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

    //不能随便查看人的年龄，工资等隐私。
    // 并对设置的年龄进行合理的验证，年龄合理就设置，
    // 否则给默认年龄必须在1~120，年龄、工资不能直接查看，name的长度在2~6之间
    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (2 <= name.length() && name.length() <= 6) {
            this.name = name;
        } else {
            System.out.println("名字长度要在2~6之间");
        }
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (1 <= age && age <= 120) {
            this.age = age;
        } else {
            System.out.println("年龄必须在1~120");
        }
    }

    public String info() {
        return "name:" + name + "\t age:" + age + "\t salary:" + salary;
    }
}

面向对象–继承

  • 为什么需要继承

我们编写了两个类：一个是Pupil类（小学生），一个是Graduate(研究生)

问题：两个类的属性和方法有很多是相同的，怎么办

package com.demo.a.b;

/**
 * 小学生->模拟小学生考试的情况
 *
 * @author L.yn
 * @version 1.0
 * @date 2021/12/19 18:56
 */
public class Pupil {

    public String name;
    public int age;
    private double score;

    public void setScore(double score) {
        this.score = score;
    }

    public void testing() {
        System.out.println("小学生：" + name + "  正在考小学数学");
    }

    public void showInfo() {
        System.out.println("小学生：" + name + "  年龄：" + age + "   成绩：" + score);
    }
}



package com.demo.a.b;

/**
 * 大学生类->模拟大学生考试的情况
 *
 * @author L.yn
 * @version 1.0
 * @date 2021/12/19 18:59
 */
public class Graduate {

    public String name;
    public int age;
    private double score;

    public void setScore(double score) {
        this.score = score;
    }

    public void testing() {//和Pupil不一样
        System.out.println("大学生：" + name + "  正在考大学数学");
    }

    public void showInfo() {//和Pupil不一样
        System.out.println("大学生：" + name + "  年龄：" + age + "   成绩：" + score);
    }
}



package com.demo.a.b;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/19 19:01
 */
public class ExtendDemo {
    public static void main(String[] args) {
        //小学生：小明  正在考小学数学
        //小学生：小明  年龄：10   成绩：60.0
        Pupil pupil = new Pupil();
        pupil.age = 10;
        pupil.name = "小明";
        pupil.setScore(60);
        pupil.testing();
        pupil.showInfo();

        //大学生：小红  正在考大学数学
        //大学生：小红  年龄：22   成绩：100.0
        Graduate graduate = new Graduate();
        graduate.age = 22;
        graduate.name = "小红";
        graduate.setScore(100);
        graduate.testing();
        graduate.showInfo();


    }
}
  • 解决方案==>继承（代码复用性）
  • 继承基本介绍

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

  • 继承的基本语法
  • class 子类 extends 父类{}
  • 子类就会自动拥有父类定义的属性和方法
  • 父类又叫超类，基类
  • 子类又叫派生类
  • 继承给编程带来的遍历
  • 代码的复用性提高了
  • 代码的扩展性和维护性提高了
  • 继承的深入讨论/细节问题
  • 子类继承了所有的属性和方法，但是私有属性和方法不能在子类直接访问，要通过公共的方法去访问
  • 子类必须调用父类构造器，完成父类的初始化
  • 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过
  • 如果希望指定去调用父类的某个构造器，则显示的调用一下：super(参数列表)
  • super在使用时，需要放在构造器第一行
  • super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
  • java所有类都是object类的子类，Object时所有类的基类
  • 父类构造器的调用不限于直接父类！将一直往上追溯到object类（顶级父类）
  • 子类最多只能继承一个父类（指直接继承），即java中时单继承机制。
  • 思考：如何让A继承B和C
  • 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系
package com.demo.a.b;

/**
 * 继承的本质分析
 *
 * @author L.yn
 * @version 1.0
 * @date 2021/12/20 20:38
 */
public class ExtendsTheory {
    public static void main(String[] args) {
        /**
         * 内存的布局
         * 一、首先看子类是否有该属性
         * 二、如果子类有这个属性，并且可以访问，则返回信息
         * 三、如果子类没有这个属性，就看父类有没有这个属性（如果父类有该属性，并且可以访问，则返回信息）
         * 四、如果父类没有就按三的规则，继续找上级父类，直到object
         */
        Son son = new Son();
        System.out.println(son.name);
        System.out.println(son.age);
        System.out.println(son.hobby);
    }
}

class GrandPa {
    String name = "a";
    String hobby = "旅游";
}

class Father extends GrandPa {
    String name = "b";
    int age = 39;
}


class Son extends Father {
    String name = "c";
}

super关键字

  • 基本介绍

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

  • 基本语法
  • 访问父类的属性，但不能访问父类的private属性：super.属性名
  • 访问父类的方法，不能访问父类的private方法：super.方法名（参数列表）
  • 访问父类的构造器：super（参数列表）；只能放在构造器的第一句，只能出现一句
/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/20 21:01
 */
public class SuperDemo {

}

class D {
    int age;
    String name;

    public void h() {
        System.out.println("h");
    }
}

class F extends D {
    public void h1() {
        System.out.println(super.age);
        System.out.println(super.name);
        super.h();
    }
}
  • super给编程带来的遍历/细节
  • 调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化）
  • 当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super，如果没有重名，使用super、this、直接访问时一样的效果
  • super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类中都有同名的成员，使用super访问遵循就近原则。A->B->C

No.

区别点

this

super

1

访问属性

访问本类中的属性，如果本类没有此属性则从父类中继续查找

访问父类中的属性

2

调用方法

访问本类中的方法，如果本类中没有此方法则从父类中继续查找

访问父类的方法

3

调用构造器

调用本类构造器，必须放在构造器的首行

调用父类构造器，必须放在子类构造器的首行

4

特殊

表示当前对象

子类中访问父类对象

方法重写/覆盖（override）

  • 基本介绍

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

class D {
    public void h() {
        System.out.println("h");
    }
}

class F extends D {
    //一、因为F是D的子类
    //二、F的h方法和D的h方法定义形式一样（名称、返回类型、参数）
    //三、这时我们就说F的h方法，重写了D的h方法
    public void h(){
        System.out.println(1);
    }
}
  • 注意事项和使用细节

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

  1. 子类的方法的参数，方法名称，要和父类方法的参数，方法名称完全一样
  2. 子类方法的返回类型和父类方法的返回类型一样，或者是父类返回类型的子类，比如父类返回类型是object，子类方法返回的是String
    public Object getInfo(){}
    public String getInfo(){}
  3. 子类方法不能缩小父类方法的访问权限
    public > protected > 默认 > private
    void sayOk(){}
    public void sayOk(){}
对方法的重写和重载做一个比较

名称

发生范围

方法名

参数列表

返回类型

修饰符

重载（overload）

本类

必须一样

类型，个数或者顺序至少有一个不同

无要求

无要求

重写（override）

父子类

必须一样

相同

子类重写的方法返回的类型和父类返回的类型一致，或者是其子类

子类方法不能缩小父类方法的访问范围

面向对象–多态

  • 先看一个问题

请编写一个程序，Master类中有一个feed（喂食）方法，可以完成主人给动物喂食物的信息

package com.lyn.a.poly;

import java.io.File;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/21 19:37
 */
public class Poly01 {
    public static void main(String[] args) {
        Master tom = new Master("tom");
        Dog dog = new Dog("大黄");
        Bone bone = new Bone("骨头");
        tom.feed(dog, bone);

        Cat cat = new Cat("小花猫");
        Fish fish = new Fish("黄花鱼");
        tom.feed(cat, fish);
    }
}


package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/21 19:38
 */
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;
    }
}

package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/21 19:40
 */
public class Fish extends Food {

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

package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/21 19:41
 */
public class Bone extends Food {

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

package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/21 20:04
 */
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;
    }
}


package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/21 20:05
 */
public class Cat extends Animal {

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


package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/21 20:06
 */
public class Dog extends Animal {

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


package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/21 20:06
 */
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;
    }

    //主人给小狗 喂食  骨头
    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方法很多，不利于管理和维护
}

传统的方法带来的问题是什么？如何解决？

问题是：代码的复用性不高，而且不利于代码维护

解决方案：引出多态

  • 多态的基本介绍

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

  • 多态的具体体现
  • 方法的多态：重写和重载就体现多态
package com.lyn.a.poly;

import com.demo.a.b.A;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/21 20:20
 */
public class PolyMethod {
    public static void main(String[] args) {
        //方法重载体现多态
        /**
         * 我们通过不同的参数个数去调用sum方法，就会去调用不同的方法
         * 因此sum方法来说，就是多种状态的体现
         */
        A a = new A();
        a.sum(10, 20);
        a.sum(10, 20, 30);

        /**
         * 根据对象不一样，我们调用的方法不一样
         */
        B b = new B();
        b.say();
        A aa = new A();
        aa.say();
    }
}

class B {//父类

    public void say() {
        System.out.println("B say（） 方法被调用....");
    }
}

class A extends B {
    public int sum(int n1, int n2) {//和下面sum方法构成重载
        return n1 + n2;
    }

    public int sum(int n1, int n2, int n3) {
        return n1 + n2 + n3;
    }

    public void say(){

    }
}
  • 对象的多态（重要的几句话）
  • 一个对象的编译类型和运行类型可以不一致
  • 编译类型在定义对象时，就确定了，不能改变
  • 运行类型是可以变化的
  • 编译类型看定义时 = 号 的左边，运行类型看 = 号的 右边
package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/21 20:36
 */
public class PolyObject {
    public static void main(String[] args) {
        Animal animal = new Dog("1");//animal编译类型是animal，运行类型Dog
        animal = new Cat("2");//animal的运行类型变成cat，编译类型仍是Animal
    }
}
  • 多态注意事项和细节讨论
  • 多态的前提是：两个对象（类）存在继承关系
  • 多态的向上转型
  • 本质：父类的引用指向了子类的对象
  • 语法：父类类型 引用名 = new 子类类型()
  • 特点
  • 编译类型看左边，运行类型看右边。
  • 可以调用父类中的所有成员（需遵守访问权限）
  • 不能调用子类中特有的成员
  • 最终运行效果看子类的具体实现
  • 多态的向下转型
  • 语法：子类类型 引用名 = （子类类型）父类引用
  • 只能强转父类的引用，不能强转父类的对象
  • 要求父类的引用必须指向的是当前目标类型的对象
  • 可以调用子类类型中的成员
class A{
    //编译类型是Cat，运行类型还是Cat
	Animal animal = new Animal();
	Cat cat = (Cat) animal;
}
  • 属性没有重写之说！属性的值看编译类型
  • instanceOf比较操作符，用于判断对象的类型是否为XX类型或XX类型的子类型
class A{
	BB bb = new BB();
	Object o = null;
    //instanceof用于判断某个变量是否为某个类的类型或其子类类型
	System.out.println(bb instanceOf AA)
	System.out.println(O instanceOf AA)
}
  • java的动态绑定机制（非常重要）
  • 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
  • 当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用
package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/22 19:45
 */
public class Dynamic {
    public static void main(String[] args) {
        //a的编译类型是AAA,运行类型是BB
        AAA a = new BB();//向上转型
        System.out.println(a.sum());//40->30
        System.out.println(a.sum1());//30 -> 20
    }
}

class AAA {//父类
    public int i = 10;

    /**
     * 动态绑定机制
     * 一、当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
     * 二、当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用
     *
     * @return
     */
    public int sum() {
        return getI() + 10;
    }

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

    public int getI() {
        return i;
    }
}


class BB extends AAA {//子类
    public int i = 20;

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

    public int getI() {
        return i;
    }

//    public int sum1() {
//        return i + 10;
//    }
}
  • 多态的应用
  • 多态数组：数组的定义类型为父类型，里面保存的实际元素类型为子类类型
    应用实例：现有一个继承结构如下：要求创建一个Person对象，2个Student对象和2个Teacher对象，统一放在数组中，并调用say方法
    应用实例升级：如何调用子类特有的方法，比如：Teacher有一个teach，Student有一个Study，怎么调用
package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/22 20:48
 */
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 "";
    }
}



package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/22 20:50
 */
public class Student extends Person {

    private double score;

    public Student(String name, int age) {
        super(name, age);
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String say(){
        return super.say();
    }
}


package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/22 20:52
 */
public class Teacher extends Person {

    private double salary;

    public Teacher(String name, int age) {
        super(name, age);
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String say() {
        return super.say();
    }
}



package com.lyn.a.poly;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/12/22 20:53
 */
public class PloyArray {
    public static void main(String[] args) {
        //应用实例：现有一个继承结构如下：要求创建一个Person对象，
        // 2个Student对象和2个Teacher对象，统一放在数组中，并调用say方法
        Person[] persons = new Person[5];
        persons[0] = new Person("jack", 20);
        persons[1] = new Student("jack", 20);
        persons[2] = new Student("jack", 20);
        persons[3] = new Teacher("jack", 20);
        persons[4] = new Teacher("jack", 20);
        //循环遍历多态数组，调用say方法
        for (Person person : persons) {
            System.out.println(person.say());//这里会有动态绑定机制

            //判断person运行类型是不是student
            if (person instanceof Student) {
                ((Student) person).study();
            }
            //判断person运行类型是不是teacher
            if (person instanceof Teacher) {
                ((Teacher) person).teach();
            }
        }


    }
}
  • 多态参数
  • 方法定义的形参类型为父类类型，实参类型允许为子类类型
  • 应用实例：前面的主人喂食

Object类详解

equals方法
  • == 和 equals的对比
  • ==：既可以判断基本类型，又可以判断引用类型
  • ==：如果判断基本类型，判断的是值是否相等。示例：int i = 10； double d = 10.0;
  • ==: 如果判断的是引用类型，判断的是地址是否相等，即判定是不是同一个对象
  • equals：是object类中的方法，只能判断引用类型
  • 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等，比如：Integer,String
hashCode方法
  1. 提高具有哈希结构的容器的效率
  2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
  3. 两个引用，如果指向的是不同对象的，则哈希值是不一样的
  4. 哈希值主要根据地址号来的，不能完全将哈希值等价与地址
toString方法
  • 基本介绍

默认返回：全类名+@+哈希值的十六进制，子类往往重写toString方法，用于返回对象属性信息

当直接输出一个对象时，toString方法会被默认调用

finalize方法
  1. 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作
  2. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法
  3. 垃圾回收机制的调用，是由系统来决定，也可以通过System.gc()主动触发垃圾回收机制
  4. 在开发当中，几乎不会运用finalize方法
package com.lyn.b.object;

/**
 * 演示finalize的用法
 *
 * @author L.yn
 * @version 1.0
 * @date 2021/12/23 19:53
 */
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("释放了某些资源");
    }
}

断点调试

  • 一个实际需求
  • 在开发中，新手程序员在查找错误时，这时老程序员就会温馨提示，可以用断点调试，一步一步的看源码执行的过程，从而发现错误所在
  • 重要提示：在断点调试过程中，是运行状态，是以对象的运行类型来执行的
  • 断点调试介绍
  • 断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码行即显示错误，停下。进行分析从而找到这个Bug
  • 断点调试时程序员必须掌握的技能
  • 断点调试也能帮助我们查看java底层源代码的执行过程，提高程序员的水平
  • 断点调试的快捷键
  • F7：跳入方法内
  • F8：逐行执行代码
  • shift + F8 ： 跳出方法
  • F9：resume，执行到下一个断点



https://www.xamrdz.com/lan/5zb1963215.html

相关文章：