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关键字来创建一个类的实例时，实际上是在调用该类的一个构造器。