Java—面向对象编程、类的基本语法

[访问修饰符] class 类名 {
    // 成员变量（属性）
    [访问修饰符] 数据类型 变量名;
    
    // 构造器
    [访问修饰符] 类名(参数列表) {
        // 构造器体
    }
    
    // 成员方法（行为）
    [访问修饰符] 返回类型 方法名(参数列表) {
        // 方法体
    }
}

2. 访问修饰符

public：公共访问
private：私有访问
protected：受保护访问
默认（不写）：包级访问

上面的修饰符我们后面再说。

3. 关键要素

类名首字母大写，遵循驼峰命名法
成员变量通常设为私有（private）以实现封装
提供公共的 getter/setter 方法访问私有成员
构造器名与类名相同，无返回类型
方法按功能进行合理划分和命名

代码：基于Student类的实例

public class Student {
    //属性，成员变量
    String name;
    int age;
    double height;
    //无参构造器
    //方法
    public void print(){
        System.out.println(name + " " + age + " " + height);
    }
}

对象时什么？可以把对象看做一张二维表。

对象在计算机中是啥？

类对象小结：

之前我们对面向对象编程做了解。我们知道面向对象的核心是要设计对象，设计对象就要设计类，所以接下来我们来学习设计类的一些语法

2、构造器

构造器是一种特殊的方法，没有返回值（不需要写）名称和类名想同。在创建对象自动调用。

1. 构造器的定义

构造器是一种特殊的方法，用于创建对象时初始化对象状态

名称必须与类名完全相同

没有返回类型（连 void 都不写）

2. 构造器的特点

当使用 new 关键字创建对象时自动调用

可以重载（一个类可以有多个构造器）

如果没有显式定义构造器，Java会提供默认无参构造器

3. 构造器的优势

简化对象创建过程

确保对象在创建时就被正确初始化

提高代码的可读性和安全性

注意事项：

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

如果为类定义了有构造器，类默认的无参构造器就没有了，此时如果还想用无参数构造器，就必须自己写无参数构造器出来。如果只写有参构造器，当使用无参构造器时候就会报错。

下面图片就是一个构造器：无参数构造器

下面我们来看代码：

Student类

public class Student {
    String name;
    int age;
    double height;
    //有参数构造器
    public Student(String name , int age , double height){
        this.name = name;  //this语法还没学到这篇文章下面我们会提到
        this.age = age;
        this.height = height;
    }
    //无参构造器
    public Student(){
        System.out.println("无参构造器");
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        // 创建Student对象并初始化基本信息
        Student s = new Student("张三",18,1.8);
        //打印student信息
        System.out.println(s.name + " " + s.age + " " + s.height);

        //无参数构造器创建Student对象
        Student s1 = new Student(); //在创建对象时打印：无参构造器
        //会发现打印出来的是默认值
        System.out.println(s1.name + " " + s1.age + " " + s1.height);
    }
}

3、this关键字

this就是一个变量，可以用在方法中，来拿到当前对象。说白了那个对象调用这个方法，this就拿到那个对象。

我们通过代码来理解上面这句话。

Student类

public class Student {
    public void print() {
        System.out.println(this);
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        // 创建Student对象并初始化基本信息
        Student s = new Student();
        s.print();
        System.out.println(s);

    }
}

通过打印发现上面两个的地址完全想同，s.print()和下面直接打印s对象的地址相同。说明s对象调用print方法，this就拿到那个对象（的地址）。那么这里this就是s对象。所以可以用this直接找到类中的成员变量。

1. this 的含义

this 是一个引用当前对象的关键字

在实例方法或构造器中，this 指向正在调用该方法或构造器的对象实例

2. this 的主要用途

区分成员变量和局部变量（解决变量名称冲突问题的）。

主要用途解决名称冲突问题该怎么使用呢场景是什么？直接看代码注释比较详细

Student类

public class Student {
    String name;
    int age;
    double height;
    //无参构造器
    public Student(){}
    //带参构造器
    //打印
    public void print(){
        System.out.println(name + " " + age + " " + height);
    }
    //在定义方法或者构造器时，有时形参名字取起来比较容易和成员变量重名
    //这里使用this关键字来区分成员变量和形参
    public Student(String name,int age,double height){
        //这里使用this关键字来区分成员变量和形参
        //这里是形参赋值给形参自己
//        name = name;这里是形参赋值给形参自己，成员变量name未被修改，不能完成赋值
        this.name = name;
        this.age = age;
        this.height = height;
    }
}

.Test类

public class Test {
    public static void main(String[] args) {
        // 创建Student对象并初始化基本信息
        Student s = new Student("张三", 18, 1.8);
        s.print();
    }
}

4、封装

面向对象的三大特性：封装、继承、多态。

类就是一种封装

封装的设计要求

合理隐藏，合理暴露

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

private关键字隐藏

private 是 Java 中的访问修饰符
用于限制成员变量、方法或构造器的访问权限
被 private 修饰的元素只能在定义它们的类内部访问

下面来看代码如何隐藏，怎么使用。

Student类

public class Student {
    //属性，成员变量
    //如何隐藏：使用private关键字修饰成员变量，
    // 就只能在本类中被直接访问，其他任何地方不能直接访问
    private String name;
    private int age;
    private double height;
    //2、如何暴露（合理暴露）：使用public修饰的get和set方法合理暴露成员变量
    //取值和赋值
    //设置值
    //为姓名赋值
    public void setName(String name){
        this.name = name;
    }
    //为年龄属性进行合理的限制
    public void setAge(int age){
        if (age >= 0 && age <= 120){
            this.age = age;
        }
    }
    //为身高属性进行合理的限制
    public void setHeight(double height){
        if (height > 0.5 && height < 2.5){
            this.height = height;
        }
    }
    //取值
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public double getHeight(){
        return height;
    }
    //方法
    public void print(){
        System.out.println(name + " " + age + " " + height);
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        // 创建Student对象并初始化基本信息
        Student s = new Student();
        s.setName("张三");
        s.setAge(18);
        s.setHeight(1.8);
        s.print();
    }
}

5、实体类/Javabean类

什么叫实体类？

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

public class Student {
    //属性，成员变量
    //如何隐藏：使用private关键字修饰成员变量，
    // 就只能在本类中被直接访问，其他任何地方不能直接访问
    private String name;
    private int age;
    private double height;
    //2、如何暴露（合理暴露）：使用public修饰的get和set方法合理暴露成员变量
    //取值和赋值
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }
    
    //构造器
    public Student() {}
}

实体类有啥应用场景？

下面我们在写一个StudentOperator类来负责对Student类的操作。

下面我们来看一下总的代码：

Student类，学生类Javabean类包含私有的成员变量和get、set方法。

public class Student {
    //属性，成员变量
    //如何隐藏：使用private关键字修饰成员变量，
    // 就只能在本类中被直接访问，其他任何地方不能直接访问
    private String name;
    private int age;
    private double height;
    //2、如何暴露（合理暴露）：使用public修饰的get和set方法合理暴露成员变量
    //取值和赋值
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    //构造器
    public Student() {}
}

StudentOperator类：用于处理Student类定义的对象的操作一些方法。体现了Java中的分层思想。

public class StudentOperator {
    //我们来写一个类处理Student类创建的对象那我们必须拿到这个对象？
    //我们现在就需要考虑怎么拿到这个对象
    private Student s;//用于记住将来操作的学生对象。此时还为null
    //我们掩考虑怎么把象传递给这个上面的s中？
    //可以使用有参构造器

    //构造器
    public StudentOperator(Student s){
        this.s = s;
    }
    //无参构造器
    public StudentOperator(){}
    public void printNamaAndAge(){
        System.out.println("姓名：" + s.getName() + " 年龄：" + s.getAge());
    }
    public void printNamaAndHeight(){
        System.out.println("姓名：" + s.getName() + " 身高：" + s.getHeight());
    }
}

Test类：用于测试Student类。

public class Test {
    public static void main(String[] args) {
        // 创建Student对象并初始化基本信息
        Student s = new Student();
        s.setName("张三");
        s.setAge(18);
        s.setHeight(1.8);

        StudentOperator so = new StudentOperator(s);
        so.printNamaAndAge();
        so.printNamaAndHeight();
    }
}

6、static关键字

static关键字，翻译过来叫静态，可以修饰成员变量，成员方法。

1.static修饰成员变量

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

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

主要特性
1. 静态变量（类变量）

使用 static 修饰的变量

在内存中只有一份拷贝，被所有实例共享

可以通过类名直接访问：ClassName.variableName

2. 静态方法

使用 static 修饰的方法

可以通过类名直接调用：类名.静态成员变量/静态方法

只能直接访问静态成员，不能访问非静态成员

3. 静态代码块

用于初始化静态变量

在类第一次被加载时执行，且只执行一次

成员变量的执行原理：

接下来看代码：

Student类

public class Student {

    static String name;
    int age;
}

Test类

public class Test {
    public static void main(String[] args) {
        //类名.静态变量(推荐)
        Student.name = "张三";
        System.out.println(Student.name);

        //对象名.静态变量（不推荐）
        Student s1 = new Student();
        s1.name = "李四";

        Student s2 = new Student();
        s2.name = "王五";
        System.out.println(s1.name);  //这里打印的也是王五，计算机里只有一份，会被类的全部对象共享。
        System.out.println(Student.name);

        //实例变量的用法
        //对象名.实例变量
        s1.age = 18;
        s2.age = 19;
        System.out.println(s1.age);
        System.out.println(s2.age);
//        System.out.println(Student.age);//报错，因为实例变量只能通过对象访问
    }
}

静态变量的使用场景（案例）

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

下面还是来看代码理解上面的例子：

User类

public class User {
    public static int count;
    //构造器
    public User(){
        //在类的内部使用成员变量可以直接使用
        //或者说，访问自己类的成员变量，是可以省略类名的。
        count++;
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        new User();
        new User();
        new User();
        new User();
        System.out.println(User.count);//4
    }
}

2.static修饰方法

修饰成员变量按照有无staict分为两类：

静态方法：有static修饰的成员方法，这个方法属于类。

实例方法：无static 修饰的成员方法，属于对象。

特点：

使用 static 关键字修饰
属于类本身，不依赖于类的实例
可以通过类名直接调用：类名.方法名()
在内存中只有一份，在类加载时就存在

限制：

不能直接访问实例变量和实例方法
不能使用 this 和 super 关键字
只能直接访问其他静态成员

下面来看代码：

Student类

public class Student {
    private  int age;
    public static void printHalloWorld(){
        System.out.println("Hallo World");
        System.out.println("Hallo World");
        System.out.println("Hallo World");
    }
    public void printPass(){
        if(age > 0 && age < 50){
            System.out.println("输入合理");
        }else{
            System.out.println("输入错误");
        }
    }

    public void setAge(int age){
        this.age = age;
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        //类名.方法名（推荐）
        Student.printHalloWorld();
        //对象名.方法名（不推荐）
        Student s1 = new Student();
        s1.printHalloWorld();
        //实例方法 对象名.方法名
        s1.setAge(20);
        s1.printPass();

        //规范：如果这个方法为了做一个功能且不需要直接访问对象的数据，这个方法直接定义成静态方法
        //如果这个方法是对象的行为，需要访问对象的数据，这个方法必须定义成实例变量
    }
}

静态方法的使用场景：

Student类

public class verifyCodeUtil {
//构造器定义成私有
    private verifyCodeUtil(){}
    public static void getVerifyCode(){
        String verifyCode = "";
        for (int i = 0; i < 4; i++){
            int number = (int)(Math.random() * 10);
            verifyCode += number;
        }
        System.out.println(verifyCode);
    }
}

工具类

public class Test {
    public static void main(String[] args) {
        verifyCodeUtil.getVerifyCode();
    }
}

为什么工具类中的方法要用静态方法，而不用实例方法？

3.static注意事项

静态方法实例方法访问相关的几个注意事项

Test类

public class Test {
    public static void main(String[] args) {
        //静态变量
    }
    //静态变量
    public static int count = 10;
    //实例变量
    public int a = 10;
    //静态方法
    public static void test() {
        System.out.println(count);
//        System.out.println(a); //报错，静态方法不能访问实例变量
//        System.out.println(this);//报错，静态方法不能访问this
    }
    //实例方法
    public void test1() {
        //实例方法可以访问静态变量和实例变量
        System.out.println(count);
        System.out.println(a);
        System.out.println(this);
    }
}

7、面向对象编程的综合小项目

Movie类

public class Movie {
    private int id;
    private String name;
    private double price;
    private String actor;
    //构造器
    public Movie(){}
    public Movie(int id, String name, double price, String actor) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.actor = actor;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }
}

MovieOperator类

public class MovieOperator {
    private Movie[] movies;
    //构造器
    public MovieOperator(Movie[] movies) {
        this.movies = movies;
    }

    public void printAllMovies() {
        for (int i = 0; i < movies.length; i++) {
            System.out.println("id" + movies[i].getId()+"name->:" + movies[i].getName() +"price->" +movies[i].getPrice() +"actor->" +movies[i].getActor());
        }
    }

    public void searchMovieById() {
        System.out.println("请输入要查询的id");
        Scanner sc = new Scanner(System.in);
        int e = sc.nextInt();
        for (int i = 0; i < movies.length; i++) {
            if (movies[i].getId() == e) {
                System.out.println("id" + movies[i].getId()+"name->:" + movies[i].getName() +"price->" +movies[i].getPrice() +"actor->" +movies[i].getActor());
                return;
            }
        }
        System.out.println("没有找到该电影");
    }
    }

Test类

public class Test {
    public static void main(String[] args) {
        //1、设计电影类Movie，以便创建电影对象，封装电影数据
        //2、封装系统中的全部电影信息，并保存在数组中（自己造）
        Movie []movies = new Movie[6];
        movies[0] = new Movie(1,"唐顿庄园",6.5,"罗宾·怀特");
        movies[1] = new Movie(2,"速度与激情",9.5,"瑞秋");
        movies[2] = new Movie(3,"夏洛特烦恼",9.5,"沈腾");
        movies[3] = new Movie(4,"战狼2",7.5,"吴京");
        movies[4] = new Movie(5,"让子弹飞",8.5,"姜武");
        movies[5] = new Movie(6,"暗战",9.1,"王大陆");
        //3、创建电影操作对象出来，专门负责电影数据的业务操作。
        MovieOperator mo = new MovieOperator(movies);
        System.out.println("------------------全部电影信息如下----------------");
        mo.printAllMovies();
        System.out.println("------------------所查询的电影-------------");
        mo.searchMovieById();
    }
}

上面的代码利用了对象的声明和初始化，其实和基本类型的数组没有什么差别。只是数组中元素比变为数组中的每个元素只是对象引用，而非实际对象实例。

OK文章到这里就结束了，作者能力有限。如果文章出现错误或者歧义欢迎大家在评论区指出。

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

SeedVR2终极指南：如何用单步扩散模型实现专业级视频修复

还在为老旧视频的模糊画质而烦恼吗？面对抖动严重的监控录像或褪色的家庭影像，你是否曾希望有一种简单高效的修复方案？SeedVR2正是为解决这些痛点而生的一站式视频修复工具。作为字节跳动推出的先进视频修复模型，它能够在单步推理中实现专业级的视频质量提升，彻底改变了传统视频修复的工作流程。## 核心价值：为什么选择SeedVR2进行视频修复？**传统视频修复的三大瓶颈**：1. **计算成本高

AI Agent技术社区

深度解析Amlogic S9xxx电视盒子Armbian系统：从闲置设备到Linux服务器的终极实战指南

你是否拥有一台闲置的Amlogic S9xxx系列电视盒子？想让它摆脱单一的视频播放功能，变身为功能强大的Linux服务器、开发平台或家庭媒体中心？本指南将为你详细解析如何通过Armbian系统实现这一转变，让你的电视盒子重获新生，成为高性能的Linux设备。Armbian系统基于Debian/Ubuntu构建，专为ARM芯片优化，提供了完整的Linux生态支持。## 🎯 核心价值与独特优势

AI Agent技术社区

CANN/runtime Event管理API

本章节描述 CANN Runtime 的 Event 管理接口，用于事件的创建、记录、同步、计时及 IPC 跨进程共享。- [`aclError aclrtCreateEvent(aclrtEvent *event)`](#aclrtCreateEvent)：创建Event，创建出来的Event可用于统计两个Event之间的耗时、多Stream之间的任务同步等场景。- [`aclError