CBG2105--Day06--笔记

最新推荐文章于 2024-09-14 21:48:00 发布
最新推荐文章于 2024-09-14 21:48:00 发布
阅读量224 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XHH_3344/article/details/121024957
版权

1 面向对象

1.1 概念

面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。
面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。

1.1.1 面向对象和面向过程区分

面向对象：面向对象则是把构成问题的事务按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。
比如：做好的饭，中间不管是谁把饭做好都能吃的找饭（简单说就是跳过执行的步骤直接得到结果）

面向过程：面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候依次调用就可以了。
例如：把大象放进冰箱

  1. 先把冰箱门打开
  2. 把大象放进去
  3. 关上冰箱门

1.2 面向对象的三大特征

1.2.1 封装

封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节将相关的数据封装成一个“类”组件

1.2.2 继承

继承主要描述的就是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。

1.2.3 多态

多态指的是在一个类中定义的属性和功能被其他类继承后，当把子类对象直接赋值给父类引用变量时，相同引用类型的变量调用同一个方法所呈现出的多种不同行为特性。

2 类和对象

2.1 类

  1. Java语言最基本单位就是类，类似于类型。
  2. 类是一类事物的抽象。
  3. 可以理解为模板或者设计图纸。
    抽象概念：类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。

2.2 对象

每个对象具有三个特点：对象的状态，对象的行为和对象的标识。

  1. 对象的状态用来描述对象的基本特征。
  2. 对象的行为用来描述对象的功能。
  3. 对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来。
  4. 类是一类事物的抽象，对象是具体的实现。

2.3 类与对象的关系

在这里插入图片描述
分析：可以将上图人看作是一个类，将每个具体的人（如小韩、小石等）看作对象，从人与具体个人之间的关系便可以看出类与对象之间的关系。

说明：类用于描述多个对象的共同特征，它是对象的模板，而对象用于描述现实中的个体，它是类的实例。对象是类的具体化，并且一个类可以对应多个对象

2.3.1 面向对象案例练习

public class TestCreateClass {
    public static void main(String[] args) {
        /**
         * 通过new关键创建对应类的对象，
         * 通过.来使用对象的资源
         */
        Phone p = new Phone();
        p.call();
        p.message();
        p.video();

        System.out.println(p.brand);
        System.out.println(p.color);
        System.out.println(p.size);
        System.out.println(p.price);

        System.out.println("************************************");

        Phone p2 = new Phone();
        p2.brand = "华为";
        p2.color = "玫瑰金";
        p2.size = 5.6;
        p2.price = 4999.99;

        System.out.println(p2.brand);
        System.out.println(p2.color);
        System.out.println(p2.size);
        System.out.println(p2.price);
        p2.call();
        p2.message();
        p2.message();
    }
}

/**封装：将一类事物的特征与行为封装成一个类组件*/
class Phone {
    // 1、定义手机特点
    /** 属性：通过成员变量来描述 */
    String brand; // 品牌
    String color; // 颜色
    double size; // 尺寸
    double price; // 价格

    // 2、定义手机功能
    /** 通过方法来描述 */
    public void call() {
        System.out.println("假装正在打电话....");
    }

    public void message() {
        System.out.println("假装正在发短信");
    }

    public void video() {
        System.out.println("真的在看直播");
    }
}

3 对象在内存中的存储

Java把内存分成5大区域，我们重点关注栈和堆。

  1. 一般来讲局部变量存在栈中，方法执行完毕内存就被释放
  2. 对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
  3. 每个堆内存的元素都有地址值
  4. 对象中的属性都是有默认值的
    TIPS: 栈与队列指的是一种数据的结构。
    栈：先进后出（FILO – First In Last Out）
    队列：先进先出（FIFO – First In First Out）
    在这里插入图片描述

3.1 封装

3.1.1 概述

封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节将相关的数据封装成一个“类”组件
作用：

  1. 提高安全性
  2. 提高重用性

3.1.2 private关键字

private（当前类访问级别）：如果类的成员被private访问控制符来修饰，则这个成员只能被该类的其他成员访问，其他类无法直接访问。类的良好封装就是通过private关键字来实现的。可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问

3.1.3 分装案例练习1

package cn.tedu.oop;
/*本类用于测试封装的必要性*/
public class TestPrivate1 {
    public static void main(String[] args) {
        //5.创建对象进行测试
        User u = new User();
        u.name = "西门庆";
        System.out.println(u.name);
        //需要封装属性，如果不封装的话，就可以直接修改属性的值
        //不需要按照我们预先设置好的方式也能操作
        //u.money = 1000000;
        //System.out.println(u.money);
        u.setMoney(109999);
        System.out.println(u.queryMoney());

    }
}
//1.创建一个用户类User
class User{
    //2.定义用户类的属性
    public String name;
    private double money = 10000;

    //3.提供方法1:可以用来查询当前账户的余额
    public double queryMoney(){
        /*后续可以添加权限的校验*/
        return money;
    }
    //4.提供方法2：可以设置当前账户的余额
    public void setMoney(double money){
        /*后续可以添加权限的校验*/
        this.money = money;
    }
}

3.1.4 封装案例练习2

/**
 * 1、在java文件中可以创建对个class，但是被public修饰的类只能创建一个
 * 并且这个java文件的名字必须以此公共类的名字一致
 */

/**
 * 总结：
 *     1、属性的封装：使用private关键字-- 提供了公共的get、set方法，提供了外界获取/设置属性值
 *     2、方法的封装：使用private关键字-- 在本类的公共方法里调用这个私有方法
 */
public class TestPrivate {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "紫霞";
        s.sno = 5;
        //s.subject = "政治";
        System.out.println(s.name);
        System.out.println(s.sno);
        //System.out.println(s.subject);
        //s.eat();
        s.study();
        s.setSubject("JAVA大数据");
        System.out.println(s.getSubject());
    }
}

/**
 * 2、我们可以把一类事物的属性，功能封装到一个类组件中
 */
class Student {
    /**
     * 3、前提：为了提高程序的安全性以及调用要按照我们指定的方式来调用
     * 说以我们可以封装自定义类中的属性与方法
     */
    String name;
    int sno;
    /**
     * 4.1、封装属性：通过private关键字进行封装
     * 被private修饰的资源只能在本类中使用
     */
    private String subject;

    /**
     * 4.2、添加被封装属性的get、set，方法也就是对外提供公共属性值获取/设置方法
     */
    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public void study() {
        System.out.println("假装在学C");
        /**
         * 5.2：在本类的公共方法里访问私有方法的功能
         */
        eat();
    }

    /**
     * 5.1：方法的封装：将方法的访问权限修改为private
     */
    private void eat() {
        System.out.println("正在干饭");
    }
}

说明：如何访问被private
我们可以使用private关键字来封装成员变量与方法
关于成员变量方法访问：

  1. setXxx – 对外提供公共的设置值方式
  2. getXxx – 对外提供公共的获取值方式
    关于成员方法:
    把私有方法放在公共方法里供外界调用即可

4 构造方法

4.1 概念

构造方法是一种特殊的方法,它是一个与类同名且没有返回值类型的方法
构造方法的主要功能就是完成对象创建或者初始化
当类创建对象(实例化)时,就会自动调用构造方法
构造方法与普通方法一样也可以重载.

4.2 形式

与类同名,且没有返回值类型,可以含参也可以不含参
在这里插入图片描述

4.2.1 构造方法案例

public class TestConstructor {
    public static void main(String[] args) {
        /**
         * 1、一个类会默认存在无参构造，每次实例化对象时都会自动调用构造方法
         */
        Person p = new Person();
        Person p2 = new Person("孙行者");
        Person p3 = new Person("孙行者",800,"五行山B1");
        System.out.println(p.name);
        p.eat();
        System.out.println(p3.name);
        System.out.println(p3.age);
        System.out.println(p3.address);
    }
}

class Person {
    String name;//姓名
    int age;//年龄
    String address;//地址

    /**
     * 2、构造方法格式：与类同名切没有返回值类型的方法
     * 方法的格式：修饰符 返回值类型 方法名(参数列表) {方法体}
     */
    public Person() {
        System.out.println("我是无参构造");
    }

    /**
     * 3、方法的重载：在同一个类中存在多个方法，方法名相同但参数列表不相同的现象
     * 4、构造函数也存在重载现象
     */
    public Person(String name) {
        System.out.println("我是含参构造" + name);
    }

    public Person(String name, int age, String address) { // 形参
        System.out.println("我是全参构造");
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public void eat() {
        System.out.println("到饭点啦~该干饭啦~");
    }
}

关于构造函数怎么记忆？

  1. 特点:方法名与类名相同,且没有返回值类型
  2. 执行时机:创建对象时立即执行
  3. 默认会创建无参构造,但是,如果自定义了含参构造,默认的无参构造会被覆盖,注意要手动添加哦

4.3 构造代码块与局部代码块

4.3.1 形式

{方法体…}

4.3.2 构造代码块的特点

  1. 位置: 在类的内部,在方法的外部
  2. 作用: 用于抽取构造方法中的共性代码
  3. 执行时机: 每次调用构造方法前都会调用构造代码块
  4. 注意事项: 构造代码块优先于构造方法加载

4.3.3 局部代码块

  1. 位置: 在方法里面的代码块
  2. 作用: 通常用于控制变量的作用范围,出了花括号就失效
  3. 注意事项: 变量的作用范围越小越好,成员变量会存在线程安全的问题

4.3.4 测试代码块的加载顺序

//执行顺序：
// 构造代码块——>构造方法——>对象创建成功——>局部代码块

/**
 * 总结：
 *  1、创建对象时，程序会自动调用构造方法，但是如果有构造代码块，会先执行构造代码块
 *     提取所有构造的共性功能，在执行构造方法创建对象
 *  2、对象创建好后，就可以通过对象来调用方法，如果方法中有局部代码块，就会执行对应的局部代码块
 */
public class TestBlock {
    public static void main(String[] args) {
        /**
         * 每次实例化对象时，都会执行一次构造代码块
         */
        Teacher t = new Teacher();
        Teacher t1 = new Teacher();
        Teacher t2 = new Teacher("政治");
        t.teach();
    }
}

class Teacher {
    String subject;
    //构建构造代码块

    /**
     * 构造代码块：
     *  位置：类里方法外
     * 执行时机：每次在调用构造方法是触发，而且要优先于构造方法执行
     * 作用：用于提取所有构造方法的共性功能
     */
    {
        subject = "JAVA培优";
        System.out.println("我是构造代码块");
    }

    public Teacher() {
        System.out.println("无参构造" + subject);
    }

    /**
     * 如果有多个构造方法被构造代码块提取了共性内容
     * 但是个别的构造方法需要自己定义参数，这个时候可以把此参数名
     * 设置为方法的参数，那么调用方法时，传什么值，就是什么值
     */
    public Teacher(String subject) {
        System.out.println("含参构造" + subject);
    }

    public void teach() {
        System.out.println("正在授课ing....");
        /**
         * 局部代码块：
         *  位置：方法里
         * 执行时机：调用本代码块的所在方法时，才会触发
         * 作用：控制变量的作用范围，变量的作用范围越小越好
         */
        {
            int i = 10;
            System.out.println("局部代码块");
            System.out.println(i);
        }
        //System.out.println(i);会报错，因为局部变量只能在局部使用
    }
}

5 this关键字

5.1 概念

this代表本类对象的一个引用对象

5.2 形式

在这里插入图片描述

5.3 this练习之变量名相同时使用

public class TestThis1 {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.eat();
    }
}

class Cat {
    int sum = 20;
    int s = 30;

    public void eat() {
        int sum = 10;
        System.out.println(sum);// 变量的就近原则
        System.out.println(s);
        /**
         * 当成员变量与局部变量同名时，我们可以通过this关键字，来指定成员变量
         * 因为成员变量属于类资源，类消失，成员变量才会释放
         * this代表的是本类，可以理解成Cat this = new Cat();
         */
        System.out.println(this.sum);
    }
}

5.3.1 this练习之构造方法间的调用

public class TestThis2 {
    public static void main(String[] args) {
        Dog d = new Dog(999);
        //d.Dog();// 会报错：不能主动的在外部调用构造方法
    }
}

/**
 * this可以实现构造方法的调用
 * 注意：是单方向的，不能来回调用，会死循环
 * this();--调用本类的无参构造
 * this(参数);--调用本类对应参数的含参构造
 * this相关的语句必须写在第一行
 */
class Dog {
    public Dog() {
        /** 本行代码的作用：在无参构造中调用本类的含参构造 */
        //this(6666);
        System.out.println("无参构造");
    }
    public Dog(int n) {
        this();
        System.out.println("含参构造" + n);
    }
}

5.4 OOP综合练习

public class TestOOP {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        Teacher t2 = new Teacher(666);
        Teacher t3 = new Teacher("霞霞",18,1000000.00,"紫青宝剑");
    }
}

class Teacher {
    private String name;
    private int age;
    private double salary;
    private String subject;

    public Teacher() {
        this(666);
        System.out.println("我是Teacher类的无参构造");
    }

    public Teacher(int n) {
        System.out.println("我是Teacher类的含参构造" + n);
//        {
//            局部代码块：方法里，用于控制变量的范围
//        }
    }

    public Teacher(String name, int age, double salary, String subject) {
        System.out.println("我是Teacher类的全参构造");
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.subject = subject;
    }

    public void ready() {
        System.out.println("正在备课ing.....");
    }

    public void teach() {
        System.out.println("正在授课ing.....");
    }

    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 double getSalary() {
        return salary;
    }

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

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }
}

5.5 创建对象流程

Person p = new Person();//短短这行代码发生了很多事情

  1. 把Person.class文件加载进内存
  2. 在栈内存中，开辟空间，存放引用变量p
  3. 在堆内存中，开辟空间，存放Person对象
  4. 对成员变量进行默认的初始化
  5. 对成员变量进行显示初始化
  6. 执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）
  7. 堆内存完成
  8. 把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值
直男编程
关注
NR HARQ(二) CBG HARQ-ACK codebook
asd199086的博客
12-14 1390
这篇开始看下HARQ-ACK codebook的相关内容，先看CBG-based HARQ-ACK codebook。那第一个关注点就是CBG 的划分规则，这部分内容主要在38.213 9.1.1章节中，PDSCH和PUSCH 的CBG 划分规则基本是一样的，这里以PDSCH为例介绍。 PDSCH 和PUSCH 都有 maxCodeBlockGroupPerTransportBlock；maxCodeBlockGroupPerTransportBlock:每个TB块最多分为n个码块组；当下行为2个TB
CBG2105-Day-10笔记
蜕变
08-04 293
1、关于路由说明 1.1 路由嵌套规则 说明：采用children属性来实现路由嵌套 <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>路由嵌套</title> </head> <body> <div id="app"> <!-- 1.定义路由 --> <router-link to=
safegraph数据清洗-2020-06-08-weekly-patterns.csv
xslwyz的博客
01-31 547
以2020-06-08-weekly-patterns.csv为例： 文件大小4.37GB，内容时间段20200608-20200615。 共25个字段，上百万条数据，正常环境下使用python的pandas加载需要60秒以上。 使用sublime text3打开体感需要20秒~40秒。 使用WPS加载体感需要40秒以上，并且打开多个类似大小或几十万条数据的csv时，WPS会无法成功打开，并且向下滚动滚轮会卡屏。 使用MySQL数据库服务的话，数据库装在笔记本上，使用标准配置，即按照开发环境配置数据库，数据
黑马程序员Java Swing笔记分享（AWT篇）
weixin_50456250的博客
03-08 1649
本文章为Java Swing的笔记分享，这一篇就够了
大唐杯学习笔记:Day9
qq_61637982的博客
03-09 485
HARQ是FEC和ARQ的一种混合技术机制。在纠错能力范围内进行自动纠正错误,超出纠错范围则要求发送端重新发送,增加了系统的可靠性,提高了传输效率。HARQ是MAC层的快速传输机制,NR中上下行均采用异步HARQ。支持多个并行的stop-and-wait进程,进程号在PDCCH的DCI中指示。HARQ可以针对一个TB块进行反馈。也可以针对CBG进行反馈。不支持跨小区的HARQ重传。物理通道介绍：PUSCH — 物理上行链路共享信道PUCCH — 物理上行链路控制信道。
safegraph数据预处理（五）：pandas选取需要的数据并用边集数组+边权重的方式保存图数据
xslwyz的博客
02-02 613
根据2020年nature上发表的论文《Mobility network models of COVID-19 explain inequities and inform reopening》其中的内容，借鉴其构建二部图的思路。 需要两个字典dist_placekey和dist_cbg，将placekey作为V_poi的唯一标识，将cbg作为V_cbg的唯一标识，cbg->poi的人数作为边的权重。数据处理的关键在于visitor_daytime_cbgs。 可能需要两种边，第一种visitor_ho
CBG Helper-crx插件
04-06
A helper tool for Onmyoji player to look for good account.A helper tool for better exploring on CBG. It provides more accurate equip values, and export as json file for further analysis.藏宝阁探宝辅助...
yys-cbg-bench:阴阳师藏宝阁衍生小工具，用于提取游戏帐号数据要点并生成报告
05-24
python cbg_bench.py -h + 选项： -h, --help 帮助 -v, --version 程序版本 -l, --lite 输出结果精简化(未指定则输出完整结果) -u, --url 藏宝阁商品详情链接 + 若未指定 -u, 程序会读取未知参数, 若也无未知...
5G NR关键词-缩写和全称.pdf
09-23
**CBGTI**（Codeblock Group Transmission Information）是指与CBG相关的传输信息，如哪些CBG已成功传输或需要重传等。CBGTI对于高效利用无线资源非常重要。 #### CBRA - Contention Based Random Access **CBRA**...
GC小帮手「GC little helper」-crx插件
03-15
您可以自行选择要使用的功能。 所有功能均可通过易于使用的菜单进行配置。 ...配置顺序，名称，......变成绿色而不是灰色配置文件在侧边栏中的自己的链接列表在侧边栏中的可折叠框中编辑链接在自己的缓存旁边的画廊链接在...
Java-网络
2301_81543552的博客
09-14 355
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 351
如果在新建Android项目时报错：Read timed out或者connect timed out。
上传文件到钉盘流程详解
jspyth的博客
09-14 438
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 596
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
记录开发一个英语听力训练网站
业余程序员Blue的博客
09-14 413
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
最新发布
m0_66572126的博客
09-14 450
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 605
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
高性能微服务架构：Spring Boot 集成 gRPC 实现用户与订单服务即时交互
weixin_48278764的博客
09-14 942
高性能微服务架构：Spring Boot 集成 gRPC 实现用户与订单服务即时交互
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

直男编程

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

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

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

打赏作者

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

抵扣说明：

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

余额充值