AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

类和对象（二）

2023-11-24 84
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 类和对象（二）

一：封装

面对对象程序的三大特性：封装，继承，多态。

1：什么是封装？

封装就是将类的实现细节进行了隐藏，对外只提供一些接口。

2：为什么要封装？

为了安全考虑。

3：访问限定符：

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认识，而访问权限用来控制方法或者字段能否直接在类外使用。

public：可以理解为一个人的外貌特征，谁都可以看的到；

default：包访问权限，只有在同一个包中才可以使用。对于自己家族中（同一个包中）不是什么秘密，对于其他人来说就是隐私了。

private：只能在同一个类中使用。

protected:在同一个包中，以及不同包的子类中可以使用。

一般我们类的成员变量我们写成private修饰，成员方法用public修饰，可以根据具体的情景来确定使用什么限定符。

举个例子看一下吧！

class Student{
    private String name;
    private int age;
    private String classroom;
    //构造方法
    public Student(String name, int age, String classroom) {
        this.name = name;
        this.age = age;
        this.classroom = classroom;
    }
   //公开的接口，获得成员变量name
    public String getName() {
        return name;
    }
    //公开的接口，设置成员变量name
    public void setName(String name) {
        this.name = name;
    }
    //公开的接口，获得成员变量age
    public int getAge() {
        return age;
    }
    //公开的接口，设置成员变量age
    public void setAge(int age) {
        this.age = age;
    }
    //公开的接口，获得成员变量classroom
    public String getClassroom() {
        return classroom;
    }
    //公开的接口，设置成员变量classroom
    public void setClassroom(String classroom) {
        this.classroom = classroom;
    }
}
public class Test {
    public static void main(String[] args) {
    Student student=new Student("张三",20,"1770");
    }
}

二：static成员：

先看个例子：

class Student{
    private String name;
    private int age;
    private String classroom;
    //构造方法
    public Student(String name, int age, String classroom) {
        this.name = name;
        this.age = age;
        this.classroom = classroom;
    }
   //公开的接口，获得成员变量name
    public String getName() {
        return name;
    }
    //公开的接口，设置成员变量name
    public void setName(String name) {
        this.name = name;
    }
    //公开的接口，获得成员变量age
    public int getAge() {
        return age;
    }
    //公开的接口，设置成员变量age
    public void setAge(int age) {
        this.age = age;
    }
    //公开的接口，获得成员变量classroom
    public String getClassroom() {
        return classroom;
    }
    //公开的接口，设置成员变量classroom
    public void setClassroom(String classroom) {
        this.classroom = classroom;
    }
    @Override
    public String toString() {
        return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
    }
}
public class Test {
    public static void main(String[] args) {
    Student student1=new Student("张三",20,"1770");
    Student student2=new Student("李四",21,"1770");
    Student student3=new Student("王五",19,"1770");
        System.out.println(student1.toString());
        System.out.println(student2.toString());
        System.out.println(student3.toString());
    }
}


我们发现这三个同学的上课班级都是相同的，都是1770，而在Student类中定义的成员变量，每个对象都会包含一份，因为这些需要描述一个具体的学生，而这个教室并不需要每个学生来存储一份，而是所有的学生共享。

在Java中，被static修饰的成员，称为静态成员，也可以称为类成员，其不属于某个具体的对象，而是所有对象共享的。

1：static修饰成员变量

1：static修饰的成员变量称为静态成员变量，静态成员变量的最大特征就是不属于某个具体的对象，是所有对象所共享的。

2：既可以通过类名访问，又可以通过对象访问，但更推荐使用类名访问，因为static修饰的成员变量是不属于某个对象的，而是属于类的。

3：static修饰的成员变量存储在方法区中；

4：生命周期伴随类的一生，随着类的加载而创建，随着类的卸载而销毁。

static修饰成员变量举例：

class Student{
    private String name;
    private int age;
    private static String classroom="1770";
    //构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
   //公开的接口，获得成员变量name
    public String getName() {
        return name;
    }
    //公开的接口，设置成员变量name
    public void setName(String name) {
        this.name = name;
    }
    //公开的接口，获得成员变量age
    public int getAge() {
        return age;
    }
    //公开的接口，设置成员变量age
    public void setAge(int age) {
        this.age = age;
    }
    //公开的接口，获得成员变量classroom
    public String getClassroom() {
        return classroom;
    }
    //公开的接口，设置成员变量classroom
    public void setClassroom(String classroom) {
        this.classroom = classroom;
    }
    @Override
    public String toString() {
        return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
    }
}
public class Test {
    public static void main(String[] args) {
    Student student1=new Student("张三",20);
    Student student2=new Student("李四",21);
    Student student3=new Student("王五",19);
        System.out.println(student1.toString());
        System.out.println(student2.toString());
        System.out.println(student3.toString());
    }
}

class Student{
    private String name;
    private int age;
    public  static String classroom;
    //构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
   //公开的接口，获得成员变量name
    public String getName() {
        return name;
    }
    //公开的接口，设置成员变量name
    public void setName(String name) {
        this.name = name;
    }
    //公开的接口，获得成员变量age
    public int getAge() {
        return age;
    }
    //公开的接口，设置成员变量age
    public void setAge(int age) {
        this.age = age;
    }
    //公开的接口，获得成员变量classroom
    public String getClassroom() {
        return classroom;
    }
    //公开的接口，设置成员变量classroom
    public void setClassroom(String classroom) {
        this.classroom = classroom;
    }
    @Override
    public String toString() {
        return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
    }
}
public class Test {
    public static void main(String[] args) {
    Student student1=new Student("张三",20);
    Student student2=new Student("李四",21);
    Student student3=new Student("王五",19);
    Student.classroom="1770";
    System.out.println(student1.toString());
    System.out.println(student2.toString());
    System.out.println(student3.toString());
    }
}


2：static修饰成员方法

1：被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。

2：可以通过类名来调用，也可以通过对象调用，但更推荐类名调用。

3：不可以在静态方法中访问任何非静态的成员变，不可以在静态方法中调用非静态的方法；

4：可以在非静态的方法中调用静态的成员变量和静态的成员方法。

5：在静态方法中不可以使用this引用。

class Student{
    private String name;
    private int age;
    private static String classroom;
    //构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public static String getClassroom(){
       return classroom;
    }
    public static void setClassroom(String classroom) {
        Student.classroom = classroom;
    }
    //公开的接口，获得成员变量name
    public String getName() {
        return name;
    }
    //公开的接口，设置成员变量name
    public void setName(String name) {
        this.name = name;
    }
    //公开的接口，获得成员变量age
    public int getAge() {
        return age;
    }
    //公开的接口，设置成员变量age
    public void setAge(int age) {
        this.age = age;
    }
    //公开的接口，获得成员变量classroom
    @Override
    public String toString() {
        return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
    }
}
public class Test {
    public static void main(String[] args) {
    Student student1=new Student("张三",20);
    Student student2=new Student("李四",21);
    Student student3=new Student("王五",19);
    Student.setClassroom("1770");
    System.out.println(student1.toString());
    System.out.println(student2.toString());
    System.out.println(student3.toString());
    }
}


3：类的成员变量

类的成员变量分为两种：

1：静态成员变量

2:非静态成员变量/普通成员变量

在非静态的成员方法中可以访问静态的成员变量和静态的成员方法。

1:静态成员变量

1：静态成员变量是属于类的，不属于对象，只有一份

2：通常使用类名来访问

3：静态的成员变量随着类被加载而加载，随着类的销毁而销毁。

2：非静态成员变量/普通成员变量

1：属于对象的，每实例化一个对象，都会有一个对应的非静态成员变量，每个对象都有。

2:通过对象来访问。

三：代码块

使用{}定义的代码称为代码块。根据代码块定义的位置以及关键字又分为：

1：普通代码块

2：构造代码块/实例代码块

3：静态代码块

1：普通代码块

普通代码块是定义在方法中的代码块，一般不使用，

public class Test{
    public static void main(String[] args) {
        {//普通代码块
            System.out.println("这是普通代码块");
            System.out.println("哈哈");
        }
    }
}

2:构造代码块/实例代码块

定义在类中的代码块称为构造代码块，也叫做：实例代码块，一般用于初始化实例成员变量。

仍是学生类：

//构造代码块，实例代码块
    {
        this.name="张三";
        this.age=19;
    }

3：静态代码块

用static修饰的代码块称为静态代码块，一般用于初始化静态的成员变量

//静态代码块
 static{
        classroom="1770";
    }

静态代码块不依赖与对象，随着类的加载而加载：

class Student{
    private String name;
    private int age;
    public  static String classroom;
    //构造方法
    public Student(String name, int age) {
        System.out.println("这是构造方法");
    }
    //构造代码块，实例代码块
    {
        System.out.println("这是构造代码块");
    }
    static{
        classroom="1770";
        System.out.println("这是静态代码块");
    }
}
public class Test{
    public static void main(String[] args) {
        //这里我们没有创建对象
        System.out.println(Student.classroom);
    }
}

注意：

1：不管生成多少个对象，静态代码块只会执行一次。

2：静态成员变量是类的属性，类在加载的时候完成初始化。

3：如果一个类中包含多个静态代码块，在程序执行时，程序会依次执行。

4：实例代码块只有在创建对象的时候才会执行，和构造方法一样，创建一次对象，执行一次。

5：先执行静态代码块，再执行实例代码块，再执行构造方法。但静态代码块只会执行一次。

class Student{
    private String name;
    private int age;
    public  static String classroom;
    //构造方法
    public Student(String name, int age) {
        System.out.println("这是构造方法");
    }
    //构造代码块，实例代码块
    {
        System.out.println("这是构造代码块");
    }
    static{
        classroom="1770";
        System.out.println("这是静态代码块");
    }
}
public class Test{
    public static void main(String[] args) {
        Student student1=new Student("张三",19);
        Student student2=new Student("李四",20);
        // 创建了两个对象实例代码块和构造方法执行了两次，
        // 而静态代码块只会执行一次
    }
}



文章标签：
Java
存储
安全
十一..
目录
相关文章
it小锅巴
|
7月前
|
缓存 NoSQL 测试技术
Redis压测脚本及持久化机制
Redis压测脚本及持久化机制简介： Redis性能压测通过`redis-benchmark`工具进行，可评估读写性能。持久化机制包括无持久化、RDB（定期快照）和AOF（操作日志），以及两者的结合。RDB适合快速备份与恢复，但可能丢失数据；AOF更安全，记录每次写操作，适合高数据安全性需求。两者结合能兼顾性能与安全性，建议同时开启并定期备份RDB文件以确保数据安全。
it小锅巴
142 9
弹性计算小冉
|
26天前
|
存储 域名解析 弹性计算
阿里云上云流程参考：云服务器+域名+备案+域名解析绑定，全流程图文详解
对于初次通过阿里云完成上云的企业和个人用户来说，很多用户不仅是需要选购云服务器，同时还需要注册域名以及完成备案和域名的解析相关流程，从而实现网站的上线。本文将以上云操作流程为核心，结合阿里云的活动政策与用户系统梳理云服务器选购、域名注册、备案申请及域名绑定四大关键环节，以供用户完成线上业务部署做出参考。
弹性计算小冉
371 3
划雨悦潭之赋
|
10月前
|
设计模式 前端开发 JavaScript
前端必须掌握的设计模式——装饰器模式
装饰器模式是一种结构型设计模式，通过创建新类来包装原始对象，实现在不修改原有结构的前提下扩展新行为。其核心在于“组合”思想，使新功能可“即插即拔”。该模式具有解耦性、灵活性和动态性等特点，广泛应用于类的面向对象编程语言中，如JavaScript的注解和TypeScript的写法。示例中，通过装饰器模式为游戏角色动态添加装备，展示了其强大的扩展性和灵活性。
划雨悦潭之赋
177 16
探索云世界
|
3月前
|
人工智能 数据可视化 数据处理
10分钟，用 EvalScope 让文生图模型评估“有理有据”
AI画师们卷出新高度，人类评审却还在搬砖打分？传统文生图模型评测依赖人工标注与主观判断，周期长、成本高、易偏差。魔搭社区推出一站式模型评测框架EvalScope，支持全自动打标、多维雷达图与可视化报告，大幅提升评测效率。10分钟掌握EvalScope，轻松为文生图模型自动评分，让模型“卷”得明明白白！
探索云世界
223 0
游客beejssedmb2sq
|
4月前
|
数据采集 自然语言处理 搜索推荐
Python内置函数ord()详解
`ord()` 是 Python 中用于将单个字符转换为对应 Unicode 码点的核心函数，支持 ASCII、多语言字符及特殊符号。其返回值为整数（范围 0-1114111），适用于字符编码验证、数据清洗、自定义排序、基础加解密等场景。使用时需注意参数长度必须为 1，否则会触发 `TypeError`。结合 `chr()` 函数可实现双向转换，进阶技巧包括多字节字符处理、编码范围检测及字符分类验证等。
游客beejssedmb2sq
673 0
Deephub
|
7月前
|
机器学习/深度学习 运维 数据挖掘
时间序列特征提取：18 种高效工具库及其应用分析
时间序列特征提取是数据科学的重要环节，可将原始数据转化为分析价值高的特征表示。本文介绍18个Python库，涵盖通用与专业领域（如医疗、金融）的特征提取工具。这些库包括tsfeatures、tsfresh、librosa等，各自针对特定任务（如预测、分类、异常检测）提供独特功能。通过结合不同库的特点，数据科学家能更高效地进行特征工程，提升模型性能与分析深度。文章总结了各库的优势及适用场景，为实际应用提供了全面指导。
Deephub
322 0
wljslmz
|
12月前
|
Web App开发 安全 Java
Debian 12.7 推出安全性和稳定性改进
【10月更文挑战第16天】
wljslmz
472 3
Debian 12.7 推出安全性和稳定性改进
小王老师呀
|
安全 Shell Windows
记windows自定义bat脚本自启动
【8月更文挑战第27天】在Windows系统中，可让自定义bat脚本自启动的方法有两种：一是利用“启动”文件夹，通过创建bat脚本的快捷方式并将其放置于该文件夹；二是使用任务计划程序，创建一个启动时触发的任务来运行bat脚本。需确保脚本正确安全，避免对系统产生不良影响。
小王老师呀
974 0
dlwlrma-晴子
|
12月前
|
XML Java 数据库
Spring boot的最全注解
Spring boot的最全注解
dlwlrma-晴子
330 4
xionghuyi-13330
|
安全 机器人 API
AppFlow实现大模型对话自由
AppFlow是阿里云团队推出的应用与数据集成平台，它无需编程即可配置对话流程，支持接入包括通义千问、文心一言等在内的多个主流大模型。用户可以通过AppFlow与钉钉、飞书、企业微信等IM软件中的大模型进行对话。配置过程包括创建连接流，选择触发事件（如钉钉机器人接收到文本消息），配置执行动作（如使用通义千问模型提问），以及设置回调地址等步骤。此外，还提供了在钉钉创建机器人的指南，通过Outgoing功能或钉钉开放平台实现与大模型的交互。如有问题，用户可以加入官方支持钉钉群进行咨询和交流。
xionghuyi-13330
55277 9