java知识四(面向对象编程)

KANGBboy2026-06-07 18:30

对象是一种特殊的数据结构，可以用来记住一个事物的数据，从而代表该事务

第一章 面向对象编程快速入门

① 先设计对象的模板，也就是对象的设计图：类。

② 通过new关键字，每new一次类就得到一个新的对象

java 复制代码 
package com.kgl.object;
public class Star {
    String name;
    int age;
    double height;
    double weight;
}
java 复制代码 
package com.kgl.object;

public class Test {
    public static void main(String[] args) {
        Star star = new Star();
        star.name = "张三";
        star.age = 18;
        star.weight = 50.0;
        star.height = 178.0;

        Star star1 = new Star();
        star1.name = "李四";
        star1.age = 18;
        star1.weight = 50.0;
        star1.height = 168.0;
    }
}

1.1 对象

对象本质上是一种特殊的数据结构(可以理解为一张表)，对象是用类new出来的，有了类就可以创建出对象。

java 复制代码 
public class 类名 {
    // 1、变量，用来说明对象可以处理什么数据
    // 2、方法，描述对象有什么功能，也就是可以对数据进行什么样的处理
    ...
}

语法格式： 类名 对象名 = new 类名();

万物皆对象，谁的数据谁存储。

第二章 构造器

java 复制代码 
public class Student {
    /** 构造器 */
    public Student() {
        ...
    }
}

2.1 构造器

构造器是一种特殊方法，不能写返回值类型，名称必须是类名。

创建对象时，对象会立即自动调用构造器执行

java 复制代码 
Student s = new Student();

2.2 构造器的常见应用场景

构造器常用于完成对象初始化，创建对象时，同时完成对对象成员变量(属性)的初始化赋值。

2.3 构造器的注意事项

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

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

第三章 this 关键字

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

主要用来解决：对象的成员变量与方法内部变量的名称一样时，导致访问冲突问题

java 复制代码 
public class Student {
    String name;
    double score;
    public void print(){
        System.out.println(name);
        System.out.println(this);
    }
    public void printHobby(String name){
        System.out.println(this.name +"喜欢" + name);
    }
    public void checkPass(double score) {
        if (this.score >= score) {
            System.out.println("恭喜您，考上哈佛，走向巅峰~~~");
        } else {
            System.out.println("不好意思，您没有考上~~~");
        }
    }
}
java 复制代码 
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "张三";
        s1.print();
        System.out.println(s1);

        System.out.println("-----------------------------------");
        Student s2 = new Student();
        s2.print();
        System.out.println(s2);
        System.out.println("-----------------------------------");
        Student s3 = new Student();
        s3.name = "李四";
        s3.printHobby("读书");
        System.out.println("-----------------------------------");
        s3.score=80;
        s3.checkPass(90);
    }
}

输出

java 复制代码 
张三
com.kgl.thisdemo.Student@3b07d329
com.kgl.thisdemo.Student@3b07d329
-----------------------------------
null
com.kgl.thisdemo.Student@41629346
com.kgl.thisdemo.Student@41629346
-----------------------------------
李四喜欢读书
-----------------------------------
不好意思，您没有考上~~~

第四章 封装

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

定义:就是用类设计对象处理某一个事物的数据时,应该把要处理的数据,以及处理这些数据的方法,设计到一个对象中去。

4.1 封装的设计规范

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

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

4.2 代码层面控对象的成员公开或隐藏

公开成员:可以使用public(公开)进行修饰。

隐藏成员:使用private(私有,隐藏)进行修饰。

java 复制代码 
public class Student {
    String name;
    private int age;
    private double chinese;
    private double math;
    public void setAge(int age) {
        if (age<0||age>100){
            System.out.println("输入的年龄有误");
            return;
        }
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}
java 复制代码 
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setAge(-15);
        System.out.println(s1.getAge());
    }
}

第五章 实体类 Javabean

5.1 定义

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

要求 1:类中的成员变量全部私有,并提供public修饰的getter/setter方法。在IDEA中可以通过右键菜单->Generate->Getter and Setter快速生成。

要求 2:提供get、set 方法,类中需要提供一个无参数构造器,有参数构造器可选。 在IDEA中可以通过右键菜单->Generate->constructor->select None/ok快速生成。

5.2 实体类应用场景

核实体类的对象只负责数据存取,而对数据的业务处理交给其他类的对象来完成,以实现数据和数据业务处理相分离。

用来保存数据的java类,可以用它创建对象,保存某个事物的数据。

java 复制代码 
// 实体类:Student (只负责存数据)
public class Student {
    private String name;
    private double score;
    // getter setter 方法...
    // 生成Getter/Setter:在IDEA中可以通过右键菜单->Generate->Getter and Setter快速生成。
}
java 复制代码 
// 业务类:StudentOperator (负责处理逻辑)
public class StudentOperator {
    private Student s;
    public StudentOperator(Student s){
        this.Student = s;
    }
    // 打印总成绩
    // 打印平均成绩
    // ...
}

5.3 实操

5.3.1 定义实体类

java 复制代码 
package com.kgl.Javabean;

public class Student {
    private String name;
    private double chinese;
    private double math;
    public void setName(String name) {
        this.name = name;
    }
    public void setChinese(double chinese) {
        this.chinese = chinese;
    }
    public void setMath(double math) {
        this.math = math;
    }
    public String getName() {
        return name;
    }
    public double getChinese() {
        return chinese;
    }
    public double getMath() {
        return math;
    }
    public Student() {
    }
    public Student(String name, double chinese, double math) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
    }
}

5.3.2 业务类

java 复制代码 
package com.kgl.Javabean;

public class StudebtOperator {
    private Student s;
    public StudebtOperator(Student s) {
        this.s = s;
    }
    public void printtotalScore( ){
        System.out.println(s.getName()+"的语文成绩是"+s.getChinese()+",数学成绩是"+s.getMath());
    }
    public void printavgScore(){
        System.out.println(s.getName()+"的总成绩是"+(s.getChinese()+s.getMath())+",平均成绩是"+(s.getChinese()+s.getMath())/2);
    }
}

5.3.3 调用

java 复制代码 
package com.kgl.Javabean;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("播妞");
        s1.setChinese(80.0);
        s1.setMath(90.0);
        System.out.println(s1.getName()+"的语文成绩是"+s1.getChinese()+",数学成绩是"+s1.getMath());
        System.out.println("-------------------------------------------");
        Student s2 = new Student("播仔",90.0,80.0);
        StudebtOperator operator = new StudebtOperator(s2);
        operator.printtotalScore();
        operator.printavgScore();
    }
}

第六章 static关键字

6.1 定义

叫静态，可以修饰成员变量、成员方法。

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

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

6.1.2 实例变量(对象的变量):无static修饰，属于每个对象的。

java 复制代码 
public class Student {
    // 静态变量
    static String name;
    // 实例变量(对象的变量)
    int age;
}

Student学生表中包含static name和age字段。

s1对象和s2对象各自拥有独立的age值(均为0)，但共享同一个name字段。

推荐访问方式:类名.静态变量；不推荐:对象.静态变量。

实例变量只能通过 对象.实例变量 访问。

6.2 static修饰成员变量 --- 成员变量的执行原理

java 复制代码 
public class Student {
    // 类变量 静态变量:有static修饰，属于类，只加载一份，可以被类和类的全部对象共享
    static String name;
    // 实例变量(对象变量) 没有static修饰，属于对象，每个对象都有一份
    int age;
}
java 复制代码 
public class Test {
    public static void main(String[] args) {
        // 1、类变量的用法
        // 类名.静态变量(推荐)
        Student.name = "袁华";
        // 对象.静态变量(不推荐)
        Student s1 = new Student();
        s1.name = "马冬梅";
        Student s2 = new Student();
        s2.name = "秋雅";
        System.out.println(s1.name);      // 秋雅
        System.out.println(Student.name); // 秋雅
        // 2、实例变量的用法
        // 对象.实例变量
        s1.age = 23;
        s2.age = 18;
        System.out.println(s1.age);       // 23
        // System.out.println(Student.age); // 报错
    }
}

第七章 静态方法

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

同一个类中访问静态成员可以省略类名不写,在某个类中访问其他类里的类变量，必须带类名访问

7.1 static修饰方法

成员方法的分类

7.1.1 静态方法：有 static 修饰的成员方法，属于类。可以直接用类名访问，也可以用对象访问

java 复制代码 
public static void printHelloWorld(){
    System.out.println("Hello World!");
    System.out.println("Hello World!");
}

7.1.1.1 调用方式：

类名.静态方法 (推荐)

对象名.静态方法 (不推荐)

7.1.1.2 案例

系统启动后，要求用户类可以记住自己创建了多少个用户对象了。

java 复制代码 
public class User {
    // 静态变量
    public static int number;

    // 构造器
    public User(){
        User.number++;
        //注意：同一个类中访问静态成员可以省略类名不写
        number++;
        System.out.println("创建了一个对象，当前对象数量为："+number);
    }
}
java 复制代码 
public class Test2 {
    public static void main(String[] args) {
        // 目标：了解静态变量的应用。
        new User();
        new User();
        new User();
        System.out.println(User.number);
    }
}

7.1.2 实例方法：无 static 修饰的成员方法，属于对象。只能用对象访问

java 复制代码 
public void printPass(){
    ...
}

调用方式：对象.实例方法

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

如果这个方法是对象的行为，需要访问对象的数据，这个方法必须定义成实例方法

java 复制代码 
public class Student {
    private double score;

    public void printpass(){
        System.out.println(score>60?"通过":"未通过");
    }
    public static void print(){
        System.out.println("hello world");
    }
    public void setScore(double score) {
        this.score = score;
    }
}
java 复制代码 
public class Test {
    public static void main(String[] args) {
        Student.print();//hello world
        //        Student.printpass();
        Student s1 = new Student();
        s1.print();//hello world
        s1.setScore(80.0);
        s1.printpass();//通过
        printhello();//hello world1
        Test.printhello();//hello world1
    }
    public static void printhello(){
        System.out.println("hello world1");
    }
}

7.2 main方法

java 复制代码 
public class Test {
    public static void main(String[] args) {
        ...
    }
}

属于类方法，实际执行是 java Test ----> Test.main(...)，调用了方法。见上代码Test.printhello();//hello world1

相关推荐
雪的季节2 小时前
矢量数据提取分析（甲方平台）
开发语言
tongluowan0072 小时前
ThreadLocal，InheritableThreadLocal，TransmittableThreadLocal详解
java·多线程·上下文
ZC跨境爬虫2 小时前
跟着 MDN 学 JavaScript day_1：什么是 JavaScript？
开发语言·前端·javascript·ecmascript
qq_2518364572 小时前
基于java Web 日化商超库存管理系统设计与实现
java·开发语言·前端
破土士V3 小时前
【Java基础语法10】继承、多态、抽象类接口、字符串与异常等
java·开发语言
轻刀快马3 小时前
撕开 Spring 的底裤：解析 Bean 生命周期与三级缓存的“破局”之术
java·spring·缓存
代码中介商3 小时前
C++完美转发与引用折叠全解析
开发语言·c++
KobeSacre3 小时前
JVM ZGC
java·开发语言·jvm
caimouse3 小时前
ReactOS 部分编译指南
开发语言
热门推荐
01GitHub 镜像站点02【AI】2026 年具身智能模型和世界模型总结03Codex 下载安装指南：Windows 和 macOS 官方版下载042026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf05Codex 桌面端更新后 Chrome 插件和 Computer Use 不可用，怎么排查和修复06CC-Switch 下载、安装与使用配置指南【2026.5.29】07【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法08CC-Switch & Claude 基于 Linux 服务器安装使用指南09Codex 接入 DeepSeek API 完整配置文档10裂开！ChatGPT 居然开始要手机号验证，附详细解决方法