Java类和对象知识点总结_java基础语法以及类与对象知识回顾-优快云博客

本文链接：https://blog.youkuaiyun.com/shushuyu_/article/details/121364012

本文详细介绍了Java中类与对象的基本概念，包括类的定义、成员变量与方法、封装、构造方法等内容，并提供了丰富的示例代码帮助理解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.类的初步认识

类就是一类对象的统称。对象就是这一类具体化的一个实例。一个模子可以实例化无数个对象。一个类，可以产生无数的对象。

声明一个类就是创建一个新的数据类型，而类在Java中属于引用类型，Java使用关键字class来声明。

下面是基本语法：

class <class_name>{
    field;//成员属性/字段/成员变量
    method;//成员方法/方法
}
<class_name> <对象名> = new <class_name>();

//例子
class Person{
    public int num;//成员属性
    public String name;
    public void run(){//成员方法
        System.out.println("跑");
    }
}
public class Main{
    public static void main(String[] args){
        Person person = new Person();//通过new实例化对象
        person.run();//成员方法调用需要通过对象的引用调用
    }
}

注意事项：

new关键字用于创建一个对象的实例。
使用.（点）来访问对象中的属性和方法。
同一个类可以创建多个实例。
普通的成员变量都是属于对象的
person是一个变量，不是地址。只不过这个变量，里面存储的是地址。所以，这个变量，也被叫做引用。

2.类的成员

字段/属性/成员变量（三种称呼都可以）

但是成员变量要细分为静态成员变量和普通成员变量。用static修饰的成员变量叫做静态成员变量，也叫作类变量，被static修饰后的成员变量是放在方法区（存储代码的片段）的，所以此时它不属于某个对象而是属于某个类，调用时用类调用就行。

例子：

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.age = 21;//普通成员变量
        person.name = "dj";
        person.num++;//静态成员变量
        System.out.println(person.age);//21
        System.out.println(person.num);//1
        System.out.println("====================================");
        Person person1 = new Person();
        person1.age++;//普通成员变量
        person1.num++;//静态成员变量
        System.out.println(person1.age);//1
        System.out.println(person1.num);//2
        Person.num++;
        System.out.println(Person.num);//用类直接调用（正确的调用方法）
    }
}
class Person{
    public int age;
    public String name;
    public static int num;//静态成员变量
}

结果：

注意事项：

成员变量的初始值为0。
静态成员变量不依赖于对象，调用方法：类名.静态的成员属性/方法。
静态的成员变量，是不可以在方法中定义的，静态方法也不行，它只能属于类，不能属于方法。
普通方法里可以调用静态方法，但是静态方法里不能调用普通方法，因为静态的方法本身不依赖对象，所以无法调用普通方法。
this和super两个关键字不能在静态上下文中使用。
一个引用不可以指向多个对象，如果有多个只是指向了最后一次的对象
引用一定是在栈上吗？不是，不同的成员变量有不同的情况。

Person person3 = null;//这个引用不指向任何的对象
 Person person = new Person();
Person person2 = person;//person2这个引用指向person这个引用所指向的对象

3.封装

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的，只要知道如何使用类就可以了。大大降低了学习和使用的复杂程度

private实现封装：

private和public这两个关键字表示访问权限控制。

被public修饰的成员变量或者方法，可以直接被类的调用者。
被private修饰的成员变量或者成员方法，不能被类的调用者使用。

getter和setter方法：

class Person{
    private int a;
    public void setNum(int myNum){
        this.num = myNum;//this引用，表示调用当前方法的对象
    }
    public int getNum(){
        return num;
    }
}
public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setNum(100);
        System.out.println(person.getNum());//100
    }
}

注意事项：

当set方法的形参名字和类中的成员属性的名字一样时，如果不使用this，相当于自赋值。this表示当前实例的引用。
不是所有的字段都一定要提供setter/getter方法，而是要根据实际情况决定提供哪种方法。

4.构造方法

构造方法：

方法名和类名是相同的，且构造方法比较特殊，没有返回值。

构造方法是干嘛的？

一个对象的产生（对象的实例化）

1.为对象分配内存。

2.调用合适的构造方法。（合适意味着构造方法不止一个）

当完成上面这两步之后，对象才真正产生。

语法规则

方法名必须和类名相同
构造方法没有返回值类型声明
每一个类中一定至少存在一个构造方法（如果没有明确定义，系统会自动生成一个无参构造）

注意事项

如果类中没有提供任何的构造参数，那么编译器会默认生成一个不带参数的构造函数
若类中定义了构造方法，则默认的无参构造将不再生成
构造方法之间可以重载，规则和普通方法的重载一致
this不能代表当前的对象，只能代表当前对象的引用

this的三种用法：

this.data 调用当前对象
this.func() 调用当前对象的方法
this() 调用当前对象的其他构造方法

例子

class Person{
    public int age;
    public String name;
    public Person(){
        this("dj",21);//调用带两个参数的构造方法，只能用一个this.()而且必须放到第一行
        System.out.println("Person()::不带参数的构造方法");
    }
    public Person(String name){
        this.name = name;
        System.out.println("Person(String)::带一个参数的构造方法");
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person()::带有两个参数的构造方法");
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\''+"}";
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);
    }
}

输出结果：

5.认识代码块

我们知道成员变量初始化可以就地初始化或者用构造方法初始化，还有一种方法就是使用代码块初始化。

代码块可以分为以下四种：

普通代码块：方法里面直接定义的代码块
构造块：定义在类中的代码块（不加修饰符），也可以叫实例代码块
静态块：使用static定义的代码块，一般用于初始化静态成员属性
同步代码块

注意事项

静态代码块只会执行一次，而且最先执行
静态代码块执行完毕后，实例代码块执行，最后是构造函数执行
静态代码块不用实例化对象都可以被执行
当静态的成员变量在类和代码块中被定义了多次，那么和定义的顺序是有关系的，以最后一次定义的为结果。（例外：当没有被初始化时以最后一次初始化的值为结果）

例子：

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        {
            System.out.println("普通代码块");
        }
        System.out.println(person.num);
    }
}
class Person{
    public int age;
    public String name;

    private int a;
    public void setNum(int myNum){
        //num = myNum;
        this.num = myNum;//this引用，表示调用当前方法的对象的引用
    }
    public int getNum(){
        return num;
    }
    public Person(){
        this("dj",21);//调用带两个参数的构造方法，只能用一个this.()而且必须放到第一行
        System.out.println("Person()::不带参数的构造方法");
    }
    public Person(String name){
        this.name = name;
        System.out.println("Person(String)::带一个参数的构造方法");
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person()::带有两个参数的构造方法");
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\''+"}";
    }
    {
        System.out.println("实例代码块");
    }
    static {
        num = 99;
        System.out.println("静态代码块");
    }
    public static int num =19;//静态成员变量
}

运行结果：

6.匿名对象

从字面意思我们可以理解为没有名字的对象

没有引用的对象
只在创建对象时使用
每次只能使用一次，如果一个对象只用一次，后面不需要了可以考虑使用匿名对象

例子：

public class Main {
    public static void main(String[] args) {
        System.out.println(new Person("dj",21).toString());
    }
}
class Person{
    public int age;
    public String name;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person()::带有两个参数的构造方法");
    }
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\''+"}";
    }
}

运行结果：