JAVA——类的定义及其实例化

Java 中的类

类可以看成是创建 Java 对象的模板

修饰符 class 类名{
    修饰符 数据类型 属性名（成员变量）;//属性
    //构造方法(无修饰符，无返回值，名称和类名一样) 
    //方法（成员函数）
}

通过下面一个例子，简单理解一下 Java 类的定义

public class CAT{// public是类的修饰符，class是定义类的关键字，CAT是类名
    String name;
    int age;//name、age是类的成员变量
    void mm(){  // 喵喵叫
        System.out.println("喵喵~");
    }
    void hungry(){  // 饥饿
        System.out.println("喵~，我饿了");
    }//mm()、hungry()是类的方法，也叫成员函数
}

一个类可以包含以下变量类型：

1. 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁
2. 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问
3. 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型

构造方法

每个类都有构造方法。如果没有为类定义构造方法，Java将会为该类提供一个默认构造方法。构造方法没有返回值，名字与类名相同

public class Dog{
    public Dog(String name){//这个构造方法仅有一个参数：name
        //方法体
    }
}

创建对象

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

1. 声明：声明一个对象，包括对象名称和对象类型
2. 实例化：使用关键字 new 来创建一个对象
3. 初始化：使用 new 创建对象时，会调用构造方法初始化对象

public class Dog {
    public Dog(String name) {// 这个构造方法仅有一个参数：name
        System.out.println("小狗的名字是 : " + name);
    }

    public static void main(String[] args) {
        // 下面的语句将创建一个Dog对象
        Dog d = new Dog("tonny");
    }
}

访问类中的的成员变量和方法

如下所示，通过对象名点的方式来访问（[对象名].）

/* 实例化类 */
Person p = new Person();
/* 访问类中的变量 */
p.name;
/* 访问类中的方法 */
p.gethigh();

public class Dog {
    int DogAge;

    public Dog(String name) {
        // 这个构造器仅有一个参数：name
        System.out.println("小狗的名字是 : " + name);
    }

    public void setAge(int age) {
        DogAge = age;
    }

    public int getAge() {
        System.out.println("小狗的年龄为 : " + DogAge);
        return DogAge;
    }

    public static void main(String[] args) {
        /* 创建对象 */
        Dog myDog = new Dog("tommy");
        /* 通过方法来设定age */
        myDog.setAge(2);
        /* 调用另一个方法获取age */
        myDog.getAge();
        /* 你也可以像下面这样访问成员变量 */
        System.out.println("变量值 : " + myDog.DogAge);
    }
}

访问修饰符

访问修饰符也叫访问控制符，是指能够控制类、成员变量、方法的使用权限的关键字。

在面向对象编程中，访问控制符是一个很重要的概念，可以使用它来保护对类、变量、方法和构造方法的访问。

Java 支持四种不同的访问权限：

this 关键字

this 的作用一般有三个：使用this区分同名变量、作为方法名来初始化对象、作为参数传递

使用this 区分同名变量

成员变量与方法内部的变量重名时，希望在方法内部调用成员变量，怎么办呢？这时候只能使用 this

public class Demo {
    public String name;
    public int age;

    public Demo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void say() {
        System.out.println("我的名字是" + name + "，我" + age + "岁");
    }

    public static void main(String[] args) {
        Demo d = new Demo("王XX", 18);
        d.say();
    }
}

在 Demo() 中，形参和成员变量重名，如果不使用 this，访问到的就是局部变量 name 和 age，而不是成员变量。在 say() 中，我们没有使用 this，因为成员变量的作用域是整个实例，当然也可以加上 this

作为方法名来初始化对象

也就是相当于调用本类的其它构造方法，它必须作为构造方法的第一句。

public class Demo {
    public String name;
    public int age;

    public Demo() {
        this("王XX", 18);
    }

    public Demo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void say() {
        System.out.println("我的名字是" + name + "，今年" + age + "岁");
    }

    public static void main(String[] args) {
        Demo d = new Demo();
        d.say();
    }
}

有几点要注意

1. 在构造方法中调用另一个构造方法，调用动作必须置于最起始的位置
2. 不能在构造方法以外的任何方法内调用构造方法
3. 在一个构造方法内只能调用一个构造方法

作为参数传递

需要在某些完全分离的类中调用一个方法，并将当前对象的一个引用作为参数传递时。例如：

public class Demo {
    public static void main(String[] args) {
        B b = new B(new A());
    }
}

class A {
    public A() {
        new B(this).print(); // 匿名对象
    }

    public void print() {
        System.out.println("Hello from A!");
    }
}

class B {
    A a;

    public B(A a) {
        this.a = a;
    }

    public void print() {
        a.print();
        System.out.println("Hello from B!");
    }
}

匿名对象就是没有名字的对象。如果对象只使用一次，就可以作为匿名对象，代码中 new B(this).print(); 等价于 (new B(this) ).print();，先通过 new B(this)创建一个没有名字的对象，再调用它的方法