Java的一个普通类里面究竟可以装什么
一.常量
1.概念
在Java中，使用final关键字声明的变量被视为常量。
常量只能被赋值一次，它们的值一旦被初始化就不能被修改。
2.格式
常量的值在声明时或者在构造函数中必须被初始化。
2.1声明时并初始化
public final String NAME = "囝囝";
public class Test {
public final String CONSTANT; // 这里会报错，因为常量没有被初始化
public static void main(String[] args) {
Test test = new Test();
System.out.println(test.CONSTANT); // 这里访问的是未初始化的常量，也会报错
}
}2.2在构造函数里面被初始化
public class Test {
public final String CONSTANT;
public Test(String value) {
CONSTANT = value;
}
public static void main(String[] args) {
Test test = new Test("I am a constant");
System.out.println(test.CONSTANT); // 这里访问的是已经初始化的常量，不会报错
}
}3.分类(静态常量和非静态常量)
3.1静态常量
常量被static修饰，所有的对象都共享同一个常量值。
public class Test {
// 直接在声明时初始化
public static final String STATIC_CONSTANT = "I am a static constant";
// 在同一个类的方法中直接访问
public void printStaticConstant() {
System.out.println(STATIC_CONSTANT);
}
public static void main(String[] args) {
// 通过类名直接访问
System.out.println(Test.STATIC_CONSTANT);
// 调用方法打印STATIC_CONSTANT
Test test = new Test();
test.printStaticConstant();
}
}3.2非静态常量（实例常量）
每个对象都有自己的一份拷贝
public class Test {
// 直接在声明时初始化
public final String CONSTANT1 = "constant1";
// 在同一个类的非静态方法中访问
public void printConstant1() {
System.out.println(CONSTANT1);
}
public static void main(String[] args) {
// 通过类的对象在其他地方访问
Test test = new Test();
System.out.println(test.CONSTANT1);
// 调用方法打印CONSTANT1
test.printConstant1();
}
}
二.成员变量(被不同访问修饰符修饰)
1.概念
也被称为字段或实例变量，是定义在类中的变量。它们的值是对象特有的，每一个对象都有一份属于自己的成员变量。
2.格式
// 私有成员变量
private String privateField;
// 公有成员变量
public int publicField;
// 受保护的成员变量
protected boolean protectedField;三.构造方法
1.概念
用于初始化新创建的对象。名称必须与类名相同，没有返回类型，甚至连void也不用写。
创建对象的时候自动调用构造方法，用于设置对象的初始状态。一个类可以有多个构造方
法，它们可以有不同的参数列表。
2.格式
public class Student {
private String name;
private int age;
// 这是一个构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
} 例子中，Student类有一个构造方法，它接受两个参数：一个String类型的name和一个int类型的age。
当我们创建一个新的Student对象时，我们需要提供这两个参数，然后构造方法会将这些参数的值赋给对象的成员变量。4.普通方法(被不同访问修饰符修饰)
四.普通方法
1.概念
也叫做成员方法或实例方法， 是定义在类中的一段代码，可以执行某些操作并返回结果。普通方法可以访问类的成员变量和其他方法，也可以使用this关键字来引用当前对象。
2.格式
// 私有方法
private void privateMethod() {
System.out.println("This is a private method.");
}
// 公有方法
public void publicMethod() {
System.out.println("This is a public method.");
}
// 受保护的方法
protected void protectedMethod() {
System.out.println("This is a protected method.");
}五.内部类
1.概念
一个类可以定义在另一个类的内部，这样的类被称为内部类。
允许我们将一些逻辑上相关的类组织在一起，使得代码更加清晰和易于维护。
2.分类
2.1成员内部类
2.1.1 概念
定义在类的成员位置，和成员变量、成员方法平级。
2.1.2 格式
public class OuterClass {
private String name;
// 这是一个成员内部类
public class InnerClass {
public void printName() {
System.out.println("名字是 " + name);
}
}
} InnerClass就是一个内部类，定义在OuterClass的内部。InnerClass有一个方法printName，这个方法可以直接访问OuterClass的私有成员变量name。
2.2静态内部类
2.2.1 概念
静态内部类不需要依赖外部类的实例，可以直接创建。而普通的内部类必须在外部类的实例中创建。静态内部类只能访问外部类的静态成员，不能访问非静态的成员。而普通的内部类可以访问所有外部类的成员。
2.2.2 格式
public class OuterClass {
private static String staticName = "囝囝";
private String name = "小美囝";
// 这是一个静态内部类
public static class StaticInnerClass {
public void printName() {
// 可以访问外部类的静态变量
System.out.println("静态名字是 " + staticName);
// 不能访问外部类的非静态变量
// System.out.println("名字是 " + name); // 这行代码是错误的
}
}
}StaticInnerClass是一个静态内部类，可以直接访问OuterClass的静态成员变量staticName，但不能访问非静态的成员变量name。
要创建和使用StaticInnerClass，我们不需要OuterClass的实例，可以直接创建：
OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
inner.printName();2.3局部内部类
2.3.1 概念
局部内部类定义在一个方法或者一个作用域里面的类，作用范围仅限于定义它的方法或者代码块。
局部内部类和普通的内部类一样，都可以访问外部类的所有成员。但是，局部内部类还可以访问定义它的方法中的final局部变量。
2.3.2 格式
public class OuterClass {
private String name = "囝囝";
public void doSomething() {
final String localName = "小美囝";
// 这是一个局部内部类
class LocalInnerClass {
public void printName() {
System.out.println("名字是 " + name);
System.out.println("局部名字是 " + localName);
}
}
// 在方法内部使用局部内部类
LocalInnerClass inner = new LocalInnerClass();
inner.printName();
}
}例子中，LocalInnerClass就是一个局部内部类，它定义在doSomething方法内部。LocalInnerClass可以访问OuterClass的成员变量name，也可以访问doSomething方法的局部变量localName。
局部内部类的主要作用是进行细粒度的封装，它可以让我们在方法中定义复杂的行为，而不需要定义一个新的类。这样可以使代码更加简洁，也更容易理解和维护。
2.3匿名内部类
2.3.1 概念
没有名字的内部类，它通常用于只需要使用一次的场合。
匿名内部类通常用来简化代码，它可以在定义的同时就创建一个类的实例。匿
名内部类常常用在图形界面编程中，作为事件监听器。
2.3.2 格式
public class OuterClass {
private String name = "囝囝";
public void doSomething() {
// 这是一个匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("名字是 " + name);
}
}).start();
}
} 例子中，我们在doSomething方法中定义了一个匿名内部类。这个匿名内部类实现了Runnable接口，并重写了run方法。然后我们用这个匿名内部类的实例作为参数，创建了一个新的线程并启动。
匿名内部类的主要作用是简化代码，它让我们可以在需要的地方直接定义并使用一个类的实例，而不需要显式地定义一个新的类。这在需要使用一次性的类，或者类的定义比较简单的情况下，可以使代码更加简洁，也更容易理解和维护。
六.初始化块与静态初始化块
1.概念
在Java中，初始化块（也称为实例初始化块）和静态初始化块是两种特殊的代码块，它们可以在类的实例被创建或类被加载时执行一些代码。
初始化块在每次创建类的实例时都会被执行，而静态初始化块在类被加载到JVM时只执行一次。
2.格式
public class OuterClass {
// 静态初始化块
static {
System.out.println("静态初始化块被执行");
}
// 初始化块
{
System.out.println("初始化块被执行");
}
public OuterClass() {
System.out.println("构造函数被执行");
}
} 例子中，OuterClass有一个静态初始化块和一个初始化块。当我们创建OuterClass的实例时，会看到如下的输出：
静态初始化块被执行
初始化块被执行
构造函数被执行
可以看到，静态初始化块首先被执行，然后是初始化块，最后是构造函数。
初始化块和静态初始化块的主要作用是执行一些初始化操作。初始化块可以用于初始化实例变量，静态初始化块可以用于初始化静态变量。这些初始化操作可能包括计算表达式、调用方法等。
七.枚举
1.概念
在Java中，一个类可以定义内部枚举。枚举类型用于表示固定数量的常量值，它可以有自己的变量、方法和构造函数。
2.格式
public class OuterClass {
// 内部枚举
enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
public void printDay() {
Day day = Day.MONDAY;
System.out.println("今天是 " + day);
}
} 例子中，OuterClass定义了一个内部枚举Day，然后在printDay方法中使用这个枚举。
枚举的主要作用是表示一组固定的常量，比如一周的七天、一年的四季等。使用枚举可以使代码更清晰，更容易理解和维护。同时，枚举也可以有自己的变量和方法，这使得我们可以在枚举中封装更多的逻辑和数据。
八.接口
1.概念
一个类可以定义内部接口。这个内部接口可以被其他类实现，也可以被其他内部类或者内部接口继承。内部接口主要用于组织相关的接口，让代码结构更清晰。
2.格式
public class OuterClass {
// 内部接口
public interface InnerInterface {
void printName();
}
}
class ImplementClass implements OuterClass.InnerInterface {
@Override
public void printName() {
System.out.println("实现了内部接口的方法");
}
} 例子中，OuterClass定义了一个内部接口InnerInterface，ImplementClass实现了这个内部接口。
内部接口的主要作用是组织和封装相关的接口。比如，如果你有一组相关的接口，你可以将它们定义为一个类的内部接口，这样可以使代码结构更清晰，也更容易理解和维护。同时，内部接口也可以让我们在实现接口时，有更多的灵活性和选择。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
