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 {// 必须拿到要处理的学生对象// 用于记住将来要操作的学生对象。 nullprivate 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关键字来创建一个类的实例时，实际上是在调用该类的一个构造器。