面向对象三大特征之封装

于 2016-12-07 16:11:57 发布
阅读量361 收藏
点赞数 1
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ciqing123/article/details/53507541
版权

1.成员变量和局部变量的区别

(1).在类中的位置不同

成员变量: 在类中方法外

局部变量: 在方法定义中,或方法声明上

(2).在内存中的位置不同

成员变量: 在堆内存

局部变量: 在栈内存

(3).生命周期不同

成员变量: 随着对象的创建而存在,随着对象的消失而消失

局部变量: 随着方法的调用而存在,随着方法的调用完毕而消失

(4).初始化值不同

成员变量: 有默认初始化值
byte,short,int,long–>0;float,double–>0.0;char–>\u0000;boolean–>false

局部变量:没有默认初始化值,必须定义,赋值,然后才能使用

注意事项

局部变量名称可以和成员变量名称相同,在方法中使用的时候,采用的是就近原则;

代码示例

  class Varialbe {
    //成员变量
    //int num = 10;
    int num; //0

    public void show() {
        //int num2 = 20; //局部变量
        //可能尚未初始化变量num2
        //int num2; //没有默认值
        int num2 = 20;
        System.out.println(num2);

        //int num = 100;
        System.out.println(num);
    }
}


class VariableDemo {
    public static void main(String[] args) {
        Varialbe v = new Varialbe();

        System.out.println(v.num); //访问成员变量

        v.show();   

    }
}

2.类作为形式参数传递的问题

如果一个方法需要传递的参数是一个类名,那么这里实际需要传递的是一个具体的对象;

代码示例

/*
    形式参数的问题：
        基本类型：形式参数的改变不影响实际参数
        引用类型：形式参数的改变直接影响实际参数
*/
//形式参数是基本类型
class Demo {
    public int sum(int a,int b) {
        return a + b;
    }
}

//形式参数是引用类型
class Student {
    public void show() {
        System.out.println("我爱学习");
    }
}

class StudentDemo {
    //如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
    public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
        s.show();
    }
}

class ArgsTest {
    public static void main(String[] args) {
        //形式参数是基本类型的调用
        Demo d = new Demo();
        int result = d.sum(10,20);
        System.out.println("result:"+result);
        System.out.println("--------------");

        //形式参数是引用类型的调用
        //需求：我要调用StudentDemo类中的method()方法
        StudentDemo sd = new StudentDemo();
        //创建学生对象
        Student s = new Student();
        sd.method(s); //把s的地址给到了这里
    }
}

3.匿名对象

(1).概念

没有名字的对象

(2).应用场景

调用方法,仅仅是调用一次的时候;

可以作为实际参数传递

代码示例
/*
    匿名对象：就是没有名字的对象。

    匿名对象的应用场景：
        A:调用方法，仅仅只调用一次的时候。
            注意：调用多次的时候，不适合。
            那么，这种匿名调用有什么好处吗?
                有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
        B:匿名对象可以作为实际参数传递
*/
class Student {
    public void show() {
        System.out.println("我爱学习");
    }
}

class StudentDemo {
    public void method(Student s) {
        s.show();
    }
}

class NoNameDemo {
    public static void main(String[] args) {
        //带名字的调用
        Student s = new Student();
        s.show();
        s.show();
        System.out.println("--------------");

        //匿名对象
        //new Student();
        //匿名对象调用方法
        new Student().show();
        new Student().show(); //这里其实是重新创建了一个新的对象
        System.out.println("--------------");


        //匿名对象作为实际参数传递
        StudentDemo sd = new StudentDemo();
        //Student ss = new Student();
        //sd.method(ss); //这里的s是一个实际参数
        //匿名对象
        sd.method(new Student());

        //在来一个
        new StudentDemo().method(new Student());
    }
}

4.封装

(1).概念

隐藏对象的属性和实现细节,仅对外提供公共的访问方式

(2).好处

隐藏实现细节,提供公共的访问方式

提高代码的复用性

提高代码的安全性

(3).设计原则

把不想让外界知道的实现细节隐藏起来,仅提供公共的访问方式

(4).具体体现

private是封装的具体体现,用private来修饰类的成员变量和成员方法

代码示例

/*
    定义一个学生类：
        成员变量：name，age
        成员方法：show()方法

    我们在使用这个案例的过程中，发现了一个问题：
        通过对象去给成员变量赋值，可以赋值一些非法的数据。
        这是不合理的。
        应该是这个样子的：在赋值之前，先对数据进行判断。
        判断到底在哪里做比较合适呢?
        StudentDemo类是一个测试类，测试类一般只创建对象，调用方法。 
        所以，这个判断应该定义在Student类中。
        而我们在成员变量的位置可不可以进行数据判断呢?
        是不可以的，因为做数据校验，必须要依靠一些逻辑语句。
        逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法
        来对数据进行校验。

    按照我们前面的分析，我们给出了一个方法进行校验。
    但是呢，它偏偏不调用方法来赋值，还是直接赋值了，
    这样我们的方法就没有起到作用。
    我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值。
    怎么去强制要求不能直接使用成员变量呢?
        针对这种情况，Java就提供了一个关键字 private

    private:私有的。可以修饰成员变量和成员方法。
        注意：被private修饰的成员只能在本类中访问。

    其实我讲到现在讲解的是一个封装的思想。
    封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
*/
class Student {
    //姓名
    String name;
    //年龄
    private int age;

    //写一个方法对数据进行校验
    /*
        返回值类型：void
        参数列表：int a
    */
    public void setAge(int a) {
        if(a < 0 || age > 120) {
            System.out.println("你给的年龄有问题");
        }else {
            age = a;
        }
    }


    //show()方法,显示所有成员变量值
    public void show() {
        System.out.println("姓名："+name);
        System.out.println("年龄："+age);
    }
}

class StudentDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();
        s.show();
        System.out.println("--------------");

        //给成员变量赋值
        s.name = "林青霞";
        //s.age = 27;
        s.setAge(27);
        s.show();
        System.out.println("--------------");

        //给age赋值
        //s.age = -27; //这个数据是不合理的
        //通过方法给值
        s.setAge(-27);
        s.show();
        System.out.println("--------------");
    }
}

5.private关键字

(1).意义

可以修饰成员变量和成员方法,防止外界直接使用

(2).特点

被private修饰后的成员,只能在本类中访问

(3).应用

写类的时候,把所有的成员变量用private修饰,并提供对应的setXXX/getXXX方法

代码示例

/*
    封装和private的应用：
        A:把成员变量用private修饰
        B:提高对应的getXxx()和setXxx()方法
*/
//定义学生类
class Student {
    //姓名
    private String name;
    //年龄
    private int age;

    //姓名获取值
    public String getName() {
        return name;
    }

    //姓名设置值
    public void setName(String n) {
        name = n;
    }

    //年龄获取值
    public int getAge() {
        return age;
    }

    //年龄赋值
    public void setAge(int a) {
        age = a;
    }

    public void show() {
        System.out.println(num);
    }

    private void method() {
        System.out.println("method");
    }

    public void function() {
        method();
    }
}

//测试类
class StudentTest {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();

        //使用成员变量
        //错误：被私有修饰了，外界不能直接访问了
        //System.out.println(s.name+"---"+s.age);
        System.out.println(s.getName()+"---"+s.getAge());

        //给成员变量赋值
        //s.name = "林青霞";
        //s.age = 27;
        //通过方法给赋值
        s.setName("林青霞");
        s.setAge(27);
        System.out.println(s.getName()+"---"+s.getAge());
    }

        d.show();
        //不能访问私有的成员方法
        //d.method();
        d.function();
}

6.this关键字

(1).意义

代表当前类的引用对象,哪个对象调用方法,该方法内部的this就代表那个对象

(2).应用场景

解决了局部变量隐藏成员变量的问题

(3).内存图

这里写图片描述

代码示例

/*
    我们曾经曰：起名字要做到见名知意。

    this:是当前类的对象引用。简单的记，它就代表当前类的一个对象。

        注意：谁调用这个方法，在该方法内部的this就代表谁。

    this的场景：
        解决局部变量隐藏成员变量
*/
//定义学生类
class Student {
    //姓名
    private String name;
    //年龄
    private int age;

    //姓名获取值
    public String getName() {
        return name;
    }

    //姓名设置值
    public void setName(String name) { //name = "林青霞";
        //name = name; //变量的使用规则：就近原则
        //这里是类名，目前还没有说过类似的用法，所以这个是有问题的
        //这里的调用只能通过对象名
        //这个对象如果存在，它应该代表的是Student的一个对象。
        //那么，谁能够代表当前类的对象呢? java就提供了一个关键字 this
        //Student.name = name;
        this.name = name;
    }

    //年龄获取值
    public int getAge() {
        return age;
    }

    //年龄赋值
    public void setAge(int age) {
        this.age = age;
    }
}

//测试类
class StudentTest {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();

        //给成员变量赋值
        s.setName("林青霞");
        s.setAge(27);
        //获取数据
        System.out.println(s.getName()+"---"+s.getAge());
    }
}

7.构造方法

(1)作用

用于对对象的数据进行初始化

(2)格式

方法名和类名相同

没有返回值类型，连void都不能有

没有返回值

(3)注意事项

如果我们没写构造方法，系统将提供一个默认的无参构造方法

如果我们给出了构造方法，系统将不再提供默认构造方法.如果这个时候，我们要使用无参构造方法，就必须自己给出。建议永远自己手动给出无参构造方法。

(4)给成员变量赋值的方式

setXxx()

带参构造方法

代码示例

/*
    我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?

    构造方法的注意事项:
        A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
        B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
            注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

    给成员变量赋值有两种方式：
        A:setXxx()
        B:构造方法
*/

class Student {
    private String name;
    private int age;

    public Student() {
        //System.out.println("我给了，你还给不");
        System.out.println("这是无参构造方法");
    }

    //构造方法的重载格式
    public Student(String name) {
        System.out.println("这是带一个String类型的构造方法");
        this.name = name;
    }

    public Student(int age) {
        System.out.println("这是带一个int类型的构造方法");
        this.age = age;
    }

    public Student(String name,int age) {
        System.out.println("这是一个带多个参数的构造方法");
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name+"---"+age);
    }
}

class ConstructDemo2 {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
        System.out.println("-------------");

        //创建对象2
        Student s2 = new Student("林青霞");
        s2.show();
        System.out.println("-------------");

        //创建对象3
        Student s3 = new Student(27);
        s3.show();
        System.out.println("-------------");

        //创建对象4
        Student s4 = new Student("林青霞",27);
        s4.show();
    }
}

8.创建对象的过程

Student s = new Student();做了哪些事情?

(1).把Student.class文件加载到内存

(2).在栈内存为s开辟空间

(3).在堆内存为学生对象申请空间

(4).给学生的成员变量进行默认初始化。

(5).给学生的成员变量进行显示初始化。

(6).通过构造方法给成员变量进行初始化。

(7).对象构造完毕，把地址赋值给s变量

9.static关键字

(1).作用

可以修饰成员变量和成员方法。

(2).特点

随着类的加载而加载

优先与对象存在

被类的所有对象共享,这也是我们判断该不该使用静态的依据。

既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。

(3)内存图

静态的内容在方法区的静态区

这里写图片描述

(4).注意事项；

在静态方法中没有this对象

静态只能访问静态

代码示例
/*
    static关键字注意事项
        A:在静态方法中是没有this关键字的
            如何理解呢?
                静态是随着类的加载而加载，this是随着对象的创建而存在。
                静态比对象先存在。
        B:静态方法只能访问静态的成员变量和静态的成员方法
                静态方法：
                    成员变量：只能访问静态变量
                    成员方法：只能访问静态成员方法
                非静态方法：
                    成员变量：可以是静态的，也可以是非静态的
                    成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
            简单记：
                静态只能访问静态。
*/
class Teacher {
    public int num = 10;
    public static int num2 = 20;

    public void show() {
        System.out.println(num); //隐含的告诉你访问的是成员变量
        System.out.println(this.num); //明确的告诉你访问的是成员变量
        System.out.println(num2);

        //function();
        //function2();
    }

    public static void method() {
        //无法从静态上下文中引用非静态 变量 num
        //System.out.println(num);
        System.out.println(num2);

        //无法从静态上下文中引用非静态 方法 function()
        //function();
        function2();
    }

    public void function() {

    }

    public static void function2() {

    }
}

class TeacherDemo {
    public static void main(String[] args) {
        //创建对象
        Teacher t = new Teacher();
        t.show();
        System.out.println("------------");
        t.method();
    }
}

(5).静态变量和成员变量的区别

所属不同

静态变量：属于类，类变量

成员变量：属于对象，对象变量，实例变量

内存位置不同

静态变量：方法区的静态区

成员变量：堆内存

生命周期不同

静态变量：静态变量是随着类的加载而加载，随着类的消失而消失

成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失

调用不同

静态变量：可以通过对象名调用，也可以通过类名调用

成员变量：只能通过对象名调用

(6).main方法是静态的

public:权限最大

static:不用创建对象调用

void:返回值给jvm没有意义

main:就是一个常见的名称。

String[] args:可以接收数据，提供程序的灵活性

代码示例
/*
    main方法的格式讲解：
        public static void main(String[] args) {...}

        public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
        static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
        void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
        main:是一个常见的方法入口。我见过的语言都是以main作为入口。
        String[] args:这是一个字符串数组。值去哪里了?
            这个东西到底有什么用啊?怎么给值啊?
                这个东西早期是为了接收键盘录入的数据的。
                格式是：
                    java MainDemo hello world java
*/
class MainDemo {
    public static void main(String[] args) {
        //System.out.println(args); //[Ljava.lang.String;@175078b
        //System.out.println(args.length); //0
        //System.out.println(args[0]); //ArrayIndexOutOfBoundsException

        //接收数据后
        System.out.println(args); 
        System.out.println(args.length); 
        //System.out.println(args[0]); 
        for(int x=0; x<args.length; x++) {
            System.out.println(args[x]);
        }
    }
}
ciqing123
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
qt练习控件label控件-lineEdit控件样例代码
07-30
qt练习控件label控件-lineEdit控件样例代码
【JCR一区级】麻雀搜索算法SSA-CNN-LSTM-Attention故障诊断分类预测【含源码 5689期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Attention分类系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Attention分类 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Attention分类 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Attention分类 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Attention分类 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Attention分类
详解MATLAB Simulink通信系统建模与仿真
07-30
第1 章 MATLAB 基础与通信系统仿真 1.1 MATLAB 简介 1.2 MATLAB 程序设计 1.3 通信系统仿真 第2 章 Simulink 仿真基础 2.1 Simulink 简介 2.2 Simulink 工作环境 2.3 Simulink 仿真的基本方法 2.4 创建自己的模块库 2.5 S-函数的编写 第3 章 通信信号与系统分析 3.1 离散信号和系统 3.2 Fourier 分析 3.3 带通信号的低通等效 3.4 随机信号分析 第4 章 信道 4.1 加性高斯白噪声信道 4.2 多径衰落信道 第5 章 模拟调制 5.1 幅度调制 5.2 角度调制 第6 章 数字基带传输 6.1 概述 6.2 二进制基带信号传输 6.3 基带PAM 信号传输 6.4 带限信道的信号传输 第7 章 数字信号载波传输 7.1 概述 7.2 载波幅度调制（PAM） 7.3 载波相位调制（PSK） 7.4 正交幅度调制（QAM） 7.5 载波频率调制（FSK） 第8 章 信道编码和交织 8.1 概述 8.2 线性分组码
SCI一区】淘金算法GRO-CNN-BiLSTM-Mutilhead-Attention多变量时序预测含源码 5642.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-BiLSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-BiLSTM-Mutilhead-Attention回归预测
2020年首届“洪泽湖杯”中国人工智能掼蛋算法大赛第8名我就是掼蛋.zip
07-30
毕业设计是高等教育阶段学生完成学业的一个重要环节，通常在学士或硕士学业即将结束时进行。这是学生将在整个学业中所学知识和技能应用到实际问题上的机会，旨在检验学生是否能够独立思考、解决问题，并展示其专业能力的一项综合性任务。 毕业设计的主要特点包括： 独立性： 毕业设计要求学生具备独立思考和解决问题的能力。学生需要选择一个合适的课题，研究相关文献，进行实地调查或实验，并提出独立见解。 实践性： 毕业设计是将理论知识应用到实际问题中的一次实践。通过完成毕业设计，学生能够将所学的专业知识转化为实际的解决方案，加深对专业领域的理解。 综合性： 毕业设计往往要求学生运用多个学科的知识，综合各种技能。这有助于培养学生的综合素养，提高他们的综合能力。 导师指导： 学生在毕业设计过程中通常由一名指导老师或导师团队提供指导和支持。导师负责引导学生确定研究方向、制定计划、提供建议，并在整个过程中监督进展。 学术规范： 毕业设计要求学生按照学术规范完成研究，包括文献综述、研究设计、数据采集与分析、结论和讨论等环节。学生需要撰写一篇完整的毕业论文，并进行答辩。
网络音乐搜索引擎，音乐搜索器 - 多站合一音乐搜索,音乐在线试听
07-30
网络音乐搜索引擎，音乐搜索器 - 多站合一音乐搜索,音乐在线试听 效果截图https://www.diyiyuanma.cn/3444.html 多站合一音乐搜索解决方案，数据调用的是各网站的API接口， 有的接口并不是开放的，随时可能失效，本项目相关代码仅供参考。 网络音乐搜索引擎，音乐搜索器 - 多站合一音乐搜索,音乐在线试听
这是一个旨在简化合约部署、验证、交互等操作用于生成区块链智能合约Foundry框架指令的 Web3.0开发者工具
07-30
这是一个旨在简化合约部署、验证、交互等操作用于生成区块链智能合约Foundry框架指令的 Web3.0开发者工具。
三种esprit算法实现doa估计 _rezip.zip
07-30
在信号处理领域，DOA（Direction of Arrival）估计是一项关键技术，主要用于确定多个信号源到达接收阵列的方向。本文将详细探讨三种ESPRIT（Estimation of Signal Parameters via Rotational Invariance Techniques）算法在DOA估计中的实现，以及它们在MATLAB环境中的具体应用。 ESPRIT算法是由Paul Kailath等人于1986年提出的，其核心思想是利用阵列数据的旋转不变性来估计信号源的角度。这种算法相比传统的 MUSIC（Multiple Signal Classification）算法具有较低的计算复杂度，且无需进行特征值分解，因此在实际应用中颇具优势。 1. 普通ESPRIT算法 普通ESPRIT算法分为两个主要步骤：构造等效旋转不变系统和估计角度。通过空间平移（如延时）构建两个子阵列，使得它们之间的关系具有旋转不变性。然后，通过对子阵列数据进行最小二乘拟合，可以得到信号源的角频率估计，进一步转换为DOA估计。 2. 常规ESPRIT算法实现 在描述中提到的`common_esprit_method1.m`和`common_esprit_method2.m`是两种不同的普通ESPRIT算法实现。它们可能在实现细节上略有差异，比如选择子阵列的方式、参数估计的策略等。MATLAB代码通常会包含预处理步骤（如数据归一化）、子阵列构造、旋转不变性矩阵的建立、最小二乘估计等部分。通过运行这两个文件，可以比较它们在估计精度和计算效率上的异同。 3. TLS_ESPRIT算法 TLS（Total Least Squares）ESPRIT是对普通ESPRIT的优化，它考虑了数据噪声的影响，提高了估计的稳健性。在TLS_ESPRIT算法中，不假设数据噪声是高斯白噪声，而是采用总最小二乘准则来拟合数据。这使得算法在噪声环境下表现更优。`TLS_esprit.m`文件应该包含了TLS_ESPRIT算法的完整实现，包括TLS估计的步骤和旋转不变性矩阵的改进处理。 在实际应用中，选择合适的ESPRIT变体取决于系统条件，例如噪声水平、信号质量以及计算资源。通过MATLAB实现，研究者和工程师可以方便地比较不同算法的效果，并根据需要进行调整和优化。同时，这些代码也为教学和学习DOA估计提供了一个直观的平台，有助于深入理解ESPRIT算法的工作原理。
细胞分割计数matlab程序 附GUI 1.zip
07-30
细胞分割计数matlab程序 附GUI 1
【SCI顶级】多元宇宙算法MVO-CNN-LSTM-Multihead-Attention温度预测【含源码 5726期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Mutilhead-Attention回归预测
基于MC9S12单片机的电动汽车锂电池组监控系统研究
最新发布
07-30
锂电池体积小、比能量高、循环寿命长，在电动汽车产业得到广泛应用。但是锂电池在成组使用过程中会出现过充、过放及电量不一致等问题，这会降低锂电池组的使用性能、缩短锂电池组使用寿命，严重时还会引发锂电池起火、爆炸导致安全问题。因此，研究锂电池组监控系统对保证锂电池安全高效运行具有重要意义。 基于MC9S12系列单片机、电压采集模块、电流采集模块、温度采集模块、均衡模块及通信模块，搭建了锂电池组监控系统，并选用电池工作电压来实现电池的均衡监控。针对锂电池组电量出现的不一致问题，开发了被动均衡和主动均衡两种均衡策略。当采用被动均衡策略时，推挽开关电路会选通待均衡的单体电池，利用功率电阻消耗其多余的电量，使得锂电池组电量重新一致。为了准确监控锂电池组的剩余电量，设计了SOC估算算法。对初始SOC值，考虑锂电池动态滞回特性，采用修正开路电压法来估算；对实时SOC值，考虑库伦效率的影响，采用修正安时法来估算。监控系统的控制系统由上位机与下位机组成，下位机采用HCS12S内核微处理器，实现各功能模块的控制任务；上位机采用LabVIEW编写交互界面，提供数据显示、预警监测、串口通信等功能。
点击未来：Python GUI编程全解析
07-30
Python是一种广泛使用的高级编程语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进来区分代码块，而不是使用大括号或关键词）。这使得Python被认为是一种易于学习的语言，同时具备强大的功能，适合初学者和经验丰富的程序员。 Python的主要特点包括： 1. **易于学习**：Python有相对较少的关键字，结构简单，和一个明确定义的语法。 2. **易于阅读**：Python代码定义的清晰度使得它像可执行伪代码。 3. **易于维护**：Python的成功在于它的源代码是相当容易维护的。 4. **广泛的标准库**：Python的标凑库很庞大，包含用于互联网通信、网络通信、数据压缩、加密、系统管理等的模块。 5. **跨平台**：Python可以在多种操作系统上运行，包括但不限于Windows、Mac OS X、Linux等。 6. **解释型语言**：Python是一种解释型语言，这意味着开发过程中没有编译步骤。 7. **动态类型系统**：Python不会在编写
[毕设]Java企业销售与采购管理系统源码.zip
07-30
[毕设]Java企业销售与采购管理系统源码
用 365 道高频算法题，带你融会贯通算法知识，做到以不变应万变
07-30
用 365 道高频算法题，带你融会贯通算法知识，做到以不变应万变
基于Android的新闻推荐系统.zip
07-30
基于Android的新闻推荐系统.zip
apache-activemq-5.18.5-bin.zip
07-30
apache-activemq-5.18.5-bin
js特效脚本含源码和说明音乐封面推荐形式的焦点图
07-30
js，js特效脚本含源码和说明音乐封面推荐形式的焦点图
etcd-v3.4.26-linux-amd64.tar.gz
07-30
kubelet.sh
减法平均算法SABO-CNN-LSTM-Multihead-Attention温度预测【含源码 5740期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Mutilhead-Attention回归预测
面向对象的三大特征：封装、继承、多态
06-12
面向对象编程的三大特征就是封装、继承和多态。其中，封装指的是将数据和方法封装在一起，形成类的特性，可以保障数据安全和代码的可维护性；继承指的是子类可以继承父类的属性和方法，避免了代码的重复编写；多态指...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值