Types of Classes in Java

2025年3月27日 | 阅读 9 分钟

在 Java 中，类是用于创建单个对象的蓝图。Java 提供了一个名为 class 的关键字来声明类。在类中，我们定义类成员和函数。没有类就无法创建 Java 程序。我们还可以将类称为用户定义的 数据类型，因为面向对象的范例允许我们模拟现实世界中的对象。在本节中，我们将重点介绍Java 中的类类型。

类类型

Java 中有七种类型的类

静态类
最终类
抽象类
具体类
单例类
POJO 类
内部类

静态类

在 Java 中，static 是一个管理内存中对象的关键字。静态对象属于类而不是类的实例。

我们只能将一个类声明为 static，前提是它是一个嵌套类。我们也可以说静态类被称为嵌套类。这意味着在另一个类中声明为 static 的类称为静态类。嵌套静态类不需要对外部类的引用。静态类的目的是为其继承的类提供大纲。

静态类的属性是

类只有静态成员。
它无法访问外部类的成员（非静态）。
我们无法创建静态类的对象。

让我们通过一个程序来理解静态类的概念。

StaticClassExample.java

public class StaticClassExample
{
private static String str = "Javatpoint";
//nested class which is a Static class
public static class StaticDemo
{
//non-static method of Static class
public void show() 
{
System.out.println(str); 
}
}
public static void main(String args[])
{
StaticClassExample.StaticDemo obj = new StaticClassExample.StaticDemo();
obj.show();
}
}

输出

Javatpoint

在上述程序的外部类中，我们已将变量 str 声明为 static，因为我们正在从静态上下文访问该变量。如果我们将其声明为非静态，编译器将显示错误，因为嵌套的静态类无法访问外部类的非静态成员。

上述程序中需要注意的第二件事是，要创建嵌套类的对象，我们不需要创建外部类的实例。如果嵌套类不是静态类，我们需要创建外部类的实例。

最终类

final 这个词的意思是“不能改变”。Java 中的final 类可以使用 final 关键字声明。一旦我们将一个类声明为 final，其值在整个程序中将保持不变。final 类的目的是使类像 String 类一样不可变。这只是使类不可变的一种方式。请记住，final 类不能被继承。它还阻止了类被子类化。

让我们通过一个程序来理解 final 类的概念。

FinalClassExample.java

//base class declared as final
final class A
{
void printmsg() 
{
System.out.print("Base class method is executed.");
}
}
//derived class
//extending a final class which is not possible 
//it shows the error cannot inherit final class at compile time 
class B extends A
{ 
void printmsg() 
{
System.out.print("Derived class method is executed.");
}
}
//main class
public class FinalClassExample
{
public static void main(String[] arg) 
{
B obj = new B();
obj.printmsg();
}
}

输出

/FinalClassExample.java:11: error: cannot inherit from final A class B extends A

抽象类

一个抽象类是使用 abstract 关键字声明的。该类可能包含也可能不包含抽象方法。我们无法创建抽象类的实例，但它可以是子类。这些类是不完整的，因此要完成抽象类，我们应该将抽象类扩展到一个具体类。当我们声明一个子类为抽象类时，有必要提供抽象方法的实现。因此，子类也必须声明为抽象类。我们可以通过使用抽象类来实现数据隐藏。抽象类的示例是 AbstarctMap 类，它是 Collections 框架的一部分。

让我们通过一个程序来理解抽象类的概念。

AbstractClassExample.java

//abstract class
abstract class MathematicalOperations 
{ 
int a=30, b=40;
//abstract method
public abstract void add(); 
}
public class Operation extends MathematicalOperations  
{ 
//definition of abstract method     
public void add() 
{
System.out.println("Sum of a and b is: "a+b);
}
public static void main(String args[]) 
{
MathematicalOperations obj = new Operation();
obj.add();
}
}

输出

Sum of a and b is: 70

具体类

这些是普通的 Java 类。为所有在基类中尚未实现的模型提供基本实现的派生类称为具体类。换句话说，它们是普通 Java 类，其中实现了抽象类的所有方法。我们可以直接创建具体类的对象。请记住，具体类和抽象类不是同一回事。具体类可以扩展其父类。它用于特定需求。

让我们通过一个程序来理解具体类的概念。

ConcreteClassExample.java

//Concrete Class
public class ConcreteClassExample 
{ 
//method of the concreted class
static int product(int a, int b) 
{
return a * b;
}
public static void main(String args[]) 
{
//method calling    
int p = product(6, 8);
System.out.println("Product of a and b is: " + p);
}
}

输出

Product of a and b is: 48

单例类

一次只有一个对象的类称为单例类。即使我们尝试第二次创建实例，新创建的实例也会指向第一个实例。如果我们通过任何实例在类中进行了任何更改，修改也会影响单个实例的变量。通常用于控制数据库连接和套接字编程时的访问。如果我们想创建一个单例类，请执行以下操作：

创建一个私有的构造函数。
创建一个静态方法（通过使用延迟初始化）来返回单例类的对象。

SingletonClassExample.java

public class Singleton
{
private String objectState;
private static Singleton instance = null;
private Singleton() throws Exception
{
this.objectState = "Javatpoint";
}
public static Singleton getInstance()
{
if(instance==null)
{
try
{
instance=new Singleton();
}
catch(Exception e)
{
e.printStackTrace();
}
}
return instance;
}
public String getObjectState()
{
return objectState;
}
public void setObjectState(String objectState)
{
this.objectState = objectState;
}
}

输出

Javatpoint

POJO 类

在 Java 中，POJO 代表Plain Old Java Object。仅包含私有变量、setter 和 getter 的 Java 类称为POJO 类。它用于定义 Java 对象，从而提高 Java 程序的可重用性和可读性。该类提供了封装。它在 Java 中被广泛使用，因为它易于理解。POJO 类具有以下属性

它不扩展预定义类，如 Arrays、HttpServlet 等。
它不能包含预先指定的注释。
它不能实现预定义的接口。
不需要添加任何构造函数。
所有实例变量都必须是私有的。
getter/setter 方法必须是公共的。

让我们通过一个 Java 程序来理解 POJO 类的概念。

PojoClassExample.java

class PojoDemo 
{
//private variable    
private double price=89764.34;
//getter method
public double getPrice() 
{
return price;
}
//setter method
public void setPrice(int price) 
{
this.price = price;
}
}
//main class
public class PojoClassExample
{
public static void main(String args[])
{
PojoDemo obj = new PojoDemo();
System.out.println("The price of an article is "+ obj.getPrice()+" Rs.");
}
}

输出

The price of an article is 89764.34 Rs.

内部类

Java 允许我们在类中定义类，这些类称为嵌套类。它用于逻辑地分组类并实现封装。内部类可以访问外部类的成员（包括私有成员）。声明嵌套类的通用语法如下：

class OuterClass
{  
//code  
class NestedClass
{  
//code  
}  
}

嵌套类有两种类型

1. 静态嵌套类：一个静态且嵌套的类称为静态嵌套类。它与外部类的实例成员进行交互。我们可以使用以下语法创建静态嵌套类的对象：

2. 非静态嵌套类：非静态嵌套类称为内部类。

声明静态嵌套类和内部类的通用语法如下：

class OuterClass 
{
...
static class StaticNestedClass 
{
...
}
class InnerClass 
{
...
}
}

让我们通过一个 Java 程序来理解内部类的概念。

InnerClassExample.java

public class InnerClassExample
{
public static void main(String[] args) 
{
System.out.println("This is outer class.");
}
class InnerClass 
{
public void printinner() 
{
System.out.println("This is inner class.");
}
}
}

内部类类型

Java 提供了以下两种内部类：

局部类或方法局部内部类
匿名类或匿名内部类

局部内部类

这是一种定义在块中的内部类。这里的块表示方法体（包含在一对大括号中的一组语句）。由于定义在块中，因此也称为方法局部内部类。这些是非静态类，因为它们可以访问块的实例成员。我们可以在方法的正文中定义局部内部类。这些类必须在它们定义的块中进行实例化。

当我们编译 Java 程序（包含内部类的程序）时，编译器会生成两个类文件，即 Outer.class 和 Outer$1Inner.class。一个用于外部类，另一个用于包含对外部类引用的内部类。

让我们通过一个 Java 程序来理解局部内部类的概念。

OuterClass.java

public class OuterClass 
{ 
private void getValue() 
{ 
//if you are using Java 7 make the variable final
//if you are using Java 8 the code runs successfully 
int sum = 20; 
//declaring method local inner class
class InnerClass 
{ 
public int divisor; 
public int remainder; 
public InnerClass() 
{ 
divisor = 4; 
remainder = sum%divisor; 
} 
private int getDivisor() 
{ 
return divisor; 
} 
private int getRemainder() 
{ 
return sum%divisor; 
} 
private int getQuotient() 
{ 
System.out.println("We are inside the inner class"); 
return sum / divisor; 
} 
} 
//creating an instance of inner class
InnerClass ic = new InnerClass(); 
System.out.println("Divisor = "+ ic.getDivisor()); 
System.out.println("Remainder = " + ic.getRemainder()); 
System.out.println("Quotient = " + ic.getQuotient()); 
} 
public static void main(String[] args) 
{ 
//creating an instance of outer class
OuterClass oc = new OuterClass(); 
oc.getValue(); 
} 
} 

输出

Divisor = 4
Remainder = 0
We are inside the inner class
Quotient = 5

匿名内部类

这是一种与局部类相同的内部类，唯一的区别是该类没有类名，并且只创建该类的一个对象。它使代码更简洁。如果我们想只使用一次局部类，就可以使用它。我们可以通过以下两种方式创建匿名类：

通过使用接口
通过将类声明为具体和抽象

语法

// the class may an interface, abstract or concrete class
DemoClass obj = new DemoClass() 
{
//methods 
//data members
public void demomethod() 
{
//statements
}   
};

查看上面的语法，我们看到它与调用构造函数相同，只是类在其块中包含定义。

AnonymousClassExample.java

interface Score
{ 
int run = 321; 
void getScore(); 
} 
public class AnonymousClassExample
{ 
public static void main(String[] args) 
{ 
// Myclass is hidden inner class of Score interface 
// whose name is not written but an object to it  
// is created. 
Score s = new Score() 
{ 
@Override
public void getScore() 
{ 
//prints score
System.out.print("Score is "+run); 
} 
}; 
s.getScore(); 
} 
} 

输出

Score is 321

Java 还提供了另一种类型的 Java 类，称为包装类。让我们详细讨论一下。

包装类

在 Java 中，“包装类”表示一组 Java 类，它们将 Java 的原始类型对象化。这意味着对于每种原始类型，都有一个对应的包装类。包装类用于执行原始类型到对象的转换以及反之。下图演示了包装类的继承层次结构。

下表显示了原始类型和对应的包装类。

原始类型	包装类
boolean	Boolean
int	Integer
char	Character
double	Double
float	Float
long	Long
byte	Byte
short	Short

让我们通过一个 Java 程序来理解包装类。

WrapperClassExample.java

public class WrapperClassExample
{ 
public static void main(String args[]) 
{ 
byte x = 0; 
//wrapping byte primitive type into Byte object 
Byte byteobj = new Byte(x); 
int y = 23; 
//wrapping int primitive type into Integer object 
Integer intobj = new Integer(y); 
char c='m'; 
//wrapping char primitive type into Character object  
Character charobj=c; 
//printing values from objects 
System.out.println("Byte object byteobj: " + byteobj); 
System.out.println("Integer object intobj: " + intobj); 
System.out.println("Character object charobj: " + charobj); 
} 
}

输出

Byte object byteobj: 0
Integer object intobj: 23
Character object charobj: m

下一个主题如何创建 Java API

Types of Classes in Java

类类型

静态类

最终类

抽象类

具体类

单例类

POJO 类

内部类

内部类类型

局部内部类

匿名内部类

包装类

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Types of Classes in Java

类类型

静态类

最终类

抽象类

具体类

单例类

POJO 类

内部类

内部类类型

局部内部类

匿名内部类

包装类

相关帖子

RuleBasedCollator hashCode() method in Java with Example

Java SE

Java 中的 Optional 类 orElseThrow() 方法

Java With Examples 的 FloatBuffer allocate() 方法

Java 中的错误类型

Java 中的量词

Java 中的稀疏数

如何在 Java 中调用抽象类的具体方法

How to Pass Integer by Reference in Java?

Java 中的模型类

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器