面向对象拓展贴

news2025/10/31 9:41:47

1. 类和对象的内存分配机制

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.1 分配机制

 Java 内存的结构分析

  1. 栈： 一般存放基本数据类型(局部变量)
  2. 堆： 存放对象(Cat cat , 数组等)
  3. 方法区：常量池(常量，比如字符串)， 类加载信息
  4. 示意图 [Cat (name, age, price)]
     Java 创建对象的流程简单分析
Person p = new Person();
p.name = “jack”;
p.age = 10

说明：

  1. 先加载 Person 类信息(属性和方法信息, 只会加载一次)
  2. 在堆中分配空间, 进行默认初始化(看规则)
  3. 把地址赋给 p , p 就指向对象
  4. 进行指定初始化， 比如 p.name =”jack” p.age = 10

2. 继承

2.1 super、this只能使用在构造方法中

super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)

class Student{
    public Student(){
		
    }
    public Student(int a){
        this(); // 可以 调用无参构造
    }
    public void create(){
        //super(); //错误，super只能在构造方法中调用
    }
}

2.2 继承内存机制

在这里插入图片描述

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 = "大头儿子";
}

补充：
如果一个类的上一级父类有一个属性被private修饰，那么将无法访问该资源，即使这个类的爷爷类有也不能访问

2.3 重写和重载的区别

在这里插入图片描述

2.4 this 和 super的区别

在这里插入图片描述

3. 多态

3.1 细节补充

在这里插入图片描述

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

3.2 动态绑定机制

在这里插入图片描述

package com.hspedu.poly_.dynamic_;

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

4. Object

4.1 equals方法

在这里插入图片描述

package com.hspedu.object_;

public class Equals01 {

    public static void main(String[] args) {
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a == c);//true
        System.out.println(b == c);//true
        B 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 {}

4.2 finalize 方法

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

5. 静态方法（类方法）细节

在这里插入图片描述

package com.hspedu.static_;

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

        D.hi();//ok
        //非静态方法，不能通过类名调用
        //D.say();, 错误，需要先创建对象，再调用
        new D().say();//可以
    }
}
class D {

    private int n1 = 100;
    private static  int n2 = 200;
    public void say() {//非静态方法,普通方法

    }

    public static  void hi() {//静态方法,类方法
        //类方法中不允许使用和对象有关的关键字，
        //比如this和super。普通方法(成员方法)可以。
        //System.out.println(this.n1);
    }

    //类方法(静态方法)中 只能访问 静态变量 或静态方法
    //口诀:静态方法只能访问静态成员.
    public static void hello() {
        System.out.println(n2);
        System.out.println(D.n2);
        //System.out.println(this.n2);不能使用
        hi();//OK
        //say();//错误
    }
    //普通成员方法，既可以访问  非静态成员，也可以访问静态成员
    //小结: 非静态方法可以访问 静态成员和非静态成员
    public void ok() {
        //非静态成员
        System.out.println(n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();

    }
}

5.1 构造方法可以调用静态和非静态资源

class Person {
    private int id;
    private static int total = 0;
    public static int getTotalPerson() {
        //id++;//错误, 注销

        return total;
    }
    public Person() {//构造器
        total++;  //total = 1
        id = total;//id = 1
    }
}
class TestPerson {
    public static void main(String[] args) {
        System.out.println("Number of total is " +Person.getTotalPerson()); //0
        Person p1 = new Person();
        System.out.println( "Number of total is "+ Person.getTotalPerson()); //1
    }
}

5.2 static修饰的方法不可以使用this/super等关键字

class Person { 
    private int id;
    private static int total = 0;
    public static void setTotalPerson(int total){
        // this.total = total;//错误，因为在static方法中，不可以使用this 关键字

        Person.total = total;
    }
    public Person() {//构造器
        total++;
        id = total;
    }
    //编写一个方法，输出total的值
    public static void m() {
        System.out.println("total的值=" + total);
    }
}
class TestPerson {
    public static void main(String[] args) {

        Person.setTotalPerson(3);
        new Person(); //最后 total的值就是4
        Person.m();//看看输出的是不是4
    }
}

小结：
记住两句话
(1) 静态方法，只能访问静态成员
(2) 非静态方法，可以访问所有的成员
(3) 在编写代码时，仍然要遵守访问权限规则

5. 代码块

5.1 细节补充

在这里插入图片描述

package com.hspedu.codeblock_;

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

        //类被加载的情况举例
        //1. 创建对象实例时(new)
        // AA aa = new AA();
        //2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
        // AA aa2 = new AA();
        //3. 使用类的静态成员时(静态属性，静态方法)
        // System.out.println(Cat.n1);

        //static代码块，是在类加载时，执行的，而且只会执行一次.
//        DD dd = new DD();
//        DD dd1 = new DD();

        //普通的代码块，在创建对象实例时，会被隐式的调用。
        // 被创建一次，就会调用一次。
        // 如果只是使用类的静态成员时，普通代码块并不会执行

        System.out.println(DD.n1);//8888, 静态模块块一定会执行

    }
}

class DD {
    public static int n1 = 8888;//静态属性
    //静态代码块
    static {
        System.out.println("DD 的静态代码1被执行...");//
    }
    //普通代码块, 在new 对象时，被调用，而且是每创建一个对象，就调用一次
    //可以这样简单的，理解 普通代码块是构造器的补充
    {
        System.out.println("DD 的普通代码块...");
    }
}

class Animal {
    //静态代码块
    static {
        System.out.println("Animal 的静态代码1被执行...");//
    }
}

class Cat extends Animal {

    public static  int n1 = 999;//静态属性

    //静态代码块
    static {
        System.out.println("Cat 的静态代码1被执行...");//
    }
}

class BB {
    //静态代码块
    static {
        System.out.println("BB 的静态代码1被执行...");//1
    }
}

class AA extends BB {


    //静态代码块
    static {
        System.out.println("AA 的静态代码1被执行...");//2
    }
}

在这里插入图片描述

5.2 静态代码块只能调用静态成员

6. 各方法代码块之间的执行顺序

在这里插入图片描述

package com.hspedu.codeblock_;

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        //老师说明
        //(1) 进行类的加载
        //1.1 先加载 父类 A02 1.2 再加载 B02
        //(2) 创建对象
        //2.1 从子类的构造器开始
        //new B02();//对象

        new C02();
    }
}

class A02 { //父类
    private static int n1 = getVal01();
    static {
        System.out.println("A02的一个静态代码块..");//(2)
    }
    {
        System.out.println("A02的第一个普通代码块..");//(5)
    }
    public int n3 = getVal02();//普通属性的初始化
    public static int getVal01() {
        System.out.println("getVal01");//(1)
        return 10;
    }

    public int getVal02() {
        System.out.println("getVal02");//(6)
        return 10;
    }

    public A02() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化......
        System.out.println("A02的构造器");//(7)
    }

}

class C02 {
    private int n1 = 100;
    private static  int n2 = 200;

    private void m1() {

    }
    private static void m2() {

    }

    static {
        //静态代码块，只能调用静态成员
        //System.out.println(n1);错误
        System.out.println(n2);//ok
        //m1();//错误
        m2();
    }
    {
        //普通代码块，可以使用任意成员
        System.out.println(n1);
        System.out.println(n2);//ok
        m1();
        m2();
    }
}

class B02 extends A02 { //

    private static int n3 = getVal03();

    static {
        System.out.println("B02的一个静态代码块..");//(4)
    }
    public int n5 = getVal04();
    {
        System.out.println("B02的第一个普通代码块..");//(9)
    }

    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }

    public int getVal04() {
        System.out.println("getVal04");//(8)
        return 10;
    }
    //一定要慢慢的去品..
    public B02() {//构造器
        //隐藏了
        //super()
        //普通代码块和普通属性的初始化...
        System.out.println("B02的构造器");//(10)
        // TODO Auto-generated constructor stub
    }
}

7. final细节补充

7.1 final的修饰属性的赋值

在这里插入图片描述

package com.hspedu.final_;

public class FinalDetail01 {
    public static void main(String[] args) {
        CC cc = new CC();

        new EE().cal();
    }
}

class AA {
    /*
    1. 定义时：如 public final double TAX_RATE=0.08;
    2. 在构造器中
    3. 在代码块中
     */
    public final double TAX_RATE = 0.08;//1.定义时赋值
    public final double TAX_RATE2 ;
    public final double TAX_RATE3 ;

    public AA() {//构造器中赋值
        TAX_RATE2 = 1.1;
    }
    {//在代码块赋值
        TAX_RATE3 = 8.8;
    }
}

class BB {
    /*
    如果final修饰的属性是静态的，则初始化的位置只能是
    1 定义时  2 在静态代码块 不能在构造器中赋值。
     */
    public static final double TAX_RATE = 99.9;
    public static final double TAX_RATE2 ;

    static {
        TAX_RATE2 = 3.3;
    }


}

//final类不能继承，但是可以实例化对象
final class CC { }


//如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承
//即，仍然遵守继承的机制.
class DD {
    public final void cal() {
        System.out.println("cal()方法");
    }
}
class EE extends DD { }

7.1 权限修饰符和static修饰的常量不会导致类加载

在这里插入图片描述

package com.hspedu.final_;

public class FinalDetail02 {
    public static void main(String[] args) {
        System.out.println(BBB.num); //10000
        //不会执行静态代码块，因为final和static修饰的常量不会导致类加载

        //包装类,String 是final类，不能被继承

    }
}

//final 和 static 往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理
class BBB {
    public final static  int num = 10000;
    static {
        System.out.println("BBB 静态代码块被执行");
    }
}
final class AAA{
    //一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法
    //public final void cry() {}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/378433.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

安全狗出席2023中国网络和数据安全产业高峰论坛

安全狗出席2023中国网络和数据安全产业高峰论坛

2月23日，由工业和信息化部、四川省人民政府主办的“2023中国网络和数据安全产业高峰论坛”在成都顺利开幕。 作为国内云原生安全领导厂商，安全狗也出席了此次活动。 在此次活动中，“2022年网络安全技术应用试点示范项目授牌仪式”环节引起业…
阅读更多...
TwinCAT3第三方伺服电机——汇川SV660N使用

TwinCAT3第三方伺服电机——汇川SV660N使用

目录 一、第三方伺服在TC3中配置和使用 二、xml文件拷贝 ​编辑 三、IO中扫描伺服 四、工程测试 五、汇川伺服参数设置说明 一、第三方伺服在TC3中配置和使用 在倍福控制系统中使用第三方伺服可以参见本人另一篇博客，有详细教程说明。本文仅仅对SV660N伺服设置…
阅读更多...
表格形式的Sarsa与Q_learning算法

表格形式的Sarsa与Q_learning算法

环境如下： 这是一个简单的环境，绿色方块代表终点，白色方块代表可行点，灰色方块代表陷阱 用Sarsa算法和Q_learning算法训练得到value表格 代码如下： (jupyter notebook上的代码，所以顺序看起来有点儿奇怪) …
阅读更多...
【博学谷学习记录】超强总结，用心分享丨人工智能 Linux常用软件安装 CenOS 7 arm 安装 MySQL8

【博学谷学习记录】超强总结，用心分享丨人工智能 Linux常用软件安装 CenOS 7 arm 安装 MySQL8

目录环境说明虚拟机安装MySQL下载步骤1.卸载系统自带的mariadb-lib2.上传安装包并解压3.按顺序安装4.初始化数据库5.目录授权，否则启动失败6.启动msyql服务7.查看msyql服务的状态8.在/var/log/mysqld.log下查看临时密码9.用临时密码登录到数据库10.执行下列mysql命令…
阅读更多...
给打算转行IC的同学几点建议，来听听工程师怎么说？

给打算转行IC的同学几点建议，来听听工程师怎么说？

“我不是相关专业的，也没什么IC设计的基础，能转IC设计岗吗？” “感觉自己学比较乱，不知道到底怎么学？没有项目经验怎么办？” 每一个想转IC设计岗位的同学都或多或少地遇到过这样的问题，有着找…
阅读更多...
使用 Postman 实现 API 自动化测试

使用 Postman 实现 API 自动化测试

目录：导读 背景介绍 名词解析 使用说明 执行 API 测试 集成 CI 实现 API 自动化测试 写在最后 背景介绍 相信大部分开发人员和测试人员对 postman 都十分熟悉，对于开发人员和测试人员而言，使用 postman 来编写和保存测试用例会是一种比…
阅读更多...
Vuex 状态管理器(vuex安装与配置、state、mutations、actions、getters、module)全解

Vuex 状态管理器(vuex安装与配置、state、mutations、actions、getters、module)全解

文章目录知识点Vuex 的简介Vuex 的安装与配置Vuex 的核心概念核心概念之：State核心概念之：Mutations核心概念之：Actions核心概念之：GettersVuex 规则核心概念之：Module实验总结知识点 Vuex 的简介Vuex 的安装与配置Vu…
阅读更多...
UE实现相机飞行效果CesiumForUnreal之DynamicPawn飞行原理浅析

UE实现相机飞行效果CesiumForUnreal之DynamicPawn飞行原理浅析

文章目录 1.实现目标2.实现过程2.1 FlyTo实现原理与代码2.2 DynamicPawn飞行原理3.参考资料1.实现目标 基于CesiumForUnreal的Dynamic Pawn实现飞行效果GIF动图： 2.实现过程 实现原理较为简单，基于CesiumForUnreal插件中DynamicPawn中的Camera实现相关功能。其中FlyTo直接通…
阅读更多...
人工智能的几个研究方向

人工智能的几个研究方向

人工智能主要研究内容是：分布式人工智能与多智能主体系统、人工思维模型、知识系统、知识发现与数据挖掘、遗传与演化计算、人工生命、人工智能应用等等。 其中热门研究有以下几种。 一、计算机视觉 就包括图像识别，视频识别，具体应用有人…
阅读更多...
接口自动化测试用例详解

接口自动化测试用例详解

phpunit 接口自动化测试系列 Post接口自动化测试用例 Post方式的接口是上传接口，需要对接口头部进行封装，所以没有办法在浏览器下直接调用，但是可以用Curl命令的-d参数传递接口需要的参数。当然我们还以众筹网的登录接口为例，讲…
阅读更多...
Qt 事件机制

Qt 事件机制

【1】事件 事件是可以被控件识别的操作。如按下确定按钮、选择某个单选按钮或复选框。 每种控件有自己可识别的事件，如窗体的加载、单击、双击等事件，编辑框（文本框）的文本改变事件等等。 事件就是用户对窗口上各种组件的操作。…
阅读更多...
速锐得适配北汽EX系列电动汽车CAN总线应用于公务分时租赁

速锐得适配北汽EX系列电动汽车CAN总线应用于公务分时租赁

过去的几年，我们看到整个分时租赁业务出现断崖式下跌，这是我们看到这种市场情况，是必然，也是出乎意料。原本很多融资后的出行公司、大牌的出行服务商的分时租赁业务，受各种影响不得不转型成其他出行服务。例如&#xf…
阅读更多...
图像处理实战--Opencv实现人像迁移

图像处理实战--Opencv实现人像迁移

前言： Hello大家好，我是Dream。 今天来学习一下如何使用Opencv实现人像迁移，欢迎大家一起参与探讨交流~ 本文目录：一、实验要求二、实验环境三、实验原理及操作1.照片准备2.图像增强3.实现美颜功能4.背景虚化5.图像二值化处理6.人…
阅读更多...
C++ 实现pcm 转wav

C++ 实现pcm 转wav

输入音PCM 属性&#xff1a; 16k采样率 16位深 单声道 #include <iostream> #include <vector> #include <fstream> using namespace std; /* wav音频头部格式 */ typedef struct _wave_pcm_hdr { char riff[4]; // "RIFF&…
阅读更多...
接口测试神器——Apifox从安装到使用的详细教程

接口测试神器——Apifox从安装到使用的详细教程

目录 Apifox简介 安装 API文档导入 接口管理 接口设计 接口调试 使用脚本 Mock数据 测试管理 主题设置 总结 重点&#xff1a;配套学习资料和视频教学 Apifox简介 Apifox 的定位是Postman Swagger Mock JMeter&#xff0c;具有API文档管理、API调试、API Mock、…
阅读更多...
2022年“网络安全”赛项山东省菏泽市选拔赛任务书

2022年“网络安全”赛项山东省菏泽市选拔赛任务书

2022年“网络安全”赛项山东省菏泽市选拔赛任务书 任务书 一、竞赛时间 共计3小时。 二、竞赛阶段 竞赛阶段 任务阶段 竞赛任务 竞赛时间 分值 第一阶段单兵模式系统渗透测试 任务一&#xff1a;Apache安全配置 任务二&#xff1a;数据分析-A 任务三&#xff1a;Windows操作系…
阅读更多...
四信5G智慧灯杆落地厦门软件园 赋能园区实现智慧升级

四信5G智慧灯杆落地厦门软件园 赋能园区实现智慧升级

2023年初&#xff0c;四信5G智慧灯杆项目落地厦门市集美软件园三期&#xff0c;实现一杆多能、多杆合一&#xff0c;为园区智慧管理和产业经济数字化高效赋能&#xff0c;打造智慧园区5G智慧灯杆项目标杆。 5G智慧灯杆赋能园区实现智慧升级 园区是城市发展的重要组成部分&#…
阅读更多...
Xiou的个人说明

Xiou的个人说明

小幽&#xff08;Xiou&#xff09;的个人说明书 V1.0 小幽是谁? 周六读书吧推广大使&#xff0c;终身学习爱好者、终身阅读爱好者、硬件工程师、学习成长陪伴伙伴、大学生职业规划答疑解惑者。 拥有【结构化思维】、【执行力】、【超强学习力】、【前瞻】等核心能力。 过往…
阅读更多...
serdes理解

serdes理解

serdes概念 serdes是一种TX并行转串行传输&#xff0c;RX串行转并行的接收的串并转换协议。而且在传输过程中不传输时钟信号&#xff0c;通过从数据信号中恢复时钟。serdes和PHY不是等效的概念。满足serdes协议的有很多不同种类的PHY。Serial RapidlO、FiberChannel (FC)、PCI-…
阅读更多...
Python代码使用PyQt5制作界面并封装

Python代码使用PyQt5制作界面并封装

目录参考链接续&#xff1a;https://blog.csdn.net/yulinxx/article/details/93344163 若要对此程序进行封装&#xff0c;加个界面&#xff0c;然后制作成 EXE&#xff0c; 使用 PyQt5 制作界面&#xff0c;PyInstaller 进行封装成 EXE 可参考&#xff1a; Python制作小软件…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023