面向对象编程

什么是面向对象编程

• 面向对象编程包含了面向过程编程和面向对象编程。

什么是面向过程编程

以下解释只是基于我当前学习进度时的理解

• 面向过程实际是一个从上到下依次按顺序执行的过程
• 举例说明：一个事件的发生使用面向过程编程的方法对其进行分析解释
  举例：一个人要去上厕所。
  分析：
  1. 第一步去厕所
  2. 第二步打开厕所门
  3. 第三步脱裤子
  4. 第四部蹲下
  5. 最后上厕所
• 总的来说，面向过程编程就是对一个事件发生的每一个步骤进行编程，没有对象的创建，只会按照事件的正常发展步骤编程

什么是面向对象编程

• 面向对象编程就是一种物以类聚的表现，将事件发生过程中，拥有相同属性的方法或者步骤分配到一个创建的类中，当执行或者运行到该方法或-步骤是直接调用创建的类执行。

• 其中面向对象编程主要有类和对象两者组成，

  1. 类：类是拥有相同属性方法对象的抽象，简单来说就是类是对象中某些相同的方法或者步骤然后被提取出来单独被写作一个方法，最后在对象需要使用到时直接调用的方法。
  2. 对象：对象就是类的实例，就是要用到该类的使用者。

• 举例说明：一个事件的发生使用面向对象编程的方法对其进行分析解释
  举例：一个人要去上厕所。
  分析：
  1. 将相同方法或者步骤划分为一个类，在这里以下的上厕所的面向过程编程的过程都是相同的，将其划分为一个类，类名设为上厕所。
  2. 第二步打开厕所门
  3. 第三步脱裤子
  4. 第四部蹲下
  5. 最后上厕所
  6. 使用类的使用者是对象，在这里是人要上厕所，所以人是对象
  7. 整个事件用面向对象的方法分析就是：
  * 人=>上厕所

面向对象编程的实质其实是：以类的方式组织代码，以对象的组织（封装）数据

面向对象编程的三大特性：封装，继承，多态

• 封装：就是将对象的数据保存在一个特定的地方，只留一个进出口方便存储和读取数据：就是后面所要学习到的实体类对象
• 继承：将一个类设计为父类，在根据父类创建一个对应的子类，该子类拥有父类所拥有的一切，包括但不限于方法，数据等
• 多态：一个方法被不同的对象调用，同时结果不同。比如现在有小红，小张这两个对象，他们都是人是同一个事物，现在，两人同时去调用学习这个方法，但是结果是小红成绩比小张好。就是说明，多态其实就是同一中事物会拥有多种形态。

方法调用的回顾

• 静态方法的调用
  

• 非静态方法的调用:

• 

注意事项：

• 在同一个类中如果方法都使用了static的那么两个方法可以相互调用

public class demo02 {
    public static void main(String[] args) {
        /**
         * 静态调用
         *  是指调用带有static方法，可以直接通调用类名.方法名
         */
        student01.Say();

        System.out.println("===================");
        /**
         * 非静态调用
         *  指为带有static的方法，需要创建一个新的对象调用
         *      方法名  自定义的名字=new 方法
         *      student02 st=new student02()
         *      st.方法名调用
         */
        student02 st= new student02();
        st.say02();
    }
}

package com.oop;

public class demo02 {
    public static void main(String[] args) {

    }
    public static void a(){
        b();//在a方法中调用b方法
    }
    public static void b(){
        a();//在b方法中调用a方法
    }
}

• 在同一个类中如果方法都没有使用了static的那么两个方法可以相互调用

package com.oop;

public class demo02 {
    public static void main(String[] args) {

    }
    public  void a(){
        b();//在a方法中调用b方法
    }
    public  void b(){
        a();//在b方法中调用a方法
    }
}

• 在同一个类中如果一个方法使用的是static修饰，一个没有使用static修饰，那个相关方法不能相互调用
• 强调：因为在这里static对应的方法是在0这个class类创建是就对应创建的，而另外一个a类是在用到他是才创建，一个已经存在的类不能调用一个尚未存在的类。

package com.oop;

public class demo02 {
    public static void main(String[] args) {

    }
    public  void a(){
        b();
    }
    public static void b(){
        a();//这里b方法引用a方法是错的
    }
}

实参和形参

• 形参：就是在创建方法时给与的对应的临时参数，他只是一个抽象的参数，没有具体的值。
• 实参：就在在方法调用时，对所调用方所传递的值
• 需要注意的是形参和实参的类型要一样

package com.oop;

/**
 * 对实参和形参举例子说明
 */
package com.oop;

/**
 * 对实参和形参举例子说明
 */
public class demo03 {
    public static void main(String[] args) {
        demo03 demo03 = new demo03();
        //1，2是调用方法时传递的值，是一个准确的数，是一个实参
        int sum= demo03.sum01(1,2);
        System.out.println("sum="+sum);


    }
    public int  sum01(int a,int b){
        //a,b是一个形参，没有具体的值
        return a+b;
    }
}

类的创建使用，即对象的实例化

• 类：是一个抽象的，是一个统一化的事件，然后对事件的相同属性进行定义。
• 实例化对象：就是将所定义的类，其中所定义的所有的与别的事物相同的属性，改为一个特殊的值，成为一个唯一的。
• 举例说明：在这里我们将假设这个拥有相同属性的一系列的事件设置为学生，每个学生都拥有名字，年龄。以及学习这个方法。

package com.oop.Demo02;

/**
 * 创建一个student的类，用于保存学生这个事物所拥有的相同属性和方法
 *每一个类中只会存在属性，方法两种东西。
 */

public class Demo01 {
    //属性
    String name;
    int age;

    //方法
    public void Study(){
        System.out.println(this.name+"学习中");
        //this表示当前这个类，在这里表示的是Demo01这个类
      
    }
}

• 对Demo01这个类进行示例化，在这里我们将这个类示例化成xiaohong和dahong这两个对象

package com.oop.Demo02;
//作为Demo02这个包的主启动类，按照正常情况而言，一个程序只会有一个main方法
public class Application {
    public static void main(String[] args) {
        //示例化对象
        Demo01 xiaohong  = new Demo01();
        Demo01 dahong = new Demo01();
        //对实例化对象进行赋值和输出
        xiaohong.name="小红";
        xiaohong.age=23;
        //将对象实例化后，调用对象的方法
        xiaohong.Study();
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
        
        
        System.out.println("================");
        
        
        dahong.name="大红";
        dahong.age=34;
        dahong.Study();
        System.out.println(dahong.age);
        System.out.println(dahong.name);

    }
}

什么是类的构造器

• 什么是构造器：构造器也称为构造方法，是在创建对象是调用的，构造器是有类和方法名和类名相同的方法组成，且该方法没有返回值，也不能有viod。
• 构造器的创建：
  1. 无参构造器：

package com.oop.Demo02;

public class Person {
    //无参构造器
    //    public Person(){}==》是一个无参构造器，在没有定义有参构造器之前，无参构造器默认存在，且不写可以直接调用
    public Person(){

    }
}

public Person(){}——>是一个无参构造器，在没有定义有参构造器之前，无参构造器默认存在，且不写可以直接调用
无参构造器的调用：

package com.oop.Demo02;
//作为Demo02这个包的主启动类，按照正常情况而言，一个程序只会有一个main方法
public class Application {
    public static void main(String[] args) {
    //new关键字的本质就是在调用构造器
        Person person = new Person();
    }
}

	3. 有参构造器：

      /**
      *有参构造器
     * 有参构造器的组成
     * public 构造器名(类型 形参)
     * @param a
     */
    public Person(String a){

    }

有参构造器的调用：

package com.oop.Demo02;
//作为Demo02这个包的主启动类，按照正常情况而言，一个程序只会有一个main方法
public class Application {
    public static void main(String[] args) {
        //new关键字的本质就是在调用构造器
        //当给予new关键字所调用的构造器一个实参时，会根据方法的重载自动的选择有参或者无参进行运行
        //需要注意的是，在编写有参构造器之后，想要调用无参构造器必须编写无参构造器，即使无参构造器默认存在。
        Person person = new Person("afh");
    }
}

注意部分：
1. 构造器名必须和类名相同
2. 构造器没有返回值，也不能写void。
3. 在编写了有参构造器之后，想要调用无参构造器，无参构造器必须显性存在。
4. new关键字的本质其实是在调用构造器
5. 构造器用于初始化对象的值。

类和对象的小结

• 类和对象：

  1. 类是一个模板化的，是抽象的e
  2. 对象是类的实例化，是唯一的

• 类中方法的调用：

  1. 对类使用new关键字进行实例化。
  2. 实例化后可直接通过 类名, 的方式调用

• 对象的引用：

  1. 八大基本引用类型：
     基本数据类型：整型、浮点型、字符型、布尔型
     整数类型 —— byte、short、int、long,
     浮点类型 —— float、double
     字符类型 —— char
     布尔类型 —— boolean

  2. 类的属性：每个不同类型的值都有默认的初始值
     数字类型：0,0.0
     chart类型：u0000
     Boolean类型：false
     引用（String）：null
     修饰符 属性类型 属性名 属性值
     student02 st= new student02();

• 对象的创建和引用：

  1. 对象的创建和引用必须使用到new关键字，和构造器
  2. 对象得到属性可以通过创建的实例化对象进行调用，假设实例化对象的名字为student，调用方法为：student.name
  3. 对象得到方法可以通过创建的实例化对象进行调用，假设实例化对象的名字为student，调用方法为：student.sleep（）

• 类中只存在属性和方法

• 类的三大特性：封装、继承、多态