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

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

2024-05-09 20
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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
目录
相关文章
toKeep
|
5天前
|
Java 编译器
java中类与对象回顾总结-1
java中类与对象回顾总结
toKeep
14 3
cuicuicuic
|
4天前
|
消息中间件 Java RocketMQ
MQ产品使用合集之在同一个 Java 进程内建立三个消费对象并设置三个消费者组订阅同一主题和标签的情况下，是否会发生其中一个消费者组无法接收到消息的现象
消息队列（MQ）是一种用于异步通信和解耦的应用程序间消息传递的服务，广泛应用于分布式系统中。针对不同的MQ产品，如阿里云的RocketMQ、RabbitMQ等，它们在实现上述场景时可能会有不同的特性和优势，比如RocketMQ强调高吞吐量、低延迟和高可用性，适合大规模分布式系统；而RabbitMQ则以其灵活的路由规则和丰富的协议支持受到青睐。下面是一些常见的消息队列MQ产品的使用场景合集，这些场景涵盖了多种行业和业务需求。
cuicuicuic
10 1
秋说
|
5天前
|
Java 编译器
【Java开发指南 | 第一篇】类、对象基础概念及Java特征
【Java开发指南 | 第一篇】类、对象基础概念及Java特征
秋说
11 4
长梦
|
5天前
|
安全 Java 数据安全/隐私保护
Java一分钟之-Java反射机制：动态操作类与对象
【5月更文挑战第12天】本文介绍了Java反射机制的基本用法，包括获取Class对象、创建对象、访问字段和调用方法。同时，讨论了常见的问题和易错点，如忽略访问权限检查、未捕获异常以及性能损耗，并提供了相应的避免策略。理解反射的工作原理和合理使用有助于提升代码灵活性，但需注意其带来的安全风险和性能影响。
长梦
23 4
java开发-郭老师
|
5天前
|
Java
【JAVA基础篇教学】第五篇：Java面向对象编程：类、对象、继承、多态
【JAVA基础篇教学】第五篇：Java面向对象编程：类、对象、继承、多态
java开发-郭老师
19 1
菜菜的后端私房菜
|
5天前
|
缓存 Java 程序员
关于创建、销毁对象⭐Java程序员需要掌握的8个编程好习惯
关于创建、销毁对象⭐Java程序员需要掌握的8个编程好习惯
菜菜的后端私房菜
20 5
关于创建、销毁对象⭐Java程序员需要掌握的8个编程好习惯
toKeep
|
5天前
|
Java
从源码出发：JAVA中对象的比较
从源码出发：JAVA中对象的比较
toKeep
20 3
长梦
|
5天前
|
Java
Java一分钟之-类与对象：面向对象编程入门
【5月更文挑战第8天】本文为Java面向对象编程的入门指南，介绍了类与对象的基础概念、常见问题及规避策略。文章通过代码示例展示了如何定义类，包括访问修饰符的适当使用、构造器的设计以及方法的封装。同时，讨论了对象创建与使用时可能遇到的内存泄漏、空指针异常和数据不一致等问题，并提供了相应的解决建议。学习OOP需注重理论与实践相结合，不断编写和优化代码。
长梦
30 1
Yeats_Liao
|
5天前
|
SQL Java 数据库连接
15：MyBatis对象关系与映射结构-Java Spring
15：MyBatis对象关系与映射结构-Java Spring
Yeats_Liao
31 4
屿小夏
|
5天前
|
Java 编译器
【Java探索之旅】解密构造方法 对象初始化的关键一步
【Java探索之旅】解密构造方法 对象初始化的关键一步
屿小夏
17 1

热门文章

最新文章

  • 1
    使用Redis进行Java缓存策略设计
  • 2
    Java语言开发的AI智慧导诊系统源码springboot+redis 3D互联网智导诊系统源码
  • 3
    【JAVA】Java 中什么叫单例设计模式？请用 Java 写出线程安全的单例模式
  • 4
    基于Java的公司员工工作日志办公系统的设计与实现(源码+lw+部署文档+讲解等)
  • 5
    【JAVA】线程的run()和start()有什么区别？
  • 6
    高德地图爬虫实践：Java多线程并发处理策略
  • 7
    [AIGC] 21世纪Java与Go的相爱相杀
  • 8
    Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
  • 9
    打造个人的Minecraft服务器：Java+cpolar实现我的世界联机游戏
  • 10
    Java 开发者必备：JDK 版本详解与选择策略(含安装与验证)
  • 1
    Java中的集合框架：深入理解与应用
    46
  • 2
    Java并发编程：理解并使用Future和Callable接口
    24
  • 3
    性能工具之 Java 调试工具 JDB
    50
  • 4
    JAVA云HIS系统医院信息管理源码
    35
  • 5
    Java基于物联网技术的智慧工地云管理平台源码 依托丰富的设备接口标准库，快速接入工地现场各类型设备
    156
  • 6
    [Java基础]——类的生命周期
    20
  • 7
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    32
  • 8
    【java进阶】Java中线程的实现方式
    27
  • 9
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    22
  • 10
    [java进阶]——方法引用改写Lambda表达式
    37

    • 相关课程

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

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 面向对象-1：类的定义
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • Elasticsearch Java API Client 开发
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考