java基础——面向对象基础（类，对象，构造方法）

一、引言

前面我们讲过数组，当有多个数组都需要遍历时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应的方法即可，提高代码的复用性。在对数组遍历的基础上继续增加需求，比如回去最值、数值逆序等，同样需要将这些功能封装到相应的方法中。这样继续封装就会发现方法越来越多，于是我们就想到能不能将这些方法继续封装呢？通过前面的讲解，我们知道类是可以存放方法的，所以，我们就考虑使用类来封装这多个方法，将来再做数组的操作时，不用去找具体的方法，先找到这个类，然后使用这个类中的方法。这就是面向对象思想的编程方式。

二、编程思想

这里提到了编程思想，我们来详细说明一下。

我们大家比较熟悉的编程思想应该就是面向对象和面向过程，除此之外还有响应式编程、并发编程、面向切面编程、声明式编程和函数式编程，目前主流的编程思想就是面向对象。

面向过程思想与面向对象思想：

（1）面向过程思想

• 我们来回想一下，之前我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后去分析怎么做，最后我们再敲代码实现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
• 在上面的每一个具体步骤我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程的最直接提现。
• 那么什么是面向过程开发呢？面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
• 面向过程思想的代表语言：C语言。

（2）面向对象思想

• 当需求简单，或者单一时，我们一步一步去操作没问题，并且效率也很高。可随着需求的 更改，功能的增多，我们发现需要面对每一个步骤很麻烦了，这时我们就开始思索，能不能把 这些步骤和功能再进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一 起。这样我们的代码结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
• 面向对象是基于面向过程的编程思想。
• 特点：
  • 是一种更符合我们思想习惯的思想
  • 可以将复杂的事情简单化
  • 将我们从执行者变成了指挥者（角色发生了变换）

面向过程：强调的是每一个功能的步骤
面向对象：强调的是对象，然后由对象去调用功能

三、对象

（1）什么是对象?

1. 从java的角度: “万物皆对象”.对象是一个操作单位, 所有内容都可以被认定为是一个对象(一个操作单位)
2. 从程序的角度: 对象是内存中的一块存储空间, 存放着现实生活中对象特征和行为的具体信息

（2）对象的组成

1. 特征: 都有什么
2. 行为: 会做什么

（3）对象间的关系

1. is a: 一个对象继承自另一个对象

   • 狗是一个动物 Dog is a Animal
   • 猫是一个动物 Cat is a Animal

2. has a: 一个对象是另一个对象的组成部分

   • 键盘是一个对象
   • 屏幕是一个对象
   • 电脑是一个对象
   • 电脑包含键盘和屏幕

3. use a: 一个对象使用另一个对象

   • 电脑是一个对象
   • 程序员是一个对象
   • 程序员使用电脑

四、重新认识类

存放对同一批对象相同的特征和行为的描述,约束同一批对象所具有的内容

测试类: 特点为拥有主函数,可以直接执行

描述型的类:特点为没有主函数,无法执行, 作用为描述对象特征和行为

（1）类和对象间的关系

1. 类是对象的模板
2. 对象是类的实例
3. 一个模板可以创建多个相同相似的实例

（2）类的组成

1. 属性: 描述对象特征. 也称为全局变量|成员属性|成员变量等

   1. 数据类型 属性名=值;
   2. 数据类型 属性名;  更常用
   

   测试类: com.xxx.test

   描述类: com.xxx.entity

   • 位置: 类以内,其他内容以外, 通常写在类的最上方
   • 特点: 有默认值,作用为空间占位,保证会分配空间
   • 属性和局部变量的区别:

   	局部变量	属性
   位置	方法内部	方法外部
   默认值	没有	有
   作用范围	定义行开始至直属代码块结束	至少整个类
   命名冲突	同一作用范围内不可重名	可以与局部变量重名,局部变量优先级更高

2. 方法 : 描述对象行为. 也称为成员方法|普通方法等

   函数就是加了static的方法

      访问修饰符 返回值类型 方法名(形参列表){
          //操作语句
          //return 语句;
      }
   

   • 位置: 类以内,方法以外,和属性平级

   package com.by.entity;
   
   public class Student {
       String name;
       int age;
       String sex;
       double score;
      // score=90.0; 错误!!
       //吃饭
       public void eat(){
           System.out.println("吃饭");
       }
       //睡觉
       public void sleep(){
           System.out.println("睡觉");
       }
       //学习
       public void study(){
           System.out.println("学习");
       }
   
   }
   

五、创建对象

	类名 对象名=new 类名();

对象的使用

1. 使用属性

      取值: 对象名.属性名;
      赋值: 对象名.属性名=值;
   

2. 使用方法

      对象名.方法名(实参列表);
   

   //创建一个学生对象
           Student stu1 = new Student();
           Student stu2 = new Student();
           //给stu1对象属性赋值
           stu1.name = "zhangsan";
           stu1.age = 20;
           stu1.sex = "男";
           stu1.score = 90;
           //获取stu1对象属性的值
           System.out.println(stu1.name);
           System.out.println(stu1.age);
           System.out.println(stu1.sex);
           System.out.println(stu1.score);
           //获取查看stu2属性的值
           System.out.println(stu2.name);
           System.out.println(stu2.age);
           System.out.println(stu2.sex);
           System.out.println(stu2.score);
   
           //调用stu1中的方法
           stu1.eat();
           stu1.sleep();
           stu1.study();
   

六、构造方法

• 特殊的方法,作用为创建对象

（1）语法

1. 无参构造

      访问修饰符 类名(){
          
      }
   

2. 有参构造

      访问修饰符 类名(数据类型 参数名1,数据类型 参数名2,..){
          属性名1=参数名1;
          属性名2=参数名2;
          ..
      }
   

   package com.by.entity;
   
   public class Student {
       public String name;
       public int age;
       public String sex;
       public double score;
      // score=90.0; 错误!!
   
       //无参构造
       public Student() {
   
       }
       //有参构造
       public Student(String n, int a, String s, double sc){
           //用对应形参给对应属性赋值
           name = n;
           age = a;
           sex = s;
           score = sc;
       }
   
       //吃饭
       public void eat(){
           System.out.println("吃饭");
       }
       //睡觉
       public void sleep(){
           System.out.println("睡觉");
       }
       //学习
       public void study(){
           System.out.println("学习");
       }
   
   }
   

（2）特点

1. 语法特点:

   • 没有返回值类型部分
   • 方法名必须与类名一致

2. 使用特点:

   • 构造方法只能创建对象,创建对象也只能使用构造

   • 创建对象的语法延伸:

     类名 对象名=new 类名();
     

     • 第一个类名: 用来声明创建的是哪个类的对象
     • 第二个类名: 用来指明调用构造方法

   • 构造方法必须通过new关键字调用

   • 根据创建对象时的小括号内的参数列表决定调用的是哪个构造

   • 语法补充: 利用有参构造创建对象

     类名 对象名=new 类名(实参列表);
     

     //利用有参构造创建一个学生对象
     Student stu = new Student("zhangsan", 20, "男", 100.0);
     

   • 无参构造与有参构造的区别:

     1. 无参构造: 只负责创建对象
     2. 有参构造: 在创建对象的同时可以给属性赋初始值
     3. 无参构造至多存在一个,有参构造可以存在0-n个

   • 每个类中都会默认提供一个无参构造, 该构造具有时效性,当类中显式定义构造后,默认给予的构造将会失效

七、对象包含关系案例

对象包含案例代码:

package com.by.entity;

/**
 * 班级类
 */
public class Clazz {
    public String className;
    public int classNumber;
    //添加一个老师对象属性
    public Teacher tea;

    //无参构造
    public Clazz(){

    }

    //有参构造
    public Clazz(String cName, int cNumber) {
        className = cName;
        classNumber = cNumber;
    }

}
/**
 * 老师类
 */
public class Teacher {
    public String name;
    public String sex;

    public Teacher(){

    }
    //有参构造
    public Teacher(String n,String s){
        name = n;
        sex = s;
    }
    //行为方法-教学
    public void teach(){
        System.out.println("正在教java...");
    }

}

package com.by.test;

import com.by.entity.Clazz;
import com.by.entity.Teacher;

public class Test3 {
    public static void main(String[] args) {
        //创建一个老师对象
        Teacher t = new Teacher("张三", "男");
        //创建一个班级对象
        Clazz c = new Clazz("1班", 20);
        //将对象t赋值给c的tea属性
        c.tea = t;
        //查看班级对象c的所有信息: 班级名  班级人数 所包含的老师姓名  所包含的老师性别
        System.out.println("班级名: "+c.className+
                "  班级人数:"+c.classNumber+
                "  所包含的老师姓名:"+c.tea.name+
                "  所包含的老师性别:"+c.tea.sex);

    }
}