Java基础：类的基本语法

XuX_z

841人浏览 · 2026-01-03 17:38:31

XuX_z · 2026-01-03 17:38:31 发布

类的基本语法

大一蒟蒻学习Java基础的笔记

1.构造器

构造器，就是名字和类名一致，并且没有定义返回值的一种特殊方法。

构造器长什么样？如下代码所示：

//1.无参数构造器
public class Student{
    /*类中的构造器*/
    public Student(){ //只有修饰符，没有返回值（特殊形式）
        
    }
}
//2.有参数构造器
public class Student{
    public Student(String name,int age){
        
    }
}

构造器有什么特点呢？

创建对象时，对象会调用构造器，我们可以指定对象去调用哪个构造器去执行。

//例如：
Student s=new Student();

构造器的常见应用场景：

创建对象时，同时完成对对象成员变量(属性)的初始化赋值。

//例如：
//有参数构造器：
public class Student{
    String name;
    int age;
    char gender;
    public Student(String n,int a,char g){
        name=n;
        age=a;
        gender=g;
    }
}
//对象调用：
Student s1=new Student("乐邦詹士",41,'男')

构造器的注意事项：

1.类默认就自带了一个无参构造器；

2.如果为类定义了有参数构造器，类默认的无参数构造器就没有了，若还想用无参数构造器，就必须自己手写一个无参数构造器出来。

3.要么都不写，要么都写（无参数在开发中别人可能会使用）

2. this关键字

this 关键字是什么？

this就是一个变量，可以用在方法中，来拿到当前对象

哪个对象调用这个方法，this就拿到哪个对象(取地址)

this有哪些应用场景？

this主要用来解决：变量名称冲突问题

//例如：
public class Student{
    String name; //成员变量(整个对象都可以用)    
    public void printHobby(String name){ //局部变量(方法内部)
        System.out.println(this.name+"喜欢"+name);
    }
}

3.封装

什么是封装？

就是用类设计对象处理某一个事务的数据时，应该把要处理的数据，以及处理这些数据的方法，设计到一个对象中去

面向对象的三大特征：封装，继承，多态

封装的设计要求：

合理隐藏，合理暴露。

1.如何隐藏对象的成员？

使用private关键字(私有，隐藏)修饰成员变量，就只能在本类中被直接访问，其他任何地方不能直接访问

2.如何暴露对象的成员（合理暴露）？

使用public(公开)的get和set方法合理暴露，成员变量的取值和赋值

//例如：
//1.为年龄赋值
public void setAge(int age){ 
    if(age>0&&age<200){
        this.age=age;
    }else{
        System.out.println("您赋值的年龄数据非法！");   //例如web端对于输入的年龄的校验
    }
}

//调用：
s1.setAge(18); //赋值18；

//2.为年龄取值：
public int getAge(){
    return age;
}

//调用：
System.out.println(s1.getAge()); //取值

总结（代码层面如何控对象的成员的公开与与隐藏？）:

公开成员，可以使用public(公开)进行修饰。
隐藏成员，使用private(私有，隐藏)进行修饰

4.实体类(特殊类) Javabean

1.是一种特殊类，类中要满足如下需求：

1.类中的成员变量全部私有，并提供public修饰的getter/setter方法；

2.类中要提供一个无参数的构造器，有参数构造器可选。

public class Test {
    public static void main(String[] args) {
        //实体类的作用：创建它的对象，存取（封装）数据
        //调用无参构造器的对象
        Student s=new Student();
        s.setName("张三");
        //调用有参构造器的对象
        Student s1=new Student("王五");
    }
}

//实体类
public class Student {
    //1.私有成员变量
    private String name;
    //2.提供公平的getter和setter方法，暴露其取值和赋值

    //必须提供一个无参构造器
    public Student() {
    }

    //提供一个有参构造器（可选）
    public Student(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }

2.实体类有啥应用场景？

实体类的对象只负责数据读取，而对数据的业务处理交给其他类的对象来完成，以实现数据和数据业务处理相分离。(分层思想)

public class Student{
    private String name;
    private double score;
    //getter/setter 方法
}

public class StudentOperator {
    private Student s; //用来记住将来要操作的学生对象 （null）
    public StudentOperator(Student s){
        this.Student=s;
    }
    //打印总成绩
    public void printscore{
    }
    //打印平均成绩
    //……
}

public class Test {
    public static void main(String[] args) {
        Student s1=new Student("王五", 80);
        //创建一个学生的操作对象专门负责对学生对象的数据进行业务分析
        StudentOperate op=new StudentOperate(s1);
        op.printscore();
    }
}

小结：

1.什么是实体类？有什么特点？

成员变量必须私有，且要为它们提供get、set方法；必须有无参数构造器
仅仅是一个用来保存数据的Java类，可以用它来创建对象，保存某个事物的数据

2.实体类的应用场景(如上)

4. static

1. static 修饰成员变量

成员变量按照有无static修饰，分为两种：

静态变量（类变量）：有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享。

访问方式：类名.静态对象

也可以以“对象名.静态变量”的方式（语法上不推荐）

实例变量（对象的变量）：无static修饰，属于每个对象的。

访问方式：对象.实例变量

注意：不允许使用this关键字

public class student{
    //静态变量：属于类，只加载一份，可以被类和类的全部对象共享访问
    static String name;  //先进入堆内存null
    //实例变量（对象的变量）：属于对象，每个对象一份
    int age;
}

静态变量应用场景：

如果某个数据只需要一份，且希望能够被共享（修改/访问），则该数据可以定义为静态变量来记住

例如：记录用户类创建了多少用户对象：

public class User{
    //静态变量
    private static int number;
    //构造器
    public User(){
        User.number++;
    }
}

访问自己类中的类变量，可以省略类名不写

注意：在某类中访问其他类里的类变量必须带类名访问

public class Student{
    static String school="HUT";//类变量（静态变量）
    public void showSchool(){
        //本类内访问类变量，可省略类名Student
        System.out.println(school);
                         //等价于Student.school
    }
}

2. static修饰方法

使用规范：

1.如果这个方法只是为了做一个功能且不需要直接访问对象的数据，那么这个方法应该定义为静态方法

2.如果这个方法是对象的行为，需要访问对象数据，那么这个方法应该定义为实例方法

public class Test {
    public static void main(String[] args) {
        //认识 static修饰与不修饰方法的区别
        //1.类名.静态方法（推荐）
        Student.printHelloWorld();
        //2.对象.静态方法（不推荐）
        Student s1 = new Student();
        s1.printHelloWorld();
        //3.对象名.实例方法
        //Student.printPass(); //报错
        s1.setScore(59.9);
        s1.printPass();
    }
}

public class Student {
    private double score;
    //静态方法:有static修饰，属于类持有
    public static void printHelloWorld(){
        System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("Hello World");
    }
    //实例方法:无static修饰，属于对象持有
    public void printPass() {
        System.out.println(score>=60?"通过":"挂科了");
    }
    public void setScore(double score) {
        this.score = score;
    }
}