Java 类和对象

类和对象是面向对象编程的基本概念，围绕着现实生活中的实体。

类

1.类是一组具有共同特征/行为和共同属性/属性的对象。

2.类不是一个现实世界的实体。它只是一个模板或蓝图或原型，对象是由它创建的。

3.类不占用内存。

4.类是一组不同数据类型的变量和一组方法。

在java中一个类可以包含：

- 数据成员

- 方法

- 构造函数

- 嵌套类和

- 接口

Syntax to declare a class:
access_modifier class<class_name>
{  
    data member;  
    method;  
    constructor;
    nested class;
    interface;
}

例如：

- 动物

- 学生

- 鸟类

- 车辆

- 公司

class Student
{ 
    int id;//data member (also instance variable) 
    String name; //data member (also instance variable) 
 
    public static void main(String args[])
    { 
        Student s1=new Student();//creating an object of Student 
        System.out.println(s1.id); 
        System.out.println(s1.name); 
     } 
} 

类是一个用户定义的蓝图或原型，对象就是从这里创建的。它代表了一种类型的所有对象所共有的属性或方法的集合。一般来说，类的声明可以依次包括这些部分。

1. 修饰语 ：一个类可以是公共的，也可以是默认访问的（详情请参考此）。
2. 类关键字： 类关键字用于创建一个类。
3. 类 的名称：该名称应该以首字母开始（按惯例大写）。
4. 超类（如果有的话）： 类的父类（超类）的名字，如果有的话，前面加上关键字extends。一个类只能扩展（子类）一个父类。
5. 接口（如果有的话）： 以逗号分隔的列表，列出该类所实现的接口（如果有的话），前面加上关键字 implements。一个类可以实现一个以上的接口。
6. 主体： 类的主体由大括号{ }包围。

构造器用于初始化新对象。字段是提供类及其对象状态的变量，方法用于实现类及其对象的行为。
在实时应用程序中，有各种类型的类，如嵌套类、匿名类、lambda表达式。

对象

它是面向对象编程的一个基本单位，代表了现实生活中的实体。一个典型的Java程序会创建许多对象，如你所知，这些对象通过调用方法进行交互。一个对象由以下部分组成。

1. 状态 ：它由一个对象的属性表示。它也反映了一个对象的属性。
2. 行为 ：它由一个对象的方法表示。它也反映了一个对象与其他对象的反应。
3. 身份 ：它给一个对象一个独特的名字，使一个对象能够与其他对象进行交互。

对象的例子：狗

对象对应于现实世界中的事物。例如，一个图形程序可能有诸如 “圆”、”方 “和 “菜单 “等对象。一个在线购物系统可能有诸如 “购物车”、”客户 “和 “产品 “等对象。

声明对象（也叫实例化类）

当一个类的对象被创建时，这个类就被称为 实例化了 所有的实例都共享该类的属性和行为。但这些属性的值，即状态对每个对象来说是唯一的。一个单一的类可以有任何数量的实例。

例子。

当我们声明变量时，如（type name;）。这就通知编译器，我们将用这个名字来指代类型为type的数据。对于一个原始变量，这个声明也为该变量保留了适当的内存量。所以对于引用变量，类型必须是严格的具体类名。一般来说，我们 不能 创建抽象类或接口的对象。

Dog tuffy;

如果我们像这样声明一个引用变量(tuffy)，它的值将是不确定的(null)，直到一个对象被实际创建并分配给它。仅仅声明一个引用变量并不能创建一个对象。

初始化一个对象

new操作符通过为一个新的对象分配内存并返回对该内存的引用来实例化一个类。new操作符也调用了类的构造函数。

// Class Declaration
 
public class Dog
{
    // Instance Variables
    String name;
    String breed;
    int age;
    String color;
 
    // Constructor Declaration of Class
    public Dog(String name, String breed,
                   int age, String color)
    {
        this.name = name;
        this.breed = breed;
        this.age = age;
        this.color = color;
    }
 
    // method 1
    public String getName()
    {
        return name;
    }
 
    // method 2
    public String getBreed()
    {
        return breed;
    }
 
    // method 3
    public int getAge()
    {
        return age;
    }
 
    // method 4
    public String getColor()
    {
        return color;
    }
 
    @Override
    public String toString()
    {
        return("Hi my name is "+ this.getName()+
               ".\nMy breed,age and color are " +
               this.getBreed()+"," + this.getAge()+
               ","+ this.getColor());
    }
 
    public static void main(String[] args)
    {
        Dog tuffy = new Dog("tuffy","papillon", 5, "white");
        System.out.println(tuffy.toString());
    }
}

输出

Hi my name is tuffy.
My breed,age and color are papillon,5,white

输出

Hi my name is tuffy.
My breed,age and color are papillon,5,white

通过使用方法/函数进行初始化

/*package whatever //do not write package name here */
public class GFG {
    // sw=software
    static String sw_name;
    static float sw_price;
 
    static void set(String n, float p) {
        sw_name = n;
        sw_price = p;
    }
 
    static void get() {
        System.out.println("Software name is: " + sw_name);
        System.out.println("Software price is: " + sw_price);
    }
 
    public static void main(String args[]) {
        GFG.set("Visual studio", 0.0f);
        GFG.get();
    }
}

输出

Software name is: Visual studio
Software price is: 0.0

• 这个类包含一个单一的构造函数。我们可以识别一个构造函数，因为它
• 的声明与该类的名称相同，而且没有返回类型。Java编译器根据参数的数量和类型来区分构造函数。 狗类 中的构造函数需要四个参数。下面的语句提供了 “tuffy”、”papillon”、5、”white “作为这些参数的值。

Dog tuffy = new Dog("tuffy","papillon",5, "white");

• 执行该语句的结果可以说明为 。

注意： 所有的类都至少有 一个 构造函数。如果一个类没有明确声明，Java编译器会自动提供一个无参数的构造函数，也叫默认构造函数。这个默认构造函数会调用类父的无参数构造函数（因为它只包含一条语句，即super();），如果该类没有其他的父，则调用 Object 类的构造函数（因为Object类是所有类的父，无论是直接还是间接）。

创建一个类的对象的方法

在java中有四种方法来创建对象。严格来说，只有一种方法（使用 new 关键字），其余的都是内部使用 new 关键字。

• 使用new关键字： 这是在java中创建一个对象的最常见和最普遍的方法。例子。

// creating object of class Test
Test t = new Test();

• 使用Class.forName(String className)方法： 在java.lang包中有一个预定义的类，名称为Class。forName(String className)方法返回与给定字符串名称的类相关的Class对象。我们必须为一个类提供一个完全合格的名字。在这个Class对象上调用new Instance()方法时，会返回给定字符串名称的新的Class实例。

// creating object of public class Test
// consider class Test present in _com.p1_ package
Test obj = (Test)Class.forName("com.p1.Test").newInstance();

• 使用clone()方法： clone()方法存在于Object类中。它创建并返回一个对象的副本。

// creating object of class Test
Test t1 = new Test();

// creating clone of above object
Test t2 = (Test)t1.clone();

• 反序列化： 反序列化是一种从文件中的保存状态读取对象的技术。参考java中的序列化/反序列化

FileInputStream file = new FileInputStream(filename);
ObjectInputStream in = new ObjectInputStream(file);
Object obj = in.readObject();

只用一种类型创建多个对象（一个好的做法）

• 在实时情况下，我们在不同的方法中需要一个类的不同对象。创建大量的引用来存储它们并不是一个好的做法，因此我们声明一个静态引用变量，并在需要时使用它。在这种情况下，内存的浪费就会减少。那些不再被引用的对象将被java的垃圾收集器销毁。例子。

Test test = new Test();
test = new Test();

• 在继承系统中，我们使用父类引用变量来存储子类对象。在这种情况下，我们可以使用同一个引用变量切换到不同的子类对象。例子。

class Animal {}

class Dog extends Animal {}
class Cat extends Animal {}

public class Test
{
    // using Dog object
    Animal obj = new Dog();

    // using Cat object
    obj = new Cat();
}       

匿名对象

匿名对象是被实例化的对象，但没有被存储在一个引用变量中。

• 它们被用于即时的方法调用。
• 它们将在方法调用后被销毁。
• 它们在不同的库中被广泛使用。例如，在AWT库中，它们被用来在捕获一个事件（如按下一个键）时执行一些动作。
• 在下面的例子中，当一个按键被按下时，我们只是简单地创建一个EventHandler类的匿名对象来调用handle方法。

btn.setOnAction(new EventHandler()
{
    public void handle(ActionEvent event)
    {
        System.out.println("Hello World!");
    }
});