Java的类和对象_java类-CSDN博客

本文链接：https://blog.csdn.net/2402_87940708/article/details/146274600

在说类和对象之前要先理解一下：什么是面向对象？

其实Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

在java语言中类是怎么定义和使用的呢？

在java中定义类时需要用到class关键字，如下↓

// 创建类
class ClassName{
ﬁeld; //成员变量
method; //成员方法
}

class为定义类的关键字，ClassName为类的名字，{}中为类的主体

成员变量和成员方法是怎么是怎么创建的呢？

其实有点类似于C语言中的结构体，但又有很大的不同，以狗这个类来创建↓

class Dog{
//访问修饰符 类型   变量
    public String name;//成员变量
    public int age;//成员变量
    
    //成员方法(狗的行为)
    public void bark(){
        System.out.println(name + " 正在汪汪叫");
    }
}

下面就要说到类的实例化，何为类的实例化？

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，如上面的Dog就是一个新类型。有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

在创建好对象后如何访问对象呢？

在java中使用 . 来访问对象中的属性和方法，有点类似于c语言。

class Dog{
//访问修饰符 类型   变量
    public String name;//成员变量
    public int age;//成员变量

    //成员方法(狗的行为)
    public void bark(){
        System.out.println(name + " 正在汪汪叫");
    }
}
public class Test {
    public static void main(String[] args) {
        //实例化对象
        Dog dog1 = new Dog();
        //用.号访问成员变量和成员方法(类似于C语言)
        dog1.name = "大黄";
        dog1.age = 3;
        System.out.println(dog1.name);
        System.out.println(dog1.age);
        dog1.bark();
    }
}

一个类也是允许创建多个对象的

说明：

1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.2. 类是一种自定义的类型，可以用来定义变量.
3. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

下面来讲到this引用的用法：

先来看这么一串代码

class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int year, int month, int day){
        year = year;
        month = month;
        day = day;
    }
    public void printDate(){
        System.out.println(this.year + "/" + this.month + "/" + this.day);
    }
}
public class Test2{
    public static void main(String[] args) {
        Date d = new Date();
        d.setDay(2020,9,15);
        d.printDate();
    }
}

输出的结果为↓

为什么呢？不是setDay传入参数2020，9，15了吗怎么还是0

其实看到setDay里面的内容year = year 你怎么能确定year是参数传进来的局部变量还是成员变量

很明显成员变量并没有被赋值。所以在这里java中有一种规则叫做局部变量优先使用的规则

解决方法有两种用this引用还有一种就是用不同的变量名这里来说一下用this引用

this其实就是代表的创建对象的引用名下面this就是代表的是d

class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(this.year + "/" + this.month + "/" + this.day);
    }
}
public class Test2{
    public static void main(String[] args) {
        Date d = new Date();
        d.setDay(2020,9,15);
        d.printDate();
    }
}

这样就能完美的解决

this引用的特点：

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
2. this只能在"成员方法"中使用
3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象
4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法
对象的引用传递给该成员方法，this负责来接收

下面来讲一下对象的初始化，有三种方法

第一种：默认初始化，就是只创建成员变量什么值都不赋给,编译器会自动帮我们把变量初始化为对应的“0”值，例如int char byte....都会被初始化为0 String会被初始化为null，boolean类型会被初始化为false

class Dog{
//访问修饰符 类型   变量
    public String name;//成员变量
    public int age;//成员变量

    //成员方法(狗的行为)
    public void bark(){
        System.out.println(name + " 正在汪汪叫");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

第二种：就地初始化，在创建变量的时候就初始化

class Dog{
//访问修饰符 类型   变量
    public String name = "大黄";//成员变量
    public int age = 2;//成员变量

    //成员方法(狗的行为)
    public void bark(){
        System.out.println(name + " 正在汪汪叫");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

这两种初始化方式都有很大的弊端

所以在java语言中提供了一种方法叫做构造方法，构造方法就是为了初始化对象

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

class Dog{
//访问修饰符 类型   变量
    public String name;//成员变量
    public int age;//成员变量
    //构造方法↓
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //成员方法(狗的行为)
    public void bark(){
        System.out.println(name + " 正在汪汪叫");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("大黄", 2);
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

在实例化对象的时候就要传参初始化dog对象

构造方法与普通方法略微有些不同

构造方法的特性：

1. 名字必须与类名相同
2. 没有返回值类型，设置为void也不行
3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

上述Dog类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方

法。注意：一旦用户定义，编译器则不再生成。总之构造方法是一定存在的。

构造方法可以存在多个构成方法重载，也可以通过一个构造方法使用this()调用其他构造方法，this()必须在构造方法的第一条

class Dog{
//访问修饰符 类型   变量
    public String name;//成员变量
    public int age;//成员变量
    //构造方法1↓
    public Dog() {
        this("大黄",2);//调用构造方法2
    }
    //构造方法2
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //成员方法(狗的行为)
    public void bark(){
        System.out.println(name + " 正在汪汪叫");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

接下来说：静态成员变量(被static修饰）

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

class Dog{
//访问修饰符 类型   变量
    public static String name;//成员变量
    public int age;//静态成员变量
    //构造方法1↓
    public Dog() {

        this("大黄",2);//调用构造方法2
    }
    //构造方法2
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //静态成员方法(狗的行为)
    public static void bark(){
        System.out.println(name + " 正在汪汪叫");
       // System.out.println(age);爆红 不能访问非静态成员变量
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        //System.out.println(dog.age);
        System.out.println(Dog.name);//通过类名访问
    }
}

静态成员方法&变量的特性：

1. 不属于某个具体的对象，是类方法
2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者
3. 不能在静态方法中访问任何非静态成员变量

4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

5.非静态方法能调用静态方法和静态成员变量

6.静态方法无法重写(下一篇文章会介绍到)

最后来说一下代码块：

静态代码块：static{内容} 一般用于初始化静态成员变量。

实例代码块：{内容} 能初始化静态成员变量，也能初始化非静态的成员变量

class Dog{
//访问修饰符 类型   变量
    public String name;//成员变量
    public static int age;//静态成员变量
    //静态代码块
    static{
        age = 18;
    }
    //实例代码块
    {
        name = "小黄";
    }
   
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}