对象之舞：Java类与对象的探索

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量311 收藏 35
点赞数 45
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwsbcjendb/article/details/131927508
版权

类和对象

1. 面向对象概述

1.1 对象

对象是类的一个实例，可以有属性和方法。属性是对象的特征，方法是对象的行为。

1.2 类

类是对象的抽象，描述了具有共同属性和行为的一组对象。

1.3 封装

封装是将属性和方法封装在类中，不允许外部直接访问和修改对象的属性，只能通过类的方法进行操作。封装可以提高代码的安全性和可维护性。

示例代码：

public class Person {
    private String name;
    private int age;
  
    public String getName() {
        return name;
    }
  
    public void setName(String name) {
        this.name = name;
    }
  
    public int getAge() {
        return age;
    }
  
    public void setAge(int age) {
        this.age = age;
    }
}

1.4 继承

继承是一种机制，可以让一个类继承另一个类的属性和方法。子类可以继承父类的所有非私有成员(属性和方法)。通过继承，可以实现代码的复用和层次化设计。

示例代码：

public class Student extends Person {
    private int grade;
  
    public int getGrade() {
        return grade;
    }
  
    public void setGrade(int grade) {
        this.grade = grade;
    }
}

1.5 多态

多态是一种特性，在面向对象编程中，它允许能够处理不同类型对象的代码在不同类型对象上执行不同的操作。多态使得代码更加灵活和可扩展。

示例代码：

public class Animal {
    public void sound() {
        System.out.println("Animal makes sound");
    }
}

public class Cat extends Animal {
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class Dog extends Animal {
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Cat();
        Animal animal2 = new Dog();
        animal1.sound(); // Output: Cat meows
        animal2.sound(); // Output: Dog barks
    }
}

2. 类

2.1 成员变量

成员变量是定义在类中的变量，可以被类的所有方法访问。它们存储对象的状态信息。

示例代码：

public class Student {
    String name; // 成员变量
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void display() {
        System.out.println("Name: " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("John");
        student.display(); // Output: Name: John
    }
}

2.2 成员方法

成员方法是定义在类中的方法，可以通过对象调用。它们对对象的操作和行为进行定义和实现。

示例代码：

public class Circle {
    double radius; // 成员变量
    
    public void setRadius(double radius) {
        this.radius = radius;
    }
    
    public double getArea() {
        return 3.14 * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.setRadius(5.0);
        double area = circle.getArea();
        System.out.println("Area: " + area); // Output: Area: 78.5
    }
}

2.3 权限修饰符

权限修饰符用于控制类、变量和方法的访问权限。Java提供了四种权限修饰符：private、default、protected和public。

示例代码：

public class Person {
    private String name; // 只能在本类中访问
    
    String gender; // 只能在本包中访问
    
    protected int age; // 只能在本包和子类中访问
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}

2.4 局部变量

局部变量是在方法、构造方法或代码块中定义的变量，只在其所在的范围内有效。局部变量必须在使用前初始化。

示例代码：

public class Calculator {
    public int add(int num1, int num2) {
        int sum = num1 + num2; // 局部变量
        return sum;
    }
    
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        int result = calculator.add(5, 3);
        System.out.println("Sum: " + result); // Output: Sum: 8
    }
}

2.5 局部变量的有效范围

局部变量的有效范围是从其声明的位置开始，到其所在的代码块结束。超出该范围后，局部变量将不再可见。

示例代码：

public class Rectangle {
    public void calculateArea() {
        int length = 10; // 局部变量
        int width = 5; // 局部变量
        int area = length * width;
        System.out.println("Area: " + area); // Output: Area: 50
    }
}

2.6 this关键字

this关键字用于引用当前对象，可以在类的成员方法中使用。它可以解决变量名冲突和区分实例变量和局部变量的问题。

示例代码：

public class Car {
    private String color; // 成员变量
    
    public void setColor(String color) {
        this.color = color; // 使用this关键字引用成员变量
    }
    
    public void displayColor() {
        String color = "Blue"; // 局部变量
        System.out.println("Local color: " + color); // Output: Local color: Blue
        System.out.println("Instance color: " + this.color); // Output: Instance color: Red
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.setColor("Red");
        car.displayColor();
    }
}

3 类的构造方法

构造方法是一种特殊的方法，用于创建对象时进行对象的初始化操作。构造方法的名称必须与类名相同，并且没有返回类型。

示例代码：

public class Person {
    private String name;
    private int age;
  
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
  
    // getter和setter方法
  
    // ...
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
    }
}

上述代码创建了一个名为Person的类，并定义了一个带有两个参数的构造方法。在main方法中，通过调用构造方法创建了一个名为person的Person对象。

4 静态变量和静态方法

静态变量是属于类的变量，所有对象共享同一个静态变量的值。静态方法是属于类的方法，可以直接通过类名调用，无需创建对象。

示例代码：

public class Person {
    private String name;
    private static int count; // 静态变量
  
    public Person(String name) {
        this.name = name;
        count++;
    }
  
    public static void printCount() { // 静态方法
        System.out.println("Count: " + count);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("Alice");
        Person person2 = new Person("Bob");
      
        Person.printCount(); // 直接通过类名调用静态方法
    }
}

上述代码中，定义了一个名为Person的类，并包含一个静态变量count和一个静态方法printCount。在构造方法中，每次创建对象时，count的值都会增加。在main方法中，创建了两个Person对象，并通过Person.printCount()直接调用静态方法。

输出结果：

Count: 2

5. 类的主方法

主方法(即main方法)是Java程序的入口点，程序从这里开始执行。主方法必须是public、static和void类型，并且接受一个String数组作为参数。

示例代码：

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

上述代码中，定义了一个名为Main的类，并包含一个名为main的主方法。在主方法中，调用System.out.println打印"Hello, World!"。

输出结果：

Hello, World!

6. 对象

6.1 对象的创建

在Java中，使用new关键字可以创建一个对象。创建对象时需要调用类的构造方法来初始化对象的属性和执行其他操作。

示例代码：

public class Person {
    private String name;
    private int age;
  
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
    }
}

上述代码创建了一个名为person的Person对象，传入了"name"和"age"参数来初始化对象的属性。

6.2 访问对象的属性和行为

通过对象的引用，可以访问对象的属性和调用对象的方法。

示例代码：

public class Person {
    private String name;
    private int age;
  
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
  
    public void printInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
        person.printInfo();
    }
}

上述代码创建了一个名为person的Person对象，并调用了对象的printInfo()方法输出对象的信息。

输出结果：

Name: Alice
Age: 25

6.3 对象的引用

在Java中，创建对象时会在堆内存中分配空间，并返回一个对象的引用。通过引用可以操作对象，包括访问对象的属性和调用对象的方法。

示例代码：

public class Person {
    private String name;
    private int age;
  
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
  
    public String getName() {
        return name;
    }
  
    public void setName(String name) {
        this.name = name;
    }
  
    public int getAge() {
        return age;
    }
  
    public void setAge(int age) {
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 25);
        Person person2 = person1;
        person2.setName("Bob");
        System.out.println(person1.getName()); // Output: Bob
    }
}

上述代码中，创建了一个名为person1的Person对象，并将该对象的引用赋值给person2。然后通过person2对象的引用，修改了person1对象的name属性，并输出了person1对象的name属性值。

输出结果：

Bob

6.4 对象的销毁

在Java中，对象的销毁是由垃圾回收器负责的。一般情况下，当对象没有被引用时，即没有任何引用指向该对象，垃圾回收器会自动将该对象回收。

示例代码：

public class Person {
    // ...
  
    public void finalize() {
        System.out.println("Object is being destroyed");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person = null; // 解除对象引用
        System.gc(); // 请求垃圾回收器执行
    }
}

上述代码中，在main方法中创建了一个Person对象，并将person变量的引用设置为null。然后通过System.gc()请求垃圾回收器执行，当垃圾回收器执行时，会调用Person类的finalize()方法输出"Object is being destroyed"。

输出结果：

Object is being destroyed
无敌泡泡糖
关注
  • 45
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 41
    评论
java打印对象头信息_打印Java对象头
weixin_28737399的博客
02-27 2040
打印Java对象头对象头形式JVM中对象头的方式有以下两种(以32位JVM为例)普通对象|--------------------------------------------------------------|| Object Header (64 bits) ||---------------------------...
simplemapper:探索 Java 注释和反射的小库
07-09
探索 Java 注释和反射的小库。 这是实验代码，不打算用于生产。 允许将字符串列表可遍历的任意输入对象的字段映射到带注释的 POJO 的字段。 POJO 的字段必须是公共的，或者提供公共的 setter 方法。 输入对象的值...
Java反射：探索对象创建与类信息获取
学IT，找陈寒
09-06 1018
反射是Java中一个强大而灵活的机制，允许我们在运行时获取和操作类的信息。通过获取Class对象、构造器对象、成员变量对象和成员方法对象，我们可以实现动态创建对象、修改属性和调用方法的功能。反射虽然强大，但也需要谨慎使用，因为它会降低代码的可读性和性能。在实际应用中，应该根据需要谨慎使用反射，以充分发挥其优势。希望本文能够帮助您理解反射的基本原理和用法，使您能够更灵活地编写Java应用程序，并更好地应对各种复杂的情况。在深入学习和实践中，您将更好地掌握反射这一强大工具，提高自己的编程技能。🧸结尾😊🙏。
深入探索Java中最常用的对象：String类
喵手的博客
05-19 945
Java作为世界上最流行的编程语言之一，其强大的字符串处理能力是其广受欢迎的重要原因之一。本文将介绍Java中的String类，包括其定义，用法，应用场景等内容。在本文中，我们将介绍Java中String类的基本概念。我们将从源代码解析开始，然后讨论其应用场景和优点与缺点，接着介绍类的代码方法，并提供一些测试用例来加深读者对该类的理解。String类是Java语言中一个非常重要的类。简单来说，String类表示了一个字符串对象。文本信息图像信息音频信息。
深入探索Java反射机制：解析原理与应用
沉淀、分享、成长，让自己和他人都能有所收获！
07-03 6933
Java反射机制是一项强大的技术，它允许程序在运行时动态地获取和操作类、对象、方法和属性。本文将深入探索Java反射机制的原理和应用，带您揭开隐藏在代码背后的魔法。我们将从基本概念入手，逐步介绍反射的核心概念、使用方法和常见应用场景。通过学习本文，您将更好地理解Java反射机制，并能够在实际项目中灵活运用。
Java面向对象与代码编写
悦分享
08-25 3392
Java面向对象与代码编写 面向过程的思想和面向对象的思想 面向对象和面向过程的思想有着本质上的区别,作为面向对象的思维来说，当你拿到一个问题时，你分析这个问题不再是第一步先做什么，第二步再做什么，这是面向过程的思维，你应该分析这个问题里面有哪些类和对象，这是第一点，然后再分析这些类和对象应该具有哪些属性和方法。这是第二点。最后分析类和类之间具体有什么关系，这是第三点。 ...
【JAVA-Day56】Java面向对象编程：深入理解类、对象、属性和方法的核心概念
热门推荐
沉淀、分享、成长，让自己和他人都能有所收获！
10-30 2万+
作为一名博主，我们将在本篇技术博客中深入研究Java面向对象编程的核心概念，包括类、对象、属性和方法。我们将详细探讨这些概念，加入小表情使文章更生动有趣。让我们一起探索这个令人兴奋的领域！在Java中，类是一种抽象数据类型，它是用于描述对象的模板或蓝图。类定义了对象的属性（也称为字段）和方法，这些属性和方法描述了对象的特征和行为。而对象则是类的实例，是实际存在的数据实体，可以拥有不同的属性值，但都共享同一类定义的方法。使用类和对象能够更有效地组织和管理代码，为现实世界中的概念和实体提供了模型化的方式。
【Java探索之旅】用面向对象的思维构建程序世界
屿小夏.的知识博客
04-20 2万+
面向对象编程（OOP）是一种强大的编程范式，Java作为一门纯面向对象的语言，通过对象之间的交互来解决问题，使得程序设计更加灵活、易于维护和扩展。本文将介绍面向对象的基本概念、类的定义和使用，以及类的实例化过程，帮助读者初步了解面向对象编程的核心思想和实践方法。Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。
【Java探索之旅】我与Java的初相识(一)：Java的特性与优点及其发展史
屿小夏.的知识博客
12-08 1万+
​ Java是一种优秀的程序设计语言，它具有令人赏心悦目的语法和易于理解的语义。​ 不仅如此Java还是一个有一系列计算机软件和规范形成的技术体系，这个技术体系提供了完整的用于软件开发和跨平台部署的支持环境，并广泛应用于嵌入式系统、移动终端、企业服务器、大型机等各种场合。
深入探索Java并发容器：ConcurrentHashMap详解与实战
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-19 1万+
ConcurrentHashMap以其独特的设计理念和精巧的实现方式，成功解决了多线程环境下的数据共享问题。了解并掌握ConcurrentHashMap的工作原理及其在并发编程中的最佳实践，对于提高Java应用程序的性能和稳定性具有重要意义。开发者应当根据实际需求选择合适的API方法，充分利用ConcurrentHashMap所提供的并发优势。
EverBlaze：具有自定义故事情节，战斗和探索的Java流氓对象
02-05
具有自定义故事情节，战斗和探索的Java类。 60％完成 产品特点 通过加密的JSON保存游戏 自定义库存机制，怪物战斗，宝藏 用LibGDX Java构建 下载 从发布页面下载最新版本 克隆存储库并加载到IntelliJ IDEA或Eclipse...
高职面向对象程序设计(Java)课的教学探索与实践.pdf
12-27
高职面向对象程序设计(Java)课的教学探索与实践
深入探索Java对象的序列化
04-24
深入探索Java对象的序列化 对象序列化就是把对象写入到输出流中，用来存储或者传输。 对象的反序列化就是从输入流中读取对象。 要序列化的对象应该实现Serializable接口。 Serializable接口是一个标识接口，...
码出高效：Java 开发手册
02-26
《码出高效：Java 开发手册》以实战为中心，以新颖的角度全面阐述面向对象理论，逐步深入地探索怎样成为一位优秀开发工程师。比如：如何驾轻就熟地使用各类集合框架；如何得心应手地处理高并发多线程问题；如何顺其...
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 892
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 898
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1209
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 671
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
武汉理工大学-java面向对象与多线程综合实验csdn
12-28
武汉理工大学的Java面向对象与多线程综合实验是一个非常具有挑战性和实用性的实验课程。该课程主要围绕Java编程语言的面向对象特性和多线程编程进行深入实践和探索，在CSND平台上进行讲解和实践。 在这门课程中，学生将通过实践项目来加深对面向对象设计和多线程编程的理解。通过完成不同的项目，学生可以掌握Java语言的面向对象设计原则和思想，掌握多线程编程的基本原理和实际运用。这门课程的实验项目丰富多样，涉及到实际的软件开发和设计，让学生能够运用所学知识解决实际问题，提高实际编程能力。 在CSND平台上，学生可以找到大量的学习资源和实践项目，通过视频教程和实验文档，学生可以很好地理解和掌握课程内容。实验课程还提供了实时交流和讨论的平台，学生可以在这里和老师、同学们进行交流和讨论问题，相互学习和提高。 总的来说，武汉理工大学的Java面向对象与多线程综合实验课程在CSND平台上的教学资源和实践项目非常丰富，能够很好地帮助学生掌握Java编程语言的面向对象和多线程编程的知识和技能，为日后的软件开发和工程实践打下坚实的基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 41
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

无敌泡泡糖

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

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

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

打赏作者

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

抵扣说明：

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

余额充值