目录

何为类，何为对象?

一.对于类

1.idea修改文件类名

二.对于对象

三.this关键字

1.区分成员变量和局部变量

2.引用当前对象

3.调用当前对象的其他构造方法

4.总结

四.构造方法

1.利用idea特性快速写出构造方法

五.封装

1.利用idea特性快速写出set和get

---

何为类，何为对象?

类，简单点来说，就是用来对对象进行描述的，主要是用来描述其有何功能，有何特点，有何作用的。比如说老虎是一个类，那么我们就说可以定义一个对象(老虎)，描述该对象可以跑，可以吃饭，可以睡觉，具有凶猛，力气大等的特点。

具体我们继续往下看!

---

一.对于类

定义：类是一个模板或蓝图，用于创建对象。它定义了一组属性（数据）和方法（函数或行为），这些属性和方法描述了该类对象的特征和行为。

class为定义类的关键字

格式：

class className{

      field;//成员变量(属性)

      method;//成员方法(行为)

}

注意事项:

1.类名注意采用大驼峰定义。 如：Person、Car。

2.成员变量和成员方法使用小驼峰命名。 如：getName()、setAge()。

3.一般一个文件当中只定义一个类。

4.main方法所在的类一般要使用public修饰

5.public修饰的类必须要和文件名相同

我们来看一个例子:

我们定义一个电脑类

//类
class Computer {
    //成员变量（属性）
    String brand;//品牌
    String mouse;//鼠标
    String keyboard;//键盘
    String hardDrive;//硬盘
    String display;//显示屏
    //等等

    //成员方法（行为）
    public void writeCode(){
        System.out.println("写代码...");
    }
    public void click(){
        System.out.println("点击...");
    }
    public void watchVideos(){
        System.out.println("看视频...");
    }
    //等等
}

---

1.idea修改文件类名

---

二.对于对象

定义：对象是类的实例。它是通过类定义的蓝图创建的具体实体。每个对象都有自己的状态（属性值）和行为（方法）。

格式：

ClassName objectName = new ClassName();   

注意事项：

1.对于格式括号里的参数，需要根据类的构造方法的参数来写，一般没有重写类的构造方法就不用写参数。

2.对象是在 堆内存 中创建的

3.对象的创建通常发生在方法中，而不是在类中直接创建。

我们继续上面的例子来写:

//类
class Computer {
    //成员变量（属性）
    String brand;//品牌
    String mouse;//鼠标
    String keyboard;//键盘
    String hardDrive;//硬盘
    String display;//显示屏
    //等等

    //成员方法（行为）
    public void writeCode(){
        System.out.println("写代码...");
    }
    public void click(){
        System.out.println("点击...");
    }
    public void watchVideos(){
        System.out.println("看视频...");
    }
    //等等
    public static void main(String[] args) {
        
        Computer com=new Computer();//实例化一个对象
        
        //通过" . "来访问对象的方法和属性
        com.brand="华为";//将该对象的属性品牌初始化为华为,以下同理
        System.out.println(com.brand);
        com.display="三星显示屏";
        System.out.println(com.display);
        com.mouse="罗技鼠标";
        System.out.println(com.mouse);
        com.keyboard="rk98";
        System.out.println(com.keyboard);
        com.hardDrive="西数固态硬盘";
        System.out.println(com.hardDrive);

        //调用对象的方法
        com.click();
        com.watchVideos();
        com.writeCode();
    }
}

---

三.this关键字

this是java的一个引用，他指向当前对象的实例。

一般用于区别类的成员变量和方法中的局部变量，以及调用类的其他构造方法或方法。

---

1.区分成员变量和局部变量

我们来看个例子：

下面的代码是否会输出zhangfei?

输出结果为null,这是为什么?

我们在idea中看到下面两个黄色提示

意思是:

从未使用分配给“name”的值“name”
变量“name”被分配给它自己

简单来说就是name = name; 只是将方法的参数 name 赋值给自己，没有赋值给类的成员变量 name，因此不会改变成员变量 name 的值。

所以此时就需要用到我们的this关键字,将第一个name指向对象的实例

public class Test {
    String name;
    public void person(String name){
        this.name=name;//相当于test.name=name
    }

    public static void main(String[] args) {
        Test test=new Test();
        test.person("zhangfei");
    }
}

输出一下:

---

2.引用当前对象

在方法中使用 this 表示调用该方法的对象实例，通常用于将当前对象作为参数传递给其他方法。

public class Test {
    String name;
    public void dispaly(){
        System.out.println(this);
    }

    @Override//重写
    public String toString() {
        return "Test{" +
                "name='" + name + '\'' +
                '}';
    }//重写toString,后面讲

    public static void main(String[] args) {
        Test test=new Test();
        test.name="wusong";
        test.dispaly();
    }
}

输出:

当然如果我们没有重写的那一部分代码，输出结果是:

但是不影响我们这this的使用方法,和指向的对象。

---

3.调用当前对象的其他构造方法

使用 this 调用其他构造方法可以减少代码重复。这种调用必须是构造方法中的第一个语句。

public class Person {
    private String name;
    private int age;

    public Person(String name) {
        this(name, 0); // 调用另一个构造方法
    }

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

---

4.总结

(1)this ---表示当前对象

(2)this.data ---表示调用成员变量

(3)this.func ---表示调用成员方法

(4)this() ---表示调用构造方法

---

四.构造方法

我们在创建对象的时候给成员变量初始化的时候，常常是通过类方法赋值的，那么有没有更方便的方法来初始化成员变量呢?

回答是:有，那就是构造方法。

---

构造方法（或称构造函数，Constructor）是一种特殊的方法，用于在创建对象时初始化对象的属性。构造方法的名称通常与类名相同，并且在实例化对象时自动调用，无需显式调用。构造方法的主要作用是为对象的属性赋予初始值，确保对象在使用前处于有效状态。

在整个对象的生命周期内只调用一次。

构造方法的格式：

[访问修饰符] 类名(参数列表) {
    // 构造函数的主体
}
 

不知道大家有没有想过为什么我们实例化对象的时候那个小括号那里为什么有时候是啥也没有，有时候又带有参数呢?比如:

我在前面对象的注意事项那里讲过那里提到过构造函数。实际上就是跟构造函数有关。

在java中，构造函数又具有以下特点:

• 无返回类型：构造方法没有返回类型，甚至没有 void 关键字。
• 与类名相同：构造方法名称必须与类名相同，以便编译器识别它为构造方法。
• 可以重载：可以定义多个构造方法（构造方法重载），每个构造方法的参数列表不同，以支持不同的初始化方式。

我们来看一个例子:

public class Test {
    String name;
    public void dispaly(){
        System.out.println(name);
    }

    public static void main(String[] args) {
        Test test=new Test();//隐式调用构造方法(隐藏起来了),使用默认的无参且无初始化的构造方法
        test.name="wusong";
        test.dispaly();
    }
}

其实呢 上面的代码相当于我下面写的代码(也是无参无初始化):

这里我们重新再写一个构造方法，带参带初始化:

public class Test {
    String name;
    public void dispaly(){
        System.out.println(name);
    }
    //构造方法

    public Test(String name) {
        this.name = name;//this指向对象的实例
    }
    public static void main(String[] args) {
//        Test test=new Test();//当我们写了重载(这个后面讲)了一个带参的构造方法且只有一个后，这里不写实参会报错!
        Test test=new Test("zhangfei");
        test.dispaly();
    }
}

这样就可以实现实例化对象的时候连带初始化成员变量了。

注意事项:

1.当我们在类中创建了一个带参的构造方法，此时我们就不能调用原来那个隐式默认的无参构造方法了(以前你对我爱答不理，现在你高攀不起(bushi))，除非你自己再创建一个无参的构造方法。

2.在一个类中可以有多个构造方法。

3.可以在一个构造方法中调用另外一个构造方法(当然不能你调用我，等一下我又调用你这样形成闭环)。

---

1.利用idea特性快速写出构造方法

效果如图：

---

五.封装

封装其实就是将对象的属性和方法隐藏在内部，不让外部直接访问或者修改。

如何实现？

• 将属性设为私有（private）：使得类的属性只能在类内部访问。
• 提供公共的访问方法：通过 public 的方法（如 get、set 方法）控制属性的访问权限。
• 通过访问控制修饰符控制可见性：private、protected、public 等修饰符可以限制访问范围，确保数据安全。

(注意这里的每一点可不是步骤，每一点都是实现封装的方法)

这里做一个访问限制符提供给大家参考:

No	范围	private	default	protected	public
1	同一包中的同一类	√	√	√	√
2	同一包中的不同类		√	√	√
3	不同包中的子类			√	√
4	不同包中的非子类				√

注意：default是没给成员变量写访问限制符的时候默认的情况。

下面我们随便举个例子

/
//Person类

public class Person {
    private int age;
    private String name;
    //构造方法
    public Person(int age,String name){
        this.age=age;
        this.name=name;
    }
}


/
//Test类

public class Test {
    public static void main(String[] args) {
        //实例化对象
        Person per=new Person(18,"zhangfei");
        System.out.println(per.age);;//报错:'age' has private access in 'Person'
        System.out.println(per.name);//报错:'name' has private access in 'Person'
    }
}

此时我们能看到这两个错误：

即:

“age”在“Person”中具有私人访问权限
“name”在“Person”中具有私有访问权限

虽然说成员变量受到private的权限保护，只能在同一类中进行访问，但是我们可以通过某些特定的方法跨类来访问成员变量

如下代码所示：

/
//Person类

public class Person {
    private int age;
    private String name;
    public Person(int age,String name){
        this.age=age;
        this.name=name;
    }
    //获取age成员变量
    public int getAge() {
        return age;
    }

    //修改age成员变量
    public void setAge(int age) {
        this.age = age;
    }
    //获取name成员变量
    public String getName() {
        return name;
    }
    //修改age成员变量
    public void setName(String name) {
        this.name = name;
    }
}




/
//Test类

public class Test {
    public static void main(String[] args) {
        Person per=new Person(18,"zhangfei");
        System.out.println(per.getAge());
        System.out.println(per.getName());
        per.setAge(20);//修改age
        per.setName("wusong");//修改name
        System.out.println(per.getAge());
        System.out.println(per.getName());
    }
}

代码解释：

1.因为成员变量和我们写的getAge，setAge，getName，setName在同一个类中，所以这些方法可以访问成员变量。

2.与此同时，这些方法又被public修饰，他们可以在不同类中被访问，所以这就使得成员变量可以被访问了。

结果输出为：

---

1.利用idea特性快速写出set和get

效果如图：