类和对象（二）

已于 2024-03-30 13:34:14 修改
阅读量244 收藏 28
点赞数 42
分类专栏： Java基础语法 文章标签： java 开发语言
于 2023-11-05 17:29:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_77978695/article/details/134230859
版权

类和对象（二）

一：封装

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

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);
        // 创建了两个对象实例代码块和构造方法执行了两次，
        // 而静态代码块只会执行一次

    }
}

在这里插入图片描述

十一.
关注
专栏目录
类和对象常见题目详解
Edison's 小宇宙
10-19 1万+
学习完了类和对象，来看几道常见的题目吧！
java中的类和对象
m0_68989458的博客
04-16 2983
类和对象详解
类和对象
qq_43623447的博客
07-18 8596
1回顾 编程语言三部分组成： 顺序结构：从顶到下，逐步求精，每一步都会执行 分支结构：选择性的执行，条件为true执行if，条件为false执行else 循环结构：条件成立(true)的情况下重复执行某个操作 1.1循环 1.1.1 已知循环次数 ​ for( ; ; ) ​ 场景：输入一个整数判断是否为素数？ ​ 分析： 除了1和其本身以外不能被任何数整数，例如 5 97 ...
Java之类和对象
2301_79404878的博客
04-17 4507
超级详细的内容，快来瞧瞧吧。
C++_类和对象
Mr___Blue的博客
04-18 2094
快速帮助了解学习C++中类和对象的基本概念
类和对象（一）
欧尼酱的技术园
06-10 541
文章目录前言1.内联函数2.宏的优缺点3. auto关键字3.1 auto的使用方法4. 面向对象和面向过程5. 类5.1 类的定义5.1.1 类 class 和结构体 struct 的区别5.2 类的访问限定符和封装5.2.1 访问限定符5.2.2 封装5.3 类的作用域5.4 类的实例化5.5 类对象模型5.5.1 计算类对象的大小5.6 this指针5.6.1 this指针的引出5.6.2 this指针的特性总结 前言 本篇文章将带大家进一步了解C++的基础知识，本节将介绍一些C++特性并入门类和对
类和对象（1）
qq_46416934的博客
05-22 65
目录 1. C和C++的主要区别是什么？ 2. 类 3. 类的定义 类的两种定义方法 4.?类的访问限定符及封装 4.1 访问限定符 4.2? 封装 5. 类的作用域 ?6. 类的实例化 7. 类的大小 7.1 求出类的大小 1. C和C++的主要区别是什么？ C语言是面向过程的，注重的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，注重的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 2. 类 在C语言中struct只能定义变量，而在C++中struct可以
C++实验4 类和对象（二）
Laic Zhang的博客
04-30 7553
开发工具及环境：PC机一套 Visual Studio 2010 实验要求： 1.硬件基本配置：Intel PentiumIII以上级别的CPU，大于64MB的内存。 2.软件要求：Window 2000操作系统，Visual Studio 6.0或更高版本开发环 境。 3.实验学时：2学时 4.实现实验内容中的题目。 5.写实验报告 实验目的： 1． 掌握类的构造函数和析构函数的概念和使用方法 ...
python基础篇-类和对象&属性和方法&类和继承
清微的博客
05-13 2828
类和对象&属性和方法&类和继承
spring事务详细讲解-深入浅出
小电玩
09-08 539
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1521
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
yang_brother的博客
09-10 586
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 618
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 581
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
Linux服务器Java启动脚本
Jack魏
09-08 573
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
MyBatis面试
Tony_yitao的博客
09-09 794
MyBatis面试
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 372
步骤很详细，直接上教程……
Spring-di基本使用
2301_76862031的博客
09-09 1392
spirngDi环境搭建，使用流程，set注入，构造注入，对象注入，外部引入注入，内部创建注入，外部引入级联赋值注入，list集合注入，map集合注入，util注入
C++编程：类与对象深入讲解
"C++课程，主要内容涉及类和对象，包括函数...以上就是C++课件第二讲的主要内容，这些概念是理解和使用C++进行面向对象编程的基础。通过学习这些知识，开发者可以更好地组织代码，实现更高效、更易于维护的程序设计。
评论 35
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

十一.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值