JavaSE-05面向对象编程OOP：类的基础语法，封装思想：面向对象的

JavaSE-05面向对象编程OOP：类的基础语法

• [ 任务列表 ]
• 1.面向对象快速入门
• 2.面向对象的底层逻辑
• 3.Java类的一些基本语法元素
• 4.类的基础语法——构造器
• 5.类的基础语法——this关键字
• 6.类的基础语法——封装
• 7.类的基础语法——javabean实体类
• 8.类的基础语法——static静态
• 9.私有构造器——设计模式：单例模式、工厂模式
• 10.Typora使用过程中有序/无序列表的对齐技巧
• 11.参考资料

---

1.面向对象快速入门

• 面向对象编程（Object-Oriented Programming OOP）
  对象是一种特殊的数据结构，类似于数组，但是可以存储多种数据类型（比较像C语言中的结构体类型）

• 面向对象编程快速入门：
  ① 先设计对象的模板——类，类就是对象的设计图，里面包含哪些字段，有哪些变量
  ② 通过new关键字，每new一次，类就得到一个新的对象。

• 封装思想：
  面向对象的三大特质：封装、继承、多态。

  封装，就是把数据和对数据的处理放到同一个类中去。

• 面向对象编程的核心是设计对象，设计对象的关键是设计对象的模板，也就是类。

  所以设计对象就是设计类。

• Java类的一些基本语法元素：类声明，成员变量，方法，构造方法，继承，接口实现，访问控制

• 类的基本语法有：
  构造器、this关键字、封装、javabean、static

2.面向对象的底层逻辑

• 面向对象到底是啥？

• 对象在计算机底层是什么？
  Java程序在JVM虚拟机中运行，而JVM虚拟机是在内存中执行的，所以Java程序是在内存中运行的；
  而虚拟机为了更好地运行程序，把内存划分为：栈内存，堆内存，方法区 ；来配合执行Java程序。

• 程序在内存中的执行逻辑：（参考上图）

  1. 方法区，放.class字节码文件，即程序运行时存放类文件信息的，比如系统会一开始执行Test类，这个类会先加载到方法区中，接下来会去碰main方法；
  2. main方法的执行会放在栈中，栈是一种先进后出，后进先出的结构，所以main方法是进入栈中（就是栈内存）；
  3. 然后继续执行代码，碰student类，继续加载到方法区中，Student类会开辟一个变量空间在栈中叫s1，（局部变量还是在main方法中的）new出来的Student对象会放在堆中；
  4. 堆的区域是非常大的，可以放很多对象，堆内存中会开辟一块区域代表new出来的一个对象；
  5. 对象中还会有所谓的类地址--这个类地址会指出是由哪个类模板创建出来的，（对象是由学生类模板创建的），所以类地址会指向方法区的student类的地址；
  6. 然后，这个对象的地址会赋值给栈中的变量s1，即s1变量会指向堆内存中的一个学生对象。

• static修饰的变量在程序运行时的原理：
  Java程序运行时，student类加载到方法区中，会扫描有没有static修饰的静态变量，这个变量将会被放到堆内存中开辟一块空间。
• main方法设计成静态方法，为了快速的调用程序，进入到程序的入口。

3.Java类的一些基本语法元素

• Java类的一些基本语法元素：类声明，成员变量，方法，构造方法，继承，接口实现，访问控制等。

• 类声明：一个类通过class关键字来声明，后面跟着类名和类体（用大括号包围）
  • public：访问修饰符，表示该类可以被其他任何代码访问。如果不指定访问修饰符，默认为包私有的（即只有同一个包中的类可以访问）。
  • Person：类的名字，需遵循Java命名约定，首字母大写。

public class MyClass {
    // 类体
}

• 成员变量：成员变量是类的状态信息，也称为属性或字段。

private String name;
private int age;

• 方法：方法是类的行为或功能，用于执行操作。

public void sayHello() {
	System.out.println(name + " says hello.");
}

• 构造方法：构造方法是一种特殊的方法，用于创建对象时初始化对象状态。构造方法的名称必须与类名相同，并且没有返回类型。

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

• 继承：使用extends关键字可以让一个类继承另一个类的属性和方法。

public class SubClass extends SuperClass {
    // 子类内容
}

• 接口实现：使用implements关键字可以让一个类实现一个或多个接口。

public class MyClass implements InterfaceA, InterfaceB {
    // 实现接口的方法
}

• 访问控制：

  • public：公开访问。
  • protected：同一包内或者不同包中的子类可访问。
  • 默认（无修饰符）：仅限于同一个包内的类访问。也叫缺省。
  • private：仅限于本类内部访问。

  其中，public > protected > 默认（无修饰符）> private

// Java类的一些基本语法元素:
public class Person {
    private String name;
    private int age;

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

    public void sayHello() {
        System.out.println(name + " says hello.");
    }

    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;
    }
}

4.类的基础语法——构造器

• 构造器长什么样子？
  构造器是一个特殊的方法，没有返回值类型，方法名必须是类名。

• 构造器可以重载，重载的构造器，参数不同（个数或者类型）

//  public 类名(){}

public class Student {
    // 1.无参数构造器：
    // 构造器：是一种特殊方法，不能写返回值类型，名称必须是类名，就是构造器
    public Student() {
        System.out.println("无参数构造器");
    }

    // 2.有参数构造器：
    public Student(String name) {
        System.out.println("有参数构造器1");
    }
}

• 特点：创建对象时，对象会自动的去调用构造器。

• 应用场景：创建对象时（即new一个对象时）才会调用构造器，结合this关键字，同时完成对对象成员变量（属性）的初始化赋值。

• 注意事项：
  类默认自带一个无参构造器；
  如果为类定义了有参构造器，类默认的无参构造器就没有了，还想用无参构造器就必须自己手写一个无参构造器出来；
  总结来说：要么都写，要么都不写。

5.类的基础语法——this关键字

• this就是一个变量，可以用在方法中，来拿到调用当前方法的对象。
  其实，this拿到的是当前对象的地址，就相当于拿到了当前的对象。
  哪个对象调用这个方法，this就拿到了哪个对象。

• 作用：this拿到对象可以访问这个对象的数据。

public class Student {
    String name;
    int age;
    char sex;

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

//    形参变量不能见名知意，传进来的参数命名不好
//    public Student(String n, int a, char s) {
//        name = n;
//        age = a;
//        sex = s;
//    }

//    做到了见名知意，但是传入参数和类的属性名冲突，这样不能初始化赋值成功
//    public Student(String name, int age, char sex) {
        // 没有把传入的参数信息，赋值给对象的信息
//        name = name;
//        age = age;
//        sex = sex;
//    }


    // 有参构造器
    public Student(String name, int age, char sex) {
// 使用this关键字，可以解决属性和形参名冲突的问题
// Student对象的信息  =  传入的信息；
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

}

• 应用场景：this用来解决变量名称冲突的问题
  结合有参构造器对对象进行初始化赋值
  成员变量，局部变量名称冲突问题，this指代的是成员变量，即本对象的成员变量。

6.类的基础语法——封装

• 封装（Encapsulation）：面向对象的三大特征之一；

• 类就是一种封装：类就是把要处理的对象的数据，以及对这些数据进行处理的方法封装成一个架子。
  例如：日常中，手机、洗衣机、汽车……等都是封装。

• 封装的设计要求：合理隐藏，合理暴漏。

• 哪些需要隐藏，哪些需要暴露，怎么隐藏，怎么暴露？
  如何隐藏：使用private关键字修饰成员变量，就只能在本类中访问，其他任何地方不能直接访问。
  如何暴露（合理暴露）：使用public修饰（公开）的getter和setter方法合理暴露。

7.类的基础语法——javabean实体类

• javabean是一种特殊类，也被称为实体类。
• 类中要满足如下需求：
  要求一、类中的成员变量全部私有，并提供public修饰的getter和setter方法
  要求二、类中需要提供一个无参构造器，有参构造器可选。
• 实体类在开发中的应用场景：
  实际上项目开发中，我们会希望这个对象的本身只负责存和取数据；而对业务的处理，我们会希望定义一个单独的对象来处理业务。
• 解耦：
  实体类的对象只负责数据的存取，而对数据的业务处理交给其他类的对象来完成，以实现数据和数据业务处理相分离————分层的思想（解耦）

// 实体类——javabean
public class Student {
    // 1、私有成员变量
    private String name;
    private double chinese;
    private double math;

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

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

    // 2、提供公开的getter和setter方法
    public String getName() {
        return name;
    }

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

    public double getChinese() {
        return chinese;
    }

    public void setChinese(double chinese) {
        this.chinese = chinese;
    }

    public double getMath() {
        return math;
    }

    public void setMath(double math) {
        this.math = math;
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("波妞");
        s1.setChinese(100);
        s1.setMath(100);
        System.out.println(s1.getName() + '/n' + s1.getChinese() + '/n' + s1.getMath());

        Student s2 = new Student("波仔", 59, 80);
        System.out.println(s2.getName() + '/n' + s2.getChinese() + '/n' + s2.getMath());

        System.out.println("==========================");
        // 实体类在开发中的应用场景：
        // 创建一个学生的操作对象专门负责对学生对象的数据进行业务处理
        StudentOperator operator = new StudentOperator(s1);
        operator.printAverageScore();
        operator.printTotalScore();
    }
}

// 实体类对象的操作类
public class StudentOperator {
    // 必须拿到要处理的学生对象
    // 用于记住将来要操作的学生对象。 默认值为：null
    private Student s;  

    // 无参构造器
    public StudentOperator(){
    }

    // 有参构造器，因为要处理的对象是私有的，所以，必须定义有参构造器
    public StudentOperator(Student s) {
        this.s = s;
    }
    
    // 提供方法：打印学生的总成绩
    public void printTotalScore() {
        System.out.println(s.getName() + "的总成绩是：" + (s.getChinese() + s.getMath()));
    }

    // 提供方法：打印学生的平均成绩
    public void printAverageScore() {
        System.out.println(s.getName() + "的平均成绩是：" + (s.getChinese() + s.getMath()) / 2);
    }
}

8.类的基础语法——static静态

• static：（静态）static可以修饰成员变量和成员方法，
  

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

  • 静态变量（类变量） 例如：static String name；
    有static修饰，属于类，在计算机中只有一份，会被类的全部对象共享（访问、修改）；所以每个单独的对象中不会有。
  • 实例变量（对象的变量）例如：int age；
    实例==对象，无static修饰，属于每个对象的，每个对象都有自己的实例变量。

• 静态变量的访问：
  访问：类名.静态变量（推荐）
  对象.静态变量（不推荐）

• 静态变量的应用场景：
  如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义成静态变量来记住。
  例如：系统启动后，要求用户类可以记住自己创建了多少个用户对象了。

• 注意事项：同一个类中，访问静态成员可以省略类名不写；
  但是在某个类中访问其他类里的类变量（就是静态变量），必须带上类名访问。

• static修饰方法：（成员方法的分类，和修饰变量类似）

• 静态方法，有static修饰的成员方法，属于类
  类名.静态方法（推荐）
  对象名.静态方法（不推荐）
• 实例方法，无static修饰的成员方法，属于对象

• 静态方法的应用：

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

• 静态方法的常见应用场景：做工具类
  工具类是指类中的方法都是一些静态方法，每个方法用来完成一个功能，以便供给开发人员使用；提高了代码的复用，调用方便，提高了开发效率。

• 为什么工具类中的方法要用静态方法，而不用实例方法？
  实例方法需要创建对象，此时对象只是为了调用方法，对象占内存，这样会浪费内存；
  静态方法，直接用类名调用即可，调用方便，也能节省内存；
  工具类没有创建对象的需求，建议将工具类的构造器进行私有。这样别人就不能直接通过new来创建对象了。

• static注意事项：（静态方法，实例方法访问相关的几点注意事项？）
  静态方法中可以直接访问静态成员，不可以直接访问实例成员；
  实例方法中既可以直接访问静态成员，也可以直接访问实例成员；
  实例方法中可以出现this关键字，静态方法中不可以出现this关键字。

9.私有构造器——设计模式：单例模式、工厂模式

• 当构造器被私有，即前面用private修饰时，这个类就不能创建对象了？

  • 在Java中，创建对象的过程与构造器紧密相关。构造器（Constructor）是一种特殊的方法，它用于初始化新创建的对象。当你使用new关键字来创建一个类的实例时，实际上是在调用该类的一个构造器。
  • 当一个类的构造器被声明为private时，意味着这个构造器只能在类的内部被访问和调用。这确实限制了从类的外部直接创建该类的实例的能力。但这并不完全意味着该类不能创建对象，而是需要通过特定的设计模式来实现对象的创建。
  • 当构造器被声明为private时，通过单例模式、静态工厂方法或其他类似的设计模式，仍然可以在特定条件下创建对象。这种做法常用于希望对实例化过程进行严格控制的场景，如管理资源、确保唯一性等。

• 单例模式 (Singleton Pattern)

  单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。通常使用私有构造器来防止外部直接实例化。

  在这个例子中，尽管构造器是私有的，但通过getInstance()方法可以获取到这个类的唯一实例。

public class Singleton {
    private static Singleton instance;  // 创建一个类的静态的实例

    // 私有构造函数，私有无参构造器
    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

• 静态工厂方法

  另一个常见的用途是定义静态工厂方法来控制对象的创建过程。

  虽然看起来似乎与单例模式相似，但是这种方法允许你根据需要创建多个实例，只是这些实例的创建必须通过指定的方法进行。

public class MyClass {
    // 私有构造函数
    private MyClass() {}

    // 创建一个静态方法来控制对象的创建
    public static MyClass createInstance() {
        return new MyClass();
    }
}

• 工厂模式 (Factory Pattern)

  在更复杂的场景下，可能会使用工厂模式来封装对象的创建逻辑。即使类的构造器是私有的，也可以通过工厂类来创建对象。

10.Typora使用过程中有序/无序列表的对齐技巧

• Typora的使用：

  怎么把这个Typora里面无序列表中，回到上一级的无序列表？

  回车后会继续显示当前级别的状态，可以按enter键，然后一直enter下去，可以回到最最开始的无列表转台。

11. 参考资料

• 黑马程序员：黑马程序员Java+AI智能辅助编程全套视频教程，java零基础入门到大牛一套通关_哔哩哔哩_bilibili
• 通义千问：通义 - 你的实用AI助手