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

简介: 对象之舞:Java类与对象的探索

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
相关文章
|
3月前
|
Java 编译器 API
Java 密封类:精细化控制继承关系
Java 密封类:精细化控制继承关系
277 83
|
12天前
|
安全 Java 数据建模
Java记录类:简化数据载体的新选择
Java记录类:简化数据载体的新选择
163 101
|
12天前
|
安全 Java 开发者
Java记录类:简化数据载体的新方式
Java记录类:简化数据载体的新方式
181 100
|
2月前
|
安全 IDE Java
Java记录类型(Record):简化数据载体类
Java记录类型(Record):简化数据载体类
299 120
|
4月前
|
IDE Java 数据挖掘
Java 基础类从入门到精通实操指南
这份指南专注于**Java 17+**的新特性和基础类库的现代化用法,涵盖开发环境配置、数据类型增强(如文本块)、字符串与集合处理进阶、异常改进(如密封类)、IO操作及实战案例。通过具体代码示例,如CSV数据分析工具,帮助开发者掌握高效编程技巧。同时提供性能优化建议和常用第三方库推荐,适合从入门到精通的Java学习者。资源链接:[点此下载](https://pan.quark.cn/s/14fcf913bae6)。
184 35
|
5月前
|
存储 安全 Java
【高薪程序员必看】万字长文拆解Java并发编程!(7):不可变类设计指南
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发编程中Java不可变类设计指南,废话不多说让我们直接开始。
80 0
|
2月前
|
缓存 安全 Java
Java反射机制:动态操作类与对象
Java反射机制是运行时动态操作类与对象的强大工具,支持获取类信息、动态创建实例、调用方法、访问字段等。它在框架开发、依赖注入、动态代理等方面有广泛应用,但也存在性能开销和安全风险。本文详解反射核心API、实战案例及性能优化策略,助你掌握Java动态编程精髓。
|
2月前
|
存储 安全 Java
Java集合框架(一):List接口及其实现类剖析
本文深入解析Java中List集合的实现原理,涵盖ArrayList的动态数组机制、LinkedList的链表结构、Vector与Stack的线程安全性及其不推荐使用的原因,对比了不同实现的性能与适用场景,帮助开发者根据实际需求选择合适的List实现。
|
3月前
|
Java API
Java API中Math类功能全景扫描
在实际使用时,这些方法的精确度和性能得到了良好的优化。当处理复杂数学运算或高精度计算时,`Math`类通常是足够的。然而,对于非常精细或特殊的数学运算,可能需要考虑使用 `java.math`包中的 `BigDecimal`类或其他专业的数学库。
91 11