java类里面如何写

Java 类的基本结构

Java 类通常包含以下组成部分：类声明、字段（成员变量）、构造方法、普通方法以及可能的代码块。

// 类声明
public class ClassName {
    // 字段（成员变量）
    private int field1;
    private String field2;

    // 构造方法
    public ClassName(int field1, String field2) {
        this.field1 = field1;
        this.field2 = field2;
    }

    // 普通方法
    public void method1() {
        System.out.println("Method1 called");
    }

    // 静态方法
    public static void staticMethod() {
        System.out.println("Static method called");
    }

    // Getter 和 Setter
    public int getField1() {
        return field1;
    }

    public void setField1(int field1) {
        this.field1 = field1;
    }
}

类的基本组成部分

类声明：使用 public class ClassName 定义类名，类名通常采用大驼峰命名法（如 Student、Car）。

字段（成员变量）：定义类的属性，通常使用 private 修饰符封装，并通过 getter 和 setter 方法访问。

构造方法：用于初始化对象，名称与类名相同，无返回类型。可以重载多个构造方法以适应不同初始化需求。

普通方法：定义类的行为，可以带参数和返回值。

静态方法：使用 static 修饰，属于类而非对象，可直接通过类名调用。

示例：定义一个简单的 Student 类

public class Student {
    private String name;
    private int age;

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

    // Getter 方法
    public String getName() {
        return name;
    }

    // Setter 方法
    public void setName(String name) {
        this.name = name;
    }

    // 普通方法
    public void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

类的继承

Java 支持单继承，使用 extends 关键字实现。

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

接口的实现

Java 类可以实现多个接口，使用 implements 关键字。

public interface Flyable {
    void fly();
}

public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("Bird is flying");
    }
}

抽象类

抽象类使用 abstract 修饰，可以包含抽象方法和具体方法。

public abstract class Shape {
    public abstract double area(); // 抽象方法

    public void display() {
        System.out.println("This is a shape");
    }
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

匿名类

适用于一次性使用的简单类实现。

interface Greeting {
    void greet();
}

public class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() {
            @Override
            public void greet() {
                System.out.println("Hello, anonymous class!");
            }
        };
        greeting.greet();
    }
}

以上是 Java 类的基本写法，涵盖了类定义、继承、接口、抽象类等常见用法。根据具体需求选择合适的实现方式。