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

java中类与对象回顾总结-2

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

java中类与对象回顾总结-1

https://developer.aliyun.com/article/1503952


三 类的方法

方法：用来描述对象的行为

对于一种特殊的称为构造方法，在后面的文章中详细讲解，本篇文章主要讲解类的普通方法。

（1）普通成员方法

class Person{
    public static int count;
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+"在睡觉");
    }
    public void sleep(){
        change();
        //Static int one = 1;error
        System.out.println(name+"在吃饭");
    }
    public static void change(){
        //sleep()error
        count=10;

    }

}
public class practiceone{
    public static void main(String[] args) {
        Person person = new Person();
        person.name="java";
        person.eat();
        person.sleep(); 
        }
}

在普通成员方法是可以对静态方法进行调用，但是在静态方法里面是不能定义静态成员变量的，这是因为静态成员变量是属于类的，而不属于方法。


（2）静态成员方法

从上面代码分析可以得出，静态成员方法内不能调用普通成员方法，因为静态方法与静态成员变量都是属于类的，不依赖于对象。而普通成员方法依赖于对象。也说明静态方法不能直接使用普通成员变（非静态数据成员）。


类与对象的关键E点：

静态变量与静态方法属于类，而且两者都不依赖于对象

对于普通成员方法以及普通成员变量都必须依赖于对象，换句话说必须要通过关键字new去进行实例化对象。


疑难解答：

问：对于Java中main函数为什么是静态的？

这是因为JVM在底层对于main函数的加载就是使用了静态的，换句话说就是静不静态都是可以的，这个是取决于JVM的（对于JVM的我们后续文章详解）


四 private封装

puplic与paivate两个关键字都是表示访问控制权限，

被puplic修饰的字段和方法，可以直接被类的使用者进行调用，

被private修饰的方法与字段是不可以直接被类的使用者进行调用

对于public修饰进行对象的访问前面我们已经讲解过，这里不多做赘述

下面通过具体的代码来分析一下

class Person{
    private int age;
    private String name;
    private void eat(){
        System.out.println("在睡觉");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.age=10;//error
        person.eat;//error
    }
}


图中标注error的是编译器报错，这个主要就是关键字private的作用了，通过private关键字进行修饰字段与方法，那么该字段与方法的作用范围只能是在当前类下，类的调用者据访问不到这些字段与方法。这个就是我们所说的private封装，封装的作用其实就是为了让代码更加的安全。


五 setter与getter

对于实现private封装的类，里面的字段我们可以通过java中提供的setter于getter方法进行访问。（注意这里是对字段进行访问，方法是不使用这个的）

class Person{
    private int age;
    private String name;
    public void setAge(int age) {
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    private void eat(){
        System.out.println("在睡觉");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(10);
        person.setName("java");
    }
}

注意这里的getter与setter方法我们是可以通过IDEA自动帮助生成，通过快捷键Alt+insert就可以进行设置，这个通过自己多动手就知道是怎样生成。

六 toString打印

与getter与setter快捷键一致，可以生成自动将对象转化为字符串的形式输出，这一过程（对象转化为字符串）我们称为序列化。

  @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

@Override 在 Java 中称为 "注解“，toString 方法会在 println 的时候被自动调用。


七 构造方法（重点理解）

在前面我们讲过普通的方法，这里我们需要理解一个特殊并且很重要的一个方法，就是构造方法。构造方法在使用关键字new实例化新对象时会被自动调用,

构造方法的意义：构造对象，对象的实例化。

class Person{
    private int age;
    private String name;
    private void eat(){
        System.out.println("在睡觉");
    }
    public Person(){//构造方法
        System.out.println("构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

运行结果：

构造方法

class Person{
    private int age;
    private String name;
    private void eat(){
        System.out.println("在睡觉");
    }
    public Person(){//构造方法
        System.out.println("构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        Person person1=new Person("java");
        Person person2 = new Person("java",1);
    }
}

构造方法要点总结：

从以上我们可以看出构造方法不止一个，可以是多个，并且构造方法之间构成了重载。

构造方法每一个类中至少含有一个，如果自己没有写构造方法，那么编译器自动会生成一个不带任何参数的构造方法，如果自己写了构造方法，那么编译器就不会在生成不带参数的构造方法。


八 this关键字

this要注意的一点就是表示当前对象的引用，而不是当前对象，this一共有三种用法，

1 this调用当前对象的属性（this.data）

class Person {
    private int age;
    private String name;

    private void eat() {
        System.out.println("在睡觉");
    }

    public void setAge(int age) {
        this.age = age;//this调用当前对象的属性
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

2 this调用当前对象的方法（this.func()）

class Person {
    private int age;
    private String name;

    private void eat() {
        System.out.println("在睡觉");
    }
    private void sleep(){
        this.eat();//调用当前对象的方法
        System.out.println("在吃饭");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

3 this调用其他构造函数(this())

class Person {
    private int age;
    private String name;
    public Person(){
        this("java");//调用其他构造函数
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

在这里调用其他构造函数时，this的调用必须放在第一行，如果写入了两个this那么这个时候编译器就会报错，那么两个this里面只能选择一个了。要注意的是这个this（）的使用情况是在一个构造方法里去调用另一个构造方法，在其他情况不能这样用。


九代码块

在这里我们主要介绍实例代码块与静态代码块，对于同步代码块后续的内容会进行阐述，而本地代码块比较简单，这里就不多加以描述。


1 实例代码块

定义：定义在类中的代码块(不加修饰符)。构造代码块一般用于初始化实例成员变量。

2 静态代码块

定义：使用static定义的代码块。一般用于初始化静态成员属性。就是在实例化代码块前加以static修饰，那么此时这个代码块就是静态代码块


3 探究两者之间的关系

class Person {
    private int age;
    private String name;
    {
        System.out.println("实例代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

运行结果：

静态代码块

实例代码块

不带参数的构造方法

从运行结果上去分析，我们可以看出静态代码块以及实例化代码块都比构造方法更早执行，方法是最后执行的。

class Person {
    private int age;
    private String name;
    {
        System.out.println("实例代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("===========");
        Person person1 = new Person("java");
    }
}

运行结果

静态代码块

实例代码块

不带参数的构造方法

===========

实例代码块

带一个参数的构造方法

从上面这一个代码，我们可以看出静态代码块只能执行一次，而实例代码块执行与对象实例化的次数有关。

class Person {
    private int age;
    private String name;
    static int count=10;
    {
        System.out.println("实例代码块");
    }
    static{
        count=90;
        System.out.println("静态代码块");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

运行结果：

静态代码块

90

从以上代码可以看出静态代码是不需要通过关键字new实例化对象就能使用的，而实例化代码块是需要先实例化对象的。

class Person {
    private int age;
    private String name;

    {
        System.out.println("实例代码块");
    }
    static{
        count=90;
        System.out.println("静态代码块");
    }
    static int count=10;
}
public class TestDemo {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

运行结果：

静态代码块

10

这里对比上一个代码我们发先就是static定义的静态成员变量位置不同，导致count的值不同，说明这个count的值与static执行的顺序有关（这里要特别提一下，static后定义静态成员变量这种java的语法是支持的，不会报错）。在这里有一个特殊的例子，就是count没有初始化值，那么它的值就不与这个执行顺序有关，count就等于99，而不等于10了。


十 匿名对象

class Person {
    private int age;
    public String name;
    static int count=10;
    public void eat(){
        System.out.println("睡觉");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        new Person().eat();
    }
}

运行结果：

睡觉

如上代码所示，不需要通过之前那样利用person作为引用去实例化对象，直接通过关键字new创建对象就被称为匿名对象，一个对象只能用一次。


总结：

1 被private修饰的属性，需要通过java提供的setter与getter方法进行访问操作。

2 静态代码块总是最先执行的，并且只执行一次，不需要实例化对象也能执行，实例代码块执行在构造方法之前，构造方法在最后

3 在this这个关键字中，它表示的是对当前对象的引用，不是当前对象。


对于this的详细讲解可以参考以下这篇文章：

this的使用详解

文章标签：
Java
编译器
数据安全/隐私保护
安全
关键词：
Java对象
Java类与对象
Java类与对象回顾总结
toKeep
目录
相关文章
BigFour
|
6月前
|
设计模式 网络协议 数据可视化
Java 设计模式之状态模式：让对象的行为随状态优雅变化
状态模式通过封装对象的状态，使行为随状态变化而改变。以订单为例，将待支付、已支付等状态独立成类，消除冗长条件判断，提升代码可维护性与扩展性，适用于状态多、转换复杂的场景。
BigFour
911 157
艾伦~耶格尔
|
8月前
|
缓存 安全 Java
Java反射机制：动态操作类与对象
Java反射机制是运行时动态操作类与对象的强大工具，支持获取类信息、动态创建实例、调用方法、访问字段等。它在框架开发、依赖注入、动态代理等方面有广泛应用，但也存在性能开销和安全风险。本文详解反射核心API、实战案例及性能优化策略，助你掌握Java动态编程精髓。
艾伦~耶格尔
255 1
武汉频琵
|
8月前
|
存储 人工智能 JavaScript
Java从作用域到对象高级应用​
本内容详细讲解了JavaScript中的作用域类型（函数作用域、块作用域、全局作用域）、作用域链、垃圾回收机制、闭包、变量提升、函数参数、数组方法、内置构造函数、对象高级知识、原型链、对象赋值、深浅拷贝、递归、异常处理及this指向等内容，全面覆盖JS核心概念与编程技巧。
武汉频琵
101 0
啦啦啦191
|
10月前
|
Java 数据库连接 API
Java 对象模型现代化实践 基于 Spring Boot 与 MyBatis Plus 的实现方案深度解析
本文介绍了基于Spring Boot与MyBatis-Plus的Java对象模型现代化实践方案。采用Spring Boot 3.1.2作为基础框架，结合MyBatis-Plus 3.5.3.1进行数据访问层实现，使用Lombok简化PO对象，MapStruct处理对象转换。文章详细讲解了数据库设计、PO对象实现、DAO层构建、业务逻辑封装以及DTO/VO转换等核心环节，提供了一个完整的现代化Java对象模型实现案例。通过分层设计和对象转换，实现了业务逻辑与数据访问的解耦，提高了代码的可维护性和扩展性。
啦啦啦191
400 1
啦啦啦191
|
10月前
|
前端开发 Java 数据库连接
java bo 对象详解_全面解析 java 中 PO,VO,DAO,BO,POJO 及 DTO 等几种对象类型
Java开发中常见的六大对象模型（PO、VO、DAO、BO、POJO、DTO）各有侧重，共同构建企业级应用架构。PO对应数据库表结构，VO专为前端展示设计，DAO封装数据访问逻辑，BO处理业务逻辑，POJO是简单的Java对象，DTO用于层间数据传输。它们在三层架构中协作：表现层使用VO，业务层通过BO调用DAO处理PO，DTO作为数据传输媒介。通过在线商城的用户管理模块示例，展示了各对象的具体应用。最佳实践包括保持分层清晰、使用工具类转换对象，并避免过度设计带来的类膨胀。理解这些对象模型的区别与联系。
啦啦啦191
858 0
大数据文摘
|
9月前
|
存储 Java
Java对象的内存布局
在HotSpot虚拟机中，Java对象的内存布局分为三部分：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。对象头包含Mark Word、Class对象指针及数组长度；实例数据存储对象的实际字段内容；对齐填充用于确保对象大小为8字节的整数倍。
大数据文摘
187 0
蓝易云
|
11月前
|
Java
深入JavaSE：详解Java对象的比较。
总的来说，Java对象的比较就像海洋生物的比较，有外在的，有内在的，有面对所有情况的，也有针对特殊情况的。理解并掌握这些比较方式，就能更好地驾驭Java的世界，游刃有余地操作Java对象。
蓝易云
486 12
蓝易云
|
编解码 JavaScript 前端开发
【Java进阶】详解JavaScript的BOM（浏览器对象模型）
总的来说，BOM提供了一种方式来与浏览器进行交互。通过BOM，你可以操作窗口、获取URL、操作历史、访问HTML文档、获取浏览器信息和屏幕信息等。虽然BOM并没有正式的标准，但大多数现代浏览器都实现了相似的功能，因此，你可以放心地在你的JavaScript代码中使用BOM。
蓝易云
364 23
智物科技库
|
Java 数据安全/隐私保护
Java 类和对象
本文介绍了Java编程中类和对象的基础知识，作为面向对象编程(OOP)的核心概念。类是对象的蓝图，定义实体类型；对象是具体实例，包含状态和行为。通过示例展示了如何创建表示汽车的类及其实例，并说明了构造函数、字段和方法的作用。同时，文章还探讨了访问修饰符的使用，强调封装的重要性，如通过getter和setter控制字段访问。最后总结了类与对象的关系及其在Java中的应用，并建议进一步学习继承等概念。
智物科技库
278 1
Remember_Ray
|
设计模式 缓存 Java
重学Java基础篇—Java对象创建的7种核心方式详解
本文全面解析了Java中对象的创建方式，涵盖基础到高级技术。包括`new关键字`直接实例化、反射机制动态创建、克隆与反序列化复用对象，以及工厂方法和建造者模式等设计模式的应用。同时探讨了Spring IOC容器等框架级创建方式，并对比各类方法的适用场景与优缺点。此外，还深入分析了动态代理、Unsafe类等扩展知识及注意事项。最后总结最佳实践，建议根据业务需求选择合适方式，在灵活性与性能间取得平衡。
Remember_Ray
767 3

热门文章

最新文章

  • 1
    如何降低90%Java垃圾回收时间？以阿里HBase的GC优化实践为例
  • 2
    如何用 Java 压缩 ZIP 文件？
  • 3
    深入解析 Java @RestController 注解：构建现代化的RESTful API
  • 4
    IO实战篇：数字大小比较 | 带你学《Java语言高级特性》之七十二
  • 5
    java B2B2C Springcloud电子商务平台源码------Hystrix的缓存使用
  • 6
    Java枚举类型介绍
  • 7
    【8】JAVA---地址App小软件（AddrDaoFile .class）（数据层）
  • 8
    java: ant 脚本示例
  • 9
    学习:java代码检测
  • 10
    java学习：字符串比较“==”与“equals”的差异及与c#的区别
  • 1
    Java 设计模式之策略模式：灵活切换算法的艺术
    1670
  • 2
    Java 设计模式之观察者模式：构建松耦合的事件响应系统
    537
  • 3
    Java 设计模式之状态模式：让对象的行为随状态优雅变化
    911
  • 4
    java零基础学习者入门课程
    577
  • 5
    Java 设计模式之责任链模式：优雅处理请求的艺术
    719
  • 6
    【Azure Storage Account】Java Code访问Storage Account File Share的上传和下载代码示例
    488
  • 7
    百宝箱开放平台 ✖️ Java SDK
    1547
  • 8
    《深入理解Spring》：现代Java开发的核心框架
    931
  • 9
    用Java语言实现一个自定义的ArrayList类
    283
  • 10
    从混沌到秩序：Java共享内存模型如何通过显式约束驯服并发？
    198

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    阿里云重磅发布Agentic SOC，企业级AI Agent驱动的安全运营平台