关于类和对象超级初级小白知识

下面的内容只是一小部分，在整个面向对象的知识中并不完整，用于记忆和梳理

目录

前言：类和对象是什么？

一、定义类

 1.如何定义类

2.类的注意事项

二.类的实例化

1.创建对象的基础知识

2.如何创建对象

3.实例化举例

4.访问对象

5.实例化对象的一些注意事项

三、this引用

1.this引用的三大作用

2.具体使用

​编辑

四、初始化方式

1.默认初始化

2.就地初始化

3.构造方法

总结

1.类和对象

2.this引用

3.初始化成员变量

4.构造方法

---

前言：类和对象是什么？

（1）类是什么？

1.类是用来对一个实体(对象)来进行描述的。比如这个实体（对象）的大小、长度和质量等等。

2.类是Java语言中一种结构

3.类的一般组成：成员变量、成员方法和构造方法

（2）对象是什么？

1.对象是一个实体。如果说类是一个形容词，那么对象就是被形容词修饰的名称。

2.类是用来描述对象的。在Java语言中，对象是由类创造出来的。

3.类相当于是一个类型，通过类型来创建变量

（3）类、对象分别长什么样？

---

上面就是类和对象大概长什么样，接下来一起更加深入的去了解如何定义类跟对象吧

一、定义类

 1.如何定义类

（1）类的定义格式

class是定义类的一个关键字，是必须要有的。在class前面可以有一个修饰符，一般是public

// 创建类
class ClassName{  
    field;       // 字段(属性) 或者 成员变量
 
    method;      // 行为 或者 成员方法
}

（2）定义一个狗类

这个类的名字为：PetDog；其中，花括号中的代码是狗的一些属性 ，用户可自行添加。

（1）像前面两行代码，称为类的成员方法

（2）后面两个方法，称为类的属性

class PetDog {
    public String name;//名字
    public String color;//颜色
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
   }
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
   }
}

（3）类出现的两种形式

第一种：class+类名的方式创造

第二种：通过创造文件的形式

（4）类的改名操作

类不能直接在代码页面改名，需要通过以下的操作来

第一步：找到类的位置

第二步：

改名后：

在大概知道一个类是怎么定义之后，就应该了解在定义类时的一些注意事项，包括易错点和潜规则

2.类的注意事项

（1）一般一个java文件中定义一个类（推荐）

最好就是一个java文件中出现一个class就好

（2）类的命名采用大驼峰定义（推荐）

1.只有一个单词时，需要首字母大写

2.多个单词时，每个单词的首字母大写

（3）public修饰的类必须要和文件名相同（必须要求）

这种类 一般都是在创建类的时候自带的一个public（属于类的第二种创造方法）

（4）一般main方法所在的类使用public修饰（推荐）

---

了解了类的一些注意事项，就应该去了解对象是怎么来的，对象是什么了

二.类的实例化

用类类型创建对象的过程，称为类的实例化

1.创建对象的基础知识

1.使用new关键字和类名来创建对象

2.一般会有一个指向对象的引用（变量）

2.如何创建对象

第一种：有一个引用指向对象

第二种：匿名对象（当前用来理解对象是什么？）

这种直接是new+类名+（），这个整体就是一个对象

new Chichen6666();

3.实例化举例

这是一个定义好的狗类：

class PetDog {
    public String name;//名字
    public String color;//颜色
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
   }
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
   }
}

在主函数内使用类定义对象

public class Main{
 public static void main(String[] args) {
        PetDog dogh = new PetDog();     //通过new实例化对象
 }
}

实例化大致包含两步：（1）为对象分配内存空间（2）调用合适的构造方法进行初始化

4.访问对象

每实例化一个对象，该对象就会拥有类中全部属性，可以说这些属性是属于对象的，接下来就可以通过对象的引用去访问这些属性了

访问的格式：指向对象的引用（变量）+.  来访问对象中的属性和方法

class PetDog {
    public String name;//名字
    public String color;//颜色
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
   }
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
   }
}
public class Main{
 public static void main(String[] args) {
        PetDog dogh = new PetDog();     //通过new实例化对象
 
        dogh.name = "阿黄";//给对象中的name进行赋值
        dogh.barks();//访问成员方法
 }
}

5.实例化对象的一些注意事项

1.new 关键字用于创建一个对象的实例。

2.同一个类可以创建对个实例。

3.使用 . 来访问对象中的属性和方法。

三、this引用

1.this引用的三大作用

（1）this可以指向当前对象

（2）this可以调用成员方法

（3）this可以调用构造方法

2.具体使用

（1）指向当前对象

 当形参名字和成员变量名字一样时，是优先执行局部变量的，编译器就会认为两个变量都是局部变量，所以不能成功给成员变量赋值。

public class Data {
    public int year;
    public int month;
    public int day;
 
   public Data(int year,int month,int day) {
      year = year;
      month = month;
      day = day;
   }
   public void print() {//打印的方法
      System.out.println(this.year+"/"+this.month+"/"+this.day);
    }
 
    public static void main(String[] args) {
        Data data = new Data();//对象1
 
        Data data1 = new Data(1999,9,9);//对象2
        data1.print();//调用打印函数
    }
}

针对上面的情况，要使用this表明该变量属于对象的，是成员变量

public class Data {
    public int year;
    public int month;
    public int day;
 
   public Data(int year,int month,int day) {
      this.year = year;
      this.month = month;
      this.day = day;
   }
   public void print() {//打印的方法
      System.out.println(year+"/"+month+"/"+day);
    }
    public static void main(String[] args) {
        Data data = new Data();//对象1
 
        Data data1 = new Data(1999,9,9);//对象2
        data1.print();
    }
}

只要是成员变量，我们都可以在前面加上this引用。谁调用的这个变量，this就表明这个成员变量是这个对象的，就会给这个对象中的成员变量进行赋值

（2）调用成员方法

代码示例： 

class Student {
    public String name;
    public int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void study() {
        this.eat();//在一个方法中调用其他的方法
        System.out.println(this.name+"正在学习");
    }
    public void eat() {
        System.out.println(this.name+"正在干饭");
    }
 
}
 
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("张三",18);
        student1.study();
    }
}

结果分析示例：

（3）调用构造方法

常用于在一个构造方法中去调用其他的构造方法

代码示例：

class Student {
    public String name;
    public int age;
 
    public Student(String name, int age) {
        this();//必须放在第一行
        this.name = name;
        this.age = age;
    }
    public Student() {
        System.out.println("无参构造方法被this调用了");
    }
}
 
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("张三",18);
    }
}

注意事项：

this()调用构造方法时，必须放在第一行

四、初始化方式

我们定义类的时候，一般都会有成员变量和成员方法；而在定义成员变量的时候可以选择赋一个初值或者不赋（初始化），也可以在后续的操作中赋值，下面一一介绍

1.默认初始化

其实默认初始化就是不初始化，变量会有一个默认的初值

class PetDog {
    public String name;//默认初始化
    public String color;//默认初始化
}

2.就地初始化

就地初始化就是在定义成员变量的时候，直接赋值，这样定义的类的使用范围就会变得很狭窄，实例化的对象都是一样的属性

class PetDog {
    public String name = "旺财";//就地初始化
    public String color = "黄色";//就地初始化
}

---

所以为了能应对更多的情况，不同的对象属性不同，使用构造方法去初始化成员变量

3.构造方法

（1）什么是构造方法

1.构造方法又称为构造器，是一种特殊的成员方法。

2.在构造方法中，可以初始化成员变量。

（2）构造方法的特点

1.构造方法的名字必须与类名相同。

2.在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

3.无论用户有没有写构造方法，总是会被调用。

4.构造方法没有返回值这一说法，设置为void也不行。

5.构造方法可以重载。

 

（3）使用构造方法

第一种：编译器默认（隐式）提供

下面的类是没有构造方法的，当用户没有提供时，编译器会默认提供一个无参的构造方法

class PetDog {
    public String name;//名字
    public String color;//颜色
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
   }
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
   }
}

将编译器默认的构造方法显示出来

class PetDog {
    public String name;//名字
    public String color;//颜色
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
   }
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
   }
   public PetDog() {
        //默认的无参构造方法
    }
}

这个默认的无参构造方法即使我们不写出来，编译器也会默认提供（这里为了认识特意写出来）

第二种：自己写构造方法

class PetDog {
    public String name;//名字
    public String color;//颜色
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
   }
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
   }
   public PetDog() {
        //默认的无参构造方法
    }
    //自己写的构造方法
   public PetDog(String name,String color) {
       this.name = name;
       this.name = color;
    }
}

第三种：由编译器自己生成

由编译器生成的前提是：类中有成员变量，不然没有必要由编译时生成（默认会由有）

根据下面提升的操作：

第一步：这一步的快捷键为：Alt+Ins

第二步：

第三步：选择需要成员变量

结果展示：

---

上述就是构造方法的创造方法，下面介绍两种构造方法的区别，和当自己定义了构造方法之后，创建对象时的区别。

（4）构造方法的区别和初始化

下面介绍无参构造方法和有参构造方法在在实例化对象时候的区别

第一种区别：默认无参构造方法与有参构造方法的区别

无参构造方法在实例化对象的时候：

public class PetDog {
 
    public String name;//名字
    public String color;//颜色
 
    public PetDog() {
    }
}
class Test {
    public static void main(String[] args) {
        PetDog dog1 = new PetDog();
    }
}

 这种情况下的对象，就是为默认初始化的

有参的构造方法在实例化对象的时候：

总结

1.类和对象

（1）类是一个类型，用来创造对象

（2）类中有成员变量和成员方法

（3）对象的引用可以通过.号访问对象中的成员方法和成员变量

2.this引用

（1）this引用成员变量

（2）this调用成员方法

（3）this调用构造方法（存在一个构造方法中，必须在代码的第一行）

（4）this只能在成员方法中使用

（5）this调用构造方法时，不能形成闭环

3.初始化成员变量

（1）默认初始化

（2）就地初始化

（3）使用成员方法（在实例化对象时）

4.构造方法

（1）系统隐式默认提供

（2）手动显示提供

（3）通过编译器自己生成