day05-面向对象编程：基础语法

Java面向对象：类的基础语法

• [ 任务列表 ]
• 1.面向对象快速入门
• 2.什么是面向对象
• 3.类的基础语法——构造器
• 4.类的基础语法——this关键字
• 5.类的基础语法——封装
• 6.类的基础语法——javabean
• 7.类的基础语法——static
• 8.其他

—————————————————————————————————————————————————————————————————————

1.面向对象快速入门

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

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

• 封装思想：
  
  面向对象的三大特质之一：封装。就是把数据和对数据的处理放到同一个类中去。

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

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

2.什么是面向对象

• 面向对象到底是啥？
  
  

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

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

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

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

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

//  public 类名(){}

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

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

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

• 应用场景：创建对象时，结合this关键字，同时完成对对象成员变量（属性）的初始化赋值。

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

4.类的基础语法——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指代的是成员变量。

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

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

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

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

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

6.类的基础语法——javabean

• javabean是一种特殊类，也被称为实体类

• 类中要满足如下需求：
  
  要求一、类中的成员变量全部私有，并提供public修饰的getter和setter方法
  
  要求二、类中需要提供一个无参构造器，有参构造器可选

• 实体类在开发中的应用场景：
  
  实际上项目开发中，我们会希望这个对象的本身只负责存和取数据；而对业务的处理，我们会希望定义一个单独的对象来处理业务。

• 解耦：
  
  实体类的对象只负责数据的存取，而对数据的业务处理交给其他类的对象来完成，以实现数据和数据业务处理相分离————分层的思想（解耦）

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());
        System.out.println(s1.getChinese());
        System.out.println(s1.getMath());

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

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

    }
}

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

    }
}

7.类的基础语法——static

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

• 成员变量按照有无static修饰，分为两种：
  
  ① 静态变量（类变量） 例如：static String name；
  
  有static修饰，属于类，在计算机中只有一份，会被类的全部对象共享；所以每个单独的对象中不会有。
  
  ② 实例变量（对象的变量）例如：int age；
  
  实例==对象，无static修饰，属于每个对象的，每个对象都有自己的实例变量。

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

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

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

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

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

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

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

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

8.其他

• static修饰的变量在程序运行时的原理：
  
  Java程序运行时，student类加载到方法区中，会扫描有没有static修饰的静态变量，这个变量将会被放到堆内存中开辟一块空间。

• main方法设计成静态方法，为了快速的调用程序，进入到程序的入口。

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

• 当构造器被私有，即前面用private修饰时，这个类就不能创建对象了？
  
  在Java中，创建对象的过程与构造器紧密相关。构造器（Constructor）是一种特殊的方法，它用于初始化新创建的对象。当你使用new关键字来创建一个类的实例时，实际上是在调用该类的一个构造器。