Java中不同类型的类和示例

类是用户定义的蓝图或原型，从中创建对象。它表示一种类型的所有对象共有的一组属性或方法。一般来说，类声明可以包括这些组件，按顺序：

• 修饰符：类可以是公共的或具有默认访问权限
• class 关键字：class 关键字用于创建一个类。
• 类名：名称应以首字母开头（按约定大写）。
• 超类（如果有）：类的父类（超类）的名称，如果有的话，前面有关键字extends。一个类只能扩展（子类）一个父类。
• 接口（如果有）：由类实现的接口的逗号分隔列表，如果有的话，前面有关键字 implements。一个类可以实现多个接口。
• Body：用大括号 { } 包围的类主体。

我们可以在类内部定义类成员和函数。不同类型的类：

1. 静态类
2. 最后一堂课
3. 抽象类
4. 具体类
5. 单例类
6. POJO类
7. 内部类

1. 静态类

我们可以将一个类声明为静态当且仅当它是一个嵌套类。我们可以用 static 修饰符声明一个内部类，这种类型的内部类称为静态嵌套类。在没有现有外部类对象的普通或常规类的情况下，不可能存在现有内部类对象，即内部类对象与外部类对象强关联。在静态嵌套类的情况下，可能有机会在没有外部类对象的情况下声明嵌套类对象。

Note:

If we want to declare a nested class object from outside of the outer class then we can create as follows

Syntax: 

Outerclassname.innerclassname objectvariable= new Outerclassname.innerclass name();

Example: 

Test.Nested n= new Test.Nested();

因此据说可能存在现有的嵌套类对象而没有现有的外部类对象。在普通或常规的内部类中，我们不能声明任何静态成员，但在静态嵌套类中，我们可以声明静态成员，包括 main 方法，因此，我们可以直接从命令提示符调用静态嵌套类。

静态类的属性：

1. 无法创建静态类对象。
2. 静态类只能有静态成员。
3. 静态类不能访问外部类的成员（非静态）。

示例：

Java

class Outer {
    static class Nested {
        public static void main(String arg[])
        {
            System.out.println(
                "static method class main method");
        }
    }
  
    public static void main(String arg[])
    {
        System.out.println("Outer class main method");
    }
}

输出：

2. 期末课

可以使用关键字“final”将类声明为最终类。如果一个类被声明为final，我们就不能扩展该类的功能，即我们不能为该类创建子类，即final 类不能继承。默认情况下，最终类中存在的每个方法通常都是最终的，但最终类中存在的每个变量都不必是最终的。如果我们创建最终类，我们将无法实现继承。如果我们创建一个 final 方法，我们无法实现多态性，但我们可以获得安全性，没有人可以改变我们代码的唯一实现，但是 final 关键字的主要缺点是我们缺少继承和多态性的好处。

Note: If there is no specific requirement it is not recommended to use the final keyword.

例子：

Java

final class Sound {
    static int number = 10;
    void message()
    {
        number = 777;
        System.out.println(number);
    }
}
  
class Animal extends Sound {
    static int number = 9;
    void message()
    {
        super.number = 888;
        System.out.println(super.number);
    }
  
    public static void main(String arg[])
    {
        Animal a = new Animal();
        a.message();
    }
}

输出：

3.抽象类

我们可以使用关键字“abstract”将一个类声明为抽象类。对于任何Java类，如果我们不允许创建此类类型的对象，我们应该使用 abstract 修饰符声明，即抽象类的实例化是不可能的。如果一个类至少包含一个抽象方法，那么我们应该将一个类声明为抽象类，否则会出现编译错误。原因：如果一个类至少包含一个抽象方法，则实现不完整，因此不建议创建对象。如果我们需要强制限制对象实例化，我们需要将类声明为抽象类。如果我们不想要任何实例化，则包含零个或多个抽象方法的类可以是抽象类。示例： HttpServletClass 是抽象的，但它不包含任何抽象方法。

如果我们要扩展抽象类，那么对于父类的每个抽象方法，我们都应该提供实现，否则，我们必须将子类声明为抽象类。在这种情况下，下一级子类负责提供实现。

例子：

Java

abstract class AbstractClass {
    public abstract void add(int a, int b);
    public abstract void sub(int a, int b);
    public void mul(int a, int b)
    {
        System.out.println("Multiplication of a and b is"
                           + " " + (a * b));
    }
}
class Geek extends AbstractClass {
    public void add(int a, int b)
    {
        System.out.println("Sum of a and b is"
                           + " " + (a + b));
    }
    public void sub(int a, int b)
    {
        System.out.println("Difference of a and b is"
                           + " " + (a - b));
    }
    public static void main(String[] args)
    {
        int a = 6;
        int b = 5;
        Geek g = new Geek();
        g.add(a, b);
        g.sub(a, b);
        g.mul(a, b);
    }
}

输出：

4. 具体类

具体类不过是Java中的普通或常规类。具体类是扩展另一个类或实现接口的类。简而言之，我们可以说任何不是抽象的类都是具体的类。我们可以直接为具体类创建一个对象。

Note: A class is said to be a concrete class if there is an implementation for each and every method.

例子：

Java

public class ConcreteClass
{
    // method of the concreted class
    static int addition(int a, int b) { return a + b; }
  
    public static void main(String args[])
    {
        // method calling
        int p = addition(5, 9);
        System.out.println("The result of a and b is: "
                           + p);
    }
}

输出：

5. 单例类

对于任何Java类，如果我们只允许创建一个对象，那么这种类就被称为单例类。

示例：运行时、BusinessDelegate、ServiceLocator

优点：

• 如果几个人有相同的需求，那么不建议为每个需求制作一个单独的对象，我们只制作一个对象，以便我们可以为每个相似的需求重用一个等效的对象，以提高性能和内存利用率有待改进。
• 这通常是单例类的中心思想。

我们还可以创建自己的单例类，因为我们想拥有

• 私有构造函数
• 私有静态变量和公共工厂方法

例子：

Java

class Test {
  
    private static Test t = null;
    public String s;
  
    private Test() throws Exception
    {
        s = "I am example of singletonclass";
    }
  
    public static Test getTest()
    {
        if (t == null) {
            try {
                t = new Test();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        return t;
    }
  
    public String gets() { return s; }
    public void sets(String s) { this.s = s; }
}
  
class Geeks {
  
    public static void main(String arg[])
    {
        Test t1 = Test.getTest();
        Test t2 = Test.getTest();
        Test t3 = Test.getTest();
        t1.getTest();
        System.out.println("Hashcode of t1 is "
                           + t1.hashCode());
        System.out.println("Hashcode of t2 is "
                           + t2.hashCode());
        System.out.println("Hashcode of t3 is "
                           + t3.hashCode());
    }
}

输出：

6. POJO类

POJO 代表普通旧Java对象。如果我们编写一个类别，那么它必须遵循一些称为 POJO 规则的规则。 Java不会扩展可读性和可重用性。它提供封装。

POJO类的属性：

1. 类必须声明为公共
2. 属性/变量必须声明为私有
3. 必须有一个公共的默认构造函数
4. 可能有也可能没有参数构造函数
5. 每个属性都应该有一个公共的 getter 和 setter 方法
6. 它不能包含预先指定的注释。

例子：

Java

class Pojoclass {
  
    private String name = "Geeks for Geeks";
    public void setName(String name) { this.name = name; }
    public String getName() { return name; }
}
  
public class PojoExample
{
    public static void main(String args[])
    {
        Pojoclass obj = new Pojoclass();
        System.out.println("The name of an student is "
                           + obj.getName());
    }
}

输出：

7.内部类

有时我们可以在另一个类中声明一个类，这种类型的类称为内部类。引入内部类概念以修复 GUI 错误作为事件处理的一部分，但由于内部类的强大功能和好处，程序员也开始在常规编码中慢慢使用。如果没有现有的一种类型的对象，就不可能执行另一种类型的对象，那么我们应该使用内部类。

示例：大学由多个部门组成，没有现有大学就没有现有部门的机会，因此我们必须在大学班级内声明部门班级。

Class University{
  // code
    Class Department{
        // code
    }
}

外部类和内部类之间的关系称为 Has-A 关系。根据声明和行为的位置，所有内部类分为四种类型。

• 普通班或普通班
• 方法本地内部类
• 匿名内部类
• 静态嵌套类

普通和普通的内部课程：

如果我们在一个类中直接声明任何命名类而没有 static 修饰符，那么这种类型的内部类称为 Normal 或 Regular 内部类。

例子：

Java

class Outer1 {
    class Inner {
        public void m1()
        {
            System.out.println("Inner class method");
        }
    }
  
    public static void main(String arg[])
    {
        Outer1 o = new Outer1();
        Outer1.Inner i = o.new Inner();
        i.m1();
    }
}

输出：

内部类的嵌套：

在内部类内部，我们可以声明另一个内部类，即内部类的嵌套是可能的。

例子：

Java

class A {
    class B {
        class C {
            public void m1()
            {
                System.out.println(
                    "Innermost class method");
            }
        }
    }
}
  
class Test {
    public static void main(String arg[])
    {
        A a = new A();
        A.B b = a.new B();
        A.B.C c = b.new C();
        c.m1();
    }
}

输出：

方法本地内部类：

有时我们可以在方法内部声明一个类，这种类型的内部类称为方法局部内部类。方法局部内部类的主要目的是定义特定于方法的重复功能。方法局部内部类最适合满足嵌套类的要求。我们可以访问方法，局部内部类，只能在我们声明的方法内部，在方法之外我们不能访问和使用它的更小范围的方法局部内部类是最不常用的内部类类型。

Note: The only applicable modifier for method local inner classes are final, abstract, Strictfp. If we are trying to apply any other modifier then we will get a compilation error.

例子：

Java

class Outer2 {
    public void m1()
    {
        class Inner {
            public void sum(int x, int y)
            {
                System.out.println("The sum"
                                   + " " + (x + y));
            }
        }
  
        Inner i = new Inner();
        i.sum(10, 20);
        i.sum(100, 200);
        i.sum(1000, 2000);
    }
  
    public static void main(String arg[])
    {
        Outer2 t = new Outer2();
        t.m1();
    }
}

输出：

Note: We can declare the method local inner class inside both instance and static method. If we declare the inner class inside the instance method then from that method local inner class, we can access both static and non-static members of the outer class directly.

匿名内部类：

有时我们声明没有名称的内部类，这种类型的内部类称为匿名内部类。匿名内部类的主要目的只是为了即时使用。基于声明和行为，匿名内部类分为三种类型

1. 扩展类的匿名内部类
2. 实现接口的匿名内部类
3. 定义内部参数的匿名内部类

例子：

Java

class ThreadDemo {
    public static void main(String arg[])
    {
        new Thread(
            new Runnable()
            {
                public void run()
                {
                    for (int i = 0; i <= 5; i++)
                    {
                        System.out.println("Child Thread");
                    }
                }
            })
            .start();
  
        for (int i = 0; i <= 5; i++)
        {
            System.out.println("Main thread");
        }
    }
}

输出：

静态嵌套类：

我们可以使用静态修饰符声明内部类，这种类型的内部类称为静态嵌套类。

例子：

Java

class StaticNested1 {
  
    private static String str = "Geeks for Geeks";
  
    static class Nested {
        public void m1() { System.out.println(str); }
    }
  
    public static void main(String args[])
    {
        StaticNested1.Nested obj
            = new StaticNested1.Nested();
        obj.m1();
    }
}

输出：