当前位置：首页 > Java

java中类如何

2026-03-21 13:31:42Java

Java 中类的定义与使用

在 Java 中，类是面向对象编程的核心概念，用于描述对象的属性和行为。以下是一个简单的类的定义示例：

public class Person {
    // 成员变量（属性）
    private String name;
    private int age;

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

    // 成员方法（行为）
    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }

    // Getter 和 Setter 方法
    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;
    }
}

创建类的对象

要使用类，需要创建该类的实例（对象）。创建对象的语法如下：

Person person1 = new Person("Alice", 25);
person1.sayHello();  // 调用对象的方法

类的继承

Java 支持类的继承，子类可以继承父类的属性和方法。继承使用 extends 关键字：

public class Student extends Person {
    private String school;

    public Student(String name, int age, String school) {
        super(name, age);  // 调用父类的构造方法
        this.school = school;
    }

    public void study() {
        System.out.println(name + " is studying at " + school);
    }
}

类的多态

多态允许子类重写父类的方法，实现不同的行为：

public class Teacher extends Person {
    public Teacher(String name, int age) {
        super(name, age);
    }

    @Override
    public void sayHello() {
        System.out.println("Hello, I am a teacher named " + getName());
    }
}

抽象类

抽象类不能被实例化，只能被继承。抽象类可以包含抽象方法（没有实现的方法）：

public abstract class Animal {
    public abstract void makeSound();

    public void sleep() {
        System.out.println("The animal is sleeping.");
    }
}

接口

接口是一种完全抽象的类，用于定义行为规范：

public interface Drawable {
    void draw();
}

public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

类的访问修饰符

Java 提供了访问修饰符来控制类的可见性：

public: 类可以被任何其他类访问。
default (无修饰符): 类只能被同一包中的其他类访问。
abstract: 类不能被实例化，只能被继承。
final: 类不能被继承。

静态成员

静态成员属于类本身，而不是类的实例：

public class MathUtils {
    public static final double PI = 3.14159;

    public static int add(int a, int b) {
        return a + b;
    }
}

// 使用静态成员
double pi = MathUtils.PI;
int sum = MathUtils.add(5, 3);

内部类

内部类是定义在另一个类中的类：

java中类如何

public class OuterClass {
    private int outerField;

    public class InnerClass {
        public void display() {
            System.out.println("Outer field: " + outerField);
        }
    }
}

// 创建内部类实例
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
inner.display();

标签: java