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

已于 2022-03-27 15:57:34 修改
阅读量345 收藏
点赞数 1
文章标签： java intellij-idea 开发语言
于 2021-12-22 21:32:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46435451/article/details/122095530
版权

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

      • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t0hFeaMl-1640179852341)(C:\Users\MSI-NB\AppData\Roaming\Typora\typora-user-images\image-20211219164536910.png)]

    • 设置字符编码

      • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lIHMU8UX-1640179817139)(C:\Users\MSI-NB\AppData\Roaming\Typora\typora-user-images\image-20211219165006702.png)]

    • 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. 只能包含数字、字母、下划线、小圆点.，但不能用数字开头，不能时关键字或保留字
  2. 命名规范
    1. 一般是小写字母+小圆点一般是：com.公司名.项目名.业务模块名
      比如：com.demo.oa.controller
      举例:
      com.demo.user
      com.demo.util
  3. 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，只有类本身可以访问，不对外公开

  5. 访问级别访问控制修饰符同类同包子类不同包
    公开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.区别点thissuper
    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，执行到下一个断点
北木楠-
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java中的类为什么只能用public修饰?
weixin_51495453的博客
03-13 2405
首先，类只能使用public修饰是一个伪命题，应该说我们只见到过使用public修饰的类，还有一些类没有访问修饰符，此时访问权限为default。其次，类实际上分为外部类和内部类（inner class），一般的类都是外部类，内部类需要依赖外部类生成，内部类可以用各种访问修饰符修饰。所以问题转化成，为什么不能使用private和protected修饰外部类？ 我们知道，在Java中，访问修饰符可以修饰类、方法、变量和构造方法。 访问权限由高到低有以下4种 类内部 本包 子包 外部包 pub
java源码包---java 源码 大量 实例
04-18
　Java二进制IO类与文件复制操作实例，好像是一本书的例子，源代码有的是独立运行的，与同目录下的其它代码文件互不联系，这些代码面向初级、中级Java程序员。 Java访问权限控制源代码 1个目标文件 摘要:Java源码,...
Java 第一阶段建立编程思想 【面向对象编程（中级部分）】---- 代码
07-22
Java 第一阶段建立编程思想 【面向对象编程（中级部分）】---- 代码
Java中级程序员面试题(重点)
01-16
Java面试题(网上+经历) 该文档包含了大部分常见的Java中级开发面试题 内容: 1.多线程相关知识 2.springboot框架以及一部分设计模式等等 3.包含一些关于mysql经常问的面试题 4.锁的机制和原理以及使用 5.虚拟机知识和垃圾回收机制 文档字数大约1w字左右（没有水分） 都是干货 感谢各位的支持!
Java学习历程之----提升篇（七）
xyl666666的博客
05-31 267
科普知识前言上周我们学习了抽象类，抽象类可以包含常规类能够包含的...
java--继承--引入继承方法--大学生，小学生考试代码，运行截图演示
yiqieanhaowzq的博客
06-28 317
韩顺平教育---java-继承的引入，学生类，以及继承的特点
Java中的访问修饰符
SakuraMG的博客
12-09 196
公开级别：用public修饰，对外公开。受保护级别：用protected修饰，对子类和同一个包中的类公开。默认级别：没有修饰符（default），对同一个包的类公开。私有级别：用private修饰，只有类本身可以访问，不对外公开。修饰符可以用来修饰类中的属性、方法和类。只有default和public才能用来访问类。
数据类型、运算符和表达式
路在前方
07-11 220
实验目的 1. 练习C#中抽象类 2. 练习静态变量 实验内容： 1.构造一个Student类为抽象类，当中要包含抽象函数。(override) 2.构造一个小学生类Pupil继承Student类，并实现父类的抽象函数。 3.构造一个中学生类Junior继承Student类，并实现父类的抽象函数。 4.构造一个大学生类Undergraduate继承Student类，并实现父类的抽象函数。 要求分别统计小学生，中学生，大学生的人数，和学生的总人数（静态变量的用法）。 一、 核心代码： using Syste
Java 第一阶段建立编程思想 【面向对象编程（中级部分）】
在人间负债^
07-22 486
公开级别用public修饰，对外公开受保护级别用protected修饰，对子类和同一个包中的类公开默认级别没有修饰符，向同一个包的类公开私有级别用private修饰，只有类本身可以访问，不对外公开继承可以解决代码复用，让我们的编程更加靠近人类思维。当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。名称、返回类型、参数方法或对象具有多种形态。......
一个java源程序中只能有一个public类，怎么内部类可以用public？
qq_36455412的博客
11-14 945
一个源程序中只能有一个public类，怎么内部类也可以用public
Java的访问级别：public(公共)，protected(保护)，private(私有)
sunling_sz的专栏
05-15 5110
Java的访问级别包含两部分：1）对类的访问级别和 2）对成员访问级别。 对于类的访问级别，关键字可以是public或没有明确的修饰符（包私有）。 对于成员的访问级别，关键字可以是public （公共）， protected（保护） ，package-private包私有（没有明确的修饰符），或private私有 。 下表总结了针对Java各成员的不同修饰符的访问级别。访问级别决定了字段和方法的可访问性。 它有4个层次：public(公共)，protected(保护)，package-pri
Java面向对象学习-适合初级中级高级
10-19
Java面向对象学习-适合初级中级高级
Java职业笔试题-ooprogramming:关于适用于Java和Python语言的面向对象编程的中级课程
06-13
更具体地说，本课程介绍了面向对象编程的基础知识以及 Java 和 Python 的大量标准 API。 学生将学习如何操作复杂的数据结构，从本地文件、数据库、Web 服务读取和写入数据，以及如何构建图形用户界面。 软件、教程、...
第8章 面向对象编程（中级部分）
m0_72671163的博客
08-26 261
Java提供四种访问控制修饰符号，用于控制方法和属性的访问权限：1）public公开级别：对外公开2）protected受保护级别：对子类和同一个包中的类公开3）默认级别：没有修饰符号，向同一个包的类公开4）private私有级别：只有类本身可以访问，不对外公开面向对象编程三大特征：封装、继承和多态封装（encapsulation）就是把抽象的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，程序的其他部分只有通过授权的操作（方法），才能对数据进行操作。.........
包和访问修饰符
m0_68263308的博客
11-09 518
包，访问修饰符
Java访问修饰符
一颗西柚的博客
06-24 182
访问修饰符
JAVA中的访问控制级别
wei_wenxue的博客
09-13 5994
共有四种： public:意思为公有的、公共的。这个访问控制修饰符的访问级别最高。使用这个访问控制修饰符进行修饰的成员，被访问时不受任何限制。 protected：意思为受保护的。使用这个访问控制修饰符进行修饰的成员只能由派生类或统一程序包中的类进行访问。对其他程序包的派生类而言，效果相当于共有的。对于其他程序的非派生类来说，效果相当于私有的。 default：意思为默认的。但是作为访问修饰
set()、get()方法体会Java封装性
zhkey123的博客
11-22 879
set()、get()方法体会Java封装性 题目要求: 1.创建程序，在其中定义两个类：Person和PersonTest类。定义如下： 用setAge()设置人的合法年龄(0~130) 用getAge()返回人的年龄。 2.在1中Person类中添加构造器，利用构造器设置的所有人的age属性初始值为18. 修改上题中类和构造器，增加name属性，使得每次创建Person对象的同时初始化对象的age属性值和name属性值 Person.java public class Person { p
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 140
借助jdeps分析出jar包的增量文件
java中级学习教程
04-11
Java中级学习教程是为那些已经掌握了Java基础知识的学习者准备的。在这个阶段，你将深入了解Java的高级特性和更复杂的编程概念。以下是一个简要的Java中级学习教程的内容概述： 1. 面向对象编程（OOP）：深入理解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北木楠-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值