Java中的类类型

类是Java编程语言中的一个蓝图，可以从中构建单个对象。在Java中，我们可以使用 class 关键字来声明一个类。类成员和函数只是在类中声明。创建Java程序需要类。面向对象范式 (OOP) 允许用户描述现实世界的对象。此外，类有时也称为用户定义的数据类型。以下组件构成一个类声明：

• 修饰符
• 班级名称
• 关键词
• 花括号 {} 中的类主体。

类的类型

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

1. 期末课

当变量、函数或类被声明为 final 时，它的值会在整个程序中保持不变。使用 final 关键字声明方法表示该方法不能被子类覆盖。那是一个标记为 final 的类不能是子类。这在创建不可变类（例如 String 类）时非常有用。一个类不能被改变，除非它被声明为final。

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
final class Base {
 
    void Display()
    {
        System.out.print("Method for Base class.");
    }
}
 
class Extended extends Base {
 
    void Display()
    {
        System.out.print("Method of Extended class.");
    }
}
 
class GFG {
 
    public static void main(String[] arg)
    {
        Extended d = new Extended();
        d.Display();
    }
}

2.静态类

静态是一个Java词，用于解释对象如何保存在内存中。静态对象属于该类而不是该类的实例。类的主要函数是为继承的类提供蓝图。静态类只有静态成员。不能为静态类创建对象。

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
class staticclasses {
    static int s;
    static void met(int x, int y)
    {
        System.out.println(
            "static method to calculate sum");
        s = x + y;
        System.out.println(x + "+" + y);
    }
    static class MyNestedClass {
        static
        {
            System.out.println(
                "static block inside a static class");
        }
        public void disp()
        {
            int x1;
            int y1;
            Scanner sc = new Scanner(System.in);
            System.out.println("Enter two numbers");
            x1 = sc.nextInt();
            y1 = sc.nextInt();
            met(x1, y1);
            System.out.println("Sum of the 2 numbers-" + s);
        }
    }
}
public class GFG {
    public static void main(String args[])
    {
        staticclasses.MyNestedClass nestedclass
            = new staticclasses.MyNestedClass();
        nestedclass.disp();
    }
}

3.抽象类

具有零个或多个抽象方法并使用 abstract 关键字指定的类称为抽象类。我们必须严格地将抽象类扩展为具体类才能使用它们，因为它们是不完整的类。也可以包括构造函数和静态方法。它可以有 final 方法，这会强制子类保持方法体未挂起。

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
interface X {
    int product(int x, int y);
}
abstract class Product implements X {
 
    public int product(int x, int y) { return x * y; }
}
class GFG extends Product {
    public static void main(String args[])
    {
        Main ob = new Main();
        int p = ob.product(20, 10);
        System.out.println("Product: " + p);
    }
}

4. 具体类

具有所有方法的实现且没有抽象方法的普通类称为具体类。他们不允许有任何当时未使用的进程。如果它实现了它的所有方法，那么具体类可以扩展它的父类、抽象类或接口。这是一个完全有效的、可实例化的类。

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
public class GFG {
    static int sum(int x, int y) { return x + y; }
 
    public static void main(String args[])
    {
        int p = sum(10, 8);
        System.out.println("Sum: " + p);
    }
}

5. POJO类

“Plain Old Java Object”是“Plain Old Java Object”的缩写。 POJO 类只有私有变量，使用 setter 和 getter 方法来访问它们。它是一个纯数据结构，其字段可以覆盖一些 Object 方法（例如 equals）或其他接口（例如可序列化），但它没有自己的行为。

POJO 类属性：

• 编写 POJO 类时，需要公共的 setter 和 getter 方法。
• 私有变量应该用于所有实例变量。
• 它不应该扩展已经定义的类。
• 它不应实现已预定义的接口。
• 不应该有预定义的注释。
• 它可能没有不带参数的函数Object() { [native code] }。

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
class POJO {
    private int value = 365;
    public int getValue() { return value; }
    public void setValue(int value) { this.value = value; }
}
public class GFG {
    public static void main(String args[])
    {
        POJO p = new POJO();
        System.out.println(p.getValue());
    }
}

6. 单例类

单例类是在任何时候都只有一个对象的类。即便如此，如果我们再次尝试创建实例，新创建的实例仍会引用前一个实例。我们通过任何实例对类进行的任何修改也会影响该特定实例中的变量。它通常用于在处理数据库连接和套接字编程时管理访问。

以下用于制作单例类：

• 制作一个仅对您可用的函数Object() { [native code] }。
• 创建一个返回单例类对象的静态函数（使用延迟初始化）。

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
class Singleton {
 
    private static Singleton single_instance = null;
 
    public String s;
 
    private Singleton()
    {
        s = "This is a string part of Singleton class";
    }
    // here a private constructor is used
 
    // Method
    public static Singleton Singleton()
    {
        if (single_instance == null) {
            single_instance = new Singleton();
        }
        return single_instance;
    }
}
 
// Main class
class GFG {
    public static void main(String args[])
    {
        Singleton x = Singleton.Singleton();
        Singleton y = Singleton.Singleton();
 
        // change var of x
        x.s = (x.s).toUpperCase();
 
        System.out.println("String from x is -->" + x.s);
        System.out.println("String from y is -->" + y.s);
        System.out.println("\n");
 
        y.s = (y.s).toLowerCase();
 
        System.out.println("String from x is -->" + x.s);
        System.out.println("String from y is -->" + y.s);
    }
}

7.内部类

我们可以在Java中的类中定义一个类，这些类称为嵌套类。它用于逻辑排列类并实现封装。内部类可以访问外部类成员（包括私有）。

句法：

Java

import java.io.*;
 
class OuterClass {
    // Write the code
    class NestedClass {
        // Write the code
    }
}

内部类有 4 种类型：

• 嵌套内部类
• 匿名内部类
• 静态嵌套类
• 方法局部内部类

A. 嵌套内部类：

它可以访问外部类的私有实例变量。访问修饰符 private、protected、public 和 default 可以应用于任何实例变量。

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
class Outer {
    class Inner {
        public void show()
        {
            System.out.println("Inside a nested class");
        }
    }
}
 
class GFG {
    public static void main(String[] args)
    {
        Outer.Inner in = new Outer().new Inner();
        in.show();
    }
}

B. 匿名内部类：

基本上，这些类的声明没有任何名称。

示例 1：使用子类

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
class Outer {
    void show()
    {
        System.out.println("Show method of super class");
    }
}
 
class GFG {
 
    static Outer o = new Outer() {
        void show()
        {
            super.show();
            System.out.println("Demo class");
        }
    };
 
    public static void main(String[] args) { o.show(); }
}

示例 2：使用接口

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
    static Hello h = new Hello() {
        public void show()
        {
            System.out.println(
                "This is an anonymous class");
        }
    };
 
    public static void main(String[] args) { h.show(); }
}
 
interface Hello {
    void show();
}

C. 静态嵌套类：

这些类就像外部类的静态成员。

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
    static int data = 100;
    static class Inner {
 
        void msg()
        {
            System.out.println("data is " + data);
        }
    }
 
    public static void main(String args[])
    {
        GFG.Inner obj = new GFG.Inner();
        obj.msg();
    }
}

D. 方法局部内部类：

内部类可以在外部类的方法中声明。

Java

import java.io.*;
import java.lang.*;
import java.util.*;
 
class Outer {
    void outerMethod()
    {
        System.out.println("Outer Method");
        class Inner {
            void innerMethod()
            {
                System.out.println("Inner Method");
            }
        }
 
        Inner y = new Inner();
        y.innerMethod();
    }
}
class GFG {
    public static void main(String[] args)
    {
        Outer x = new Outer();
        x.outerMethod();
    }
}