Java 面向对象基础

面向对象基础

类和对象

什么是类

1. 类是现实生活中一类具有共同属性和行为的事物的抽象。

2. 类的特点

   • 类是对象的数据类型
   • 类是具有相同属性和行为的一组对象的集合

什么是对象的属性

1. 属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值。

什么是对象的行为

1. 行为：对象能够执行的操作。

类和对象的关系

1. 对象：是能够看得到摸得着的真实存在的实体。
2. 关系：类是对象的抽象，对象是类的实体。

类的定义

1. 类的重要性：类是 Java 程序的基本组成单位。

2. 类的组成：属性和行为

   • 属性：在类中通过成员变量来体现（类中方法外的变量）
   • 行为：在类中通过成员方法来体现（和前面的方法相比去掉 static 关键字即可）

3. 类的定义格式：

   public class 类名{
       //成员变量
       变量1的数据类型 变量1;
       变量2的数据类型 变量2;
       ...
       //成员方法
       方法1;
       方法2;
       ...
   }
   

对象的使用

1. 创建对象

   • 格式：

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

2. 使用对象

   • 使用成员变量

     • 格式：

       对象名.变量名
       

   • 使用成员方法

     • 格式：

       对象名.方法名();
       

成员变量和局部变量

成员变量

• 类中方法外的变量

局部变量

• 方法中的变量

成员变量与局部变量的区别

构造方法

概述

1. 构造方法是一种特殊的方法。

2. 作用：创建对象

3. 格式：

   public class 类名{
       修饰符 类名(参数){
           //构造方法内书写的内容
       }
   }
   

4. 功能：主要是完成对象数据的初始化。

注意事项

1. 构造方法的创建

• 如果没有定义构造方法，系统将给出一个默认的无参构造方法。
• 如果定义了构造方法，系统将不再提供默认的构造方法。

2. 构造方法的重载
   • 如果自定义了带参数构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法。
3. 推荐的使用方式
   • 无论是否使用，都手工书写无参数构造方法。

标准类原则

1. 成员变量

   • 使用 private 修饰

2. 构造方法

   • 提供一个无参构造方法
   • 提供一个带多个参数的构造方法

3. 成员方法

   • 提供每一个成员变量对应的 setXxx()/getXxx()
   • 提供一个显示对象信息的 show()

4. 创建对象并为其成员变量赋值的两种方式

   • 无参构造方法创建对象后使用**setXxx()**赋值
   • 使用带参构造方法直接创建带有属性值的对象

封装

private 关键字

1. private 关键字
   • 是一个权限修饰符
   • 可以修饰成员（成员变量和成员方法）
   • 作用是保护成员不被别的类使用，被 private 修饰的成员只在本类中才能访问。
2. 针对 private 修饰的成员变量，如果需要被其他类使用，可以设置相应的操作
   • 创建”get 变量名()“方法，用于获取成员变量的值，方法用 public 修饰
   • 创建”set 变量名(参数)“方法，用于设置成员变量的值，方法用 public 修饰

this 关键字

1. this 关键字

   • this 修饰的变量用于指代成员变量，代表所在类的对象引用，方法被哪个对象调用，this 就代表哪个对象
   • 方法的形参如果与成员变量同名，不带 this 修饰的变量指的是形参，而不是成员变量
   • 方法的形参没有与成员变量同名，不带 this 修饰的变量指的是成员变量

2. this 的作用

   • 解决局部变量与成员变量同名的问题

封装概述

• 是面向对象三大特征之一（封装、继承、多态）
• 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

封装原则

• 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来事项对隐藏信息的操作和访问成员变量 private，提供对应的 getXxx()/ setXxx() 方法。

封装好处

• 通过方法来控制成员变量的操作，提高了代码的安全性
• 把代码方法进行封装，提高了代码的复用性

继承

概述

• 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。

• 格式：

  public class 子类名 extends 父类名{}
  

  • 父类，也称为基类、超类
  • 子类，也称为派生类

• 继承中子类的特点：

  • 子类可以有父类的内容
  • 子类还可以有自己特有的内容

• 继承的用途：一般用于多个类中具有相同的特征（属性和方法），将相同的特征提取出来作为父类，然后多个类再继承父类相同的特征。

继承的好处和弊端

• 好处：

  • 提高了代码的复用性（多个类相同的成员可以放在同一个类中）
  • 提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

• 弊端：

  • 继承让类与类之间产生了关系，类的耦合性增强，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性。

继承中变量的访问特点

• 在子类方法中访问一个变量（自内向外）
  • 子类局部范围找
  • 子类成员范围找
  • 父类成员范围找
  • 继续往上找（若父类也有自己的父类）

super

• super 关键字的用法和 this 关键字的用法相似

  • this：代表本类对象的引用
  • super：代表父类存储空间的标识（可以理解为父类对象的引用）

  关键字	访问成员变量	访问构造方法	访问成员方法
  this	this.成员变量访问本类成员变量	this(...)访问本类构造方法	this.成员方法(...)访问本类成员方法
  super	super.成员变量访问父类成员变量	super(...)访问父类构造方法	super.成员方法(...)访问父类成员方法

继承中构造方法的访问特点

• 子类中所有的构造方法默认都会访问父类中的无参构造方法。

• 原因：

  • 因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。
  • 每一个子类构造方法的第一条语句默认是：super();

• 当父类中没有无参构造方法，只有带参构造方法时，有两种解决方案：

  • 通过 super 关键字在子类构造方法中调用父类的带参构造方法
  • 在父类中自己提供一个无参构造方法

继承中成员方法的访问特点

• 通过子类对象访问一个方法
  • 子类成员范围找
  • 父类成员范围找
  • 继续往上找（若父类也有自己的父类）

方法重写

• 概述

  • 子类中出现了和父类一模一样的方法声明（包括返回值和参数类型，但不包括权限符）。

• 应用

  • 当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写父类中的方法。这样，即继承了父类的功能，又定义了子类特有的内容。

• @Override

  • 是一个注解
  • 可以帮助我们检查重写方法的方法声明的正确性

• 重写方法格式一般为：

  public class Fu{
      public void show(){
          int f = 0;
          System.out.println("f的值为：" + f);
      }
  }
  
  public class Zi extends Fu{
      public void show(){
          System.out.println("调用子类的show方法");
          super();   // 当子类重写方法是在父类方法上添加功能时，可以在添加功能后直接调用super();
      }
  }
  

方法重写的注意事项

• 私有方法不能被重写（父类私有成员子类是不能继承的）
• 子类方法访问权限不能比父类的低（public > 默认 > 私有）

继承的注意事项

• Java 中类只支持单继承，不支持多继承
• Java 中类支持多层继承

多态

概述

• 同一个对象，在不同时刻表现出来的不同形态。
• 多态的前提和体现
  • 有继承/实现关系
  • 有方法重写
  • 有父类引用指向子类对象

多态中成员访问特点

• 成员变量：编译看左边，执行看左边

• 成员方法：编译看左边，执行看右边

• 成员变量与成员方法访问特点不一样原因

  • 因为成员方法有重写，而成员变量没有

多态的好处和弊端

• 好处：提高了程序的扩展性

  具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体子类型参与操作

• 弊端：不能使用子类的特有功能

多态中的转型

• 向上转型

  • 从子到父

  • 父类引用指向子类对象

  • 格式：

    Fu f = new Zi();
    

• 向下转型

  • 从父到子

  • 父类引用转为子类对象

  • 格式：

    Zi z = (Zi) f;