Java中有哪些不同类型的类？

Java类的类型

具体课

任何不具有任何抽象方法的普通类，或具有其父类或接口的所有方法及其自己的方法的所有实现的类都是具体的类。

示例

public class Concrete { // Concrete Class
   static int product(int a, int b) {
      return a * b;
   }
   public static void main(String args[]) {
      int p = product(2, 3);
      System.out.println("Product: " + p);
   }
}

输出结果

Product: 6

抽象类

用abstract关键字声明并且具有零个或多个抽象方法的类被称为abstract class。抽象类是不完整的类，因此，要使用该类，我们必须严格将抽象类扩展为具体类。

示例

abstract class Animal { //abstract parent class
   public abstract void sound(); //abstract method
}
public class Dog extends Animal { //Dog class extends Animal class
   public void sound() {
      System.out.println("Woof");
   }
   public static void main(String args[]) {
      Animal a = new Dog();
      a.sound();
   }
}

输出结果

Woof

期末班

用final关键字声明的类是final类，并且不能由其他类扩展，例如java.lang.System类。

示例

final class BaseClass {
   void Display() {
      System.out.print("This is Display() method of BaseClass.");
   }
}
class DerivedClass extends BaseClass { //Compile-time error - can't inherit final class   void Display() {
      System.out.print("This is Display() method of DerivedClass.");
   }
}
public class FinalClassDemo {
   public static void main(String[] arg) {
      DerivedClass d = new DerivedClass();
      d.Display();
   }
}

在上面的示例中，DerivedClass扩展了BaseClass(final)，我们无法扩展最终的类，因此编译器将抛出error。上面的程序没有 执行。

输出结果

cannot inherit from final BaseClass
Compile-time error - can't inherit final class

POJO课

仅包含私有变量以及使用这些变量的setter和getter方法的类称为POJO（普通Java对象）类。这是一个完全封装的类。

示例

class POJO {
  private int value=100;
  public int getValue() {
      return value;
   }
   public void setValue(int value) {
      this.value = value;
   }
}
public class Test {
   public static void main(String args[]){
      POJO p = new POJO();
      System.out.println(p.getValue());
   }
}

输出结果

100

静态类

静态类是嵌套类，表示在另一个类中声明为静态成员的类称为静态类。

示例

import java.util.Scanner;
class staticclasses {
   static int s; // static variable
   static void met(int a, int b) { // static method
   System.out.println("static method to calculate sum");
   s = a + b;
   System.out.println(a + "+" + b); // print two numbers
}
   static class MyNestedClass { // static class
      static { // static block
         System.out.println("static block inside a static class");
      }
      public void disp() {
         int c, d;
         Scanner sc = new Scanner(System.in);
         System.out.println("Enter two values");
         c = sc.nextInt();
         d = sc.nextInt();
         met(c, d); // calling static method
         System.out.println("Sum of two numbers-" + s); // print the result in static variable
      }
   }
}
public class Test {
   public static void main(String args[]) {
      staticclasses.MyNestedClass mnc = new staticclasses.MyNestedClass(); // object for static class
      mnc.disp(); // accessing methods inside a static class
   }
}

输出结果

static block inside a static class
Enter two values 10 20
static method to calculate sum
10+20
Sum of two numbers-30

内部阶层

在另一个类或方法中声明的类称为内部类。

示例

public class OuterClass {
   public static void main(String[] args) {
      System.out.println("Outer");
   }
   class InnerClass {
      public void inner_print() {
         System.out.println("Inner");
      }
   }
}

输出结果

Outer