【Java】基础入门（十一）--- 面向对象的基本概念

1.this关键字

在Java中，this表示当前对象，通常用于区分成员变量和方法中的局部变量，具体来说，this关键字可用于以下几个方面：

（1）引用当前对象的成员变量:
       在类的成员方法中，如果存在与成员变量同名的局部变量，则可以使用this关键字来引用当前对象的成员变量。例如：

package swp.kaifamiao.codes.Java.d0816;

/**
 * {class description}
 *
 * @author SWP
 * @version 1.0.0
 */
public class Demo01 {

    //成员变量

    private  String name;
    private  int age;

    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
}

       在上面的代码中，setName方法和setAge方法中的形参与成员变量同名，因此需要使用this关键字来区分看，其中this.后面的为成员变量,=后面的为局部变量（形参）

（2）调用当前对象的成员方法:

       在类的成员方法中，可以使用this关键字来调用当前对象的其他成员方法，例如：

package swp.kaifamiao.codes.Java.d0816;

/**
 * {class description}
 *
 * @author SWP
 * @version 1.0.0
 */
public class Demo02 {
    public void sayHello(){
        System.out.println("Hello!");
    }

    //this调用当前对象的成员方法

    public void sayHi(){
        this.sayHello();
    }
}

(3)调用当前对象的构造方法：

package swp.kaifamiao.codes.Java.d0816;

/**
 * {class description}
 *  * @author SWP
 * @version 1.0.0
 */
public class Demo03 {
    private  String name;
    private  int age;
    
    // 调用了当前类的另一个构造方法
    
    public Demo03(){
        this("Tom",20);
    }
    
    //有参构造
    
    public Demo03(String name,int age){
        this.name = name;
        this.age = age;
    }
}

---

• this — 谁执行（调用）就是谁；
• this 关键字只能在实例成员、实例初始化构造方法中出现，不能在静态方法中使用，因为静态方法不属于任何任何一个对象，不存在当前对象的概念。
• 使用this调用其他构造方法【 使用this[实参列表]调用重载的构造时，只能出现在构造的第一个语句 】

---

2.包

包是类的容器，利用包来划分名字空间，用于分割类名空间，以避免类名冲突。

包的主要作用：
（1）存放类；
（2）防止命名冲突；
（3）包允许在更广的范围内保护类、数据和方法。根据访问规则，包外的代码有可能不能访问该类。

注意：（1）同包下或子包下的类不需要导包；
           （2）Java.lang包下的类不需要导包；
           （3）命名包时不能以“Java”或“Javax”开头。

3.访问修饰符

Java中的封装是通过访问修饰符实现的。访问修饰符有3个（4种），分别是public、protected、package-access（包访问修饰符）、private。

• public访问修饰符：公开的，任何地方都能访问；
• protected访问修饰符： 受保护的，同包以及不同包子类中能访问；
• package-access（包访问修饰符）：包访问权限，同包中访问；
• private访问修饰符：私有的，只能在当前类中访问。

访问修饰符不能用于方法 中声明的变量或形式参数，因为在方法中声明的变量或形式参数的作用域仅限于该方法，在方法外是不可见的，其他类无法访问。

4.封装

• 什么是封装？

封装（Encapsulation）是面向对象的三大特征之一，是面向对象编程中的一种重要概念，它将数据和方法封装在一个单元（类）中，以实现信息隐藏和访问控制。

• 为什么要封装？

通过封装，可以提高代码的安全性、可重用性和可维护性。

---

• 如何封装？

封装的步骤：

（1）修改字段的可见性：

public class Demo04 {
    private int age;
    private String name;
    private String gender;
}

将public修改为private后，其他类就无访问了，如果需要访问则需要进行封装第二步

（2）设置getter/setter方法：

• Setter方法：将传入的参数值赋给属性
• Getter方法：直接返回属性的值

package swp.kaifamiao.codes.Java.d0816;

/**
 * {class description}
 *
 * @author SWP
 * @version 1.0.0
 */
public class Demo04 {
    private int age;
    private String name;
    private String gender;

    public void setAge(){
        this.age = age;
    }
    
    public int getAge() {
        return age;
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }
    
    public void setGender(String gender){
        this.gender = gender;
    }
    
    public String getGender(){
        return gender;
    }
}

（3）设置字段的存取权限
        在setter方法中进一步利用条件判断语句进行赋值限制。

5.包装类

在Java中，基本数据类型与对象类型是两个不同的概念。为了使基本数据类型也具备面向对象的特性，Java 提供了包装类（Wrapper Class）

基本类型	包装类
boolean	java.lang.Boolean
byte	java.lang.Byte
short	java.lang.Short
int	java.lang.Integer
long	java.lang.Long
float	java.lang.Float
double	java.lang.Double

一般情况下，基本数据类型和其包装类可以交替使用。

默认值是null

包装类的默认值都是 null。

例如，Integer 类的初始值是 null，而不是基本类型 int 的默认值 0。

例如：

Integer num = null;
System.out.println(num);  // 输出为 null

装箱&拆箱

• 装箱：将基本数据类型自动转换为对应的包装类对象，可以使用包装类的构造方法或静态方法ValueOf( )来完成
• 拆箱：将包装类对象自动转换为对应的基本数据类型，可以使用包装类提供的xxxValue（）方法来完成。

例如：

// 自动装箱
Integer i = 5;

// 自动拆箱
int num = i;

6.继承

6.1 什么是继承？

• 继承是面向对象的三大特征之一
• 一个类（称为子类或派生类）可以继承另一个类（称为父类或基类）的属性和方法。通过继承，子类可以获得父类的特性，并且可以在此基础上增加、修改或覆盖功能，同时还可以定义自己独有的属性和方法。

6.2 为什么要继承？

• 代码重用：通过继承，子类可以直接获得父类的属性和方法，无需重复编写相同的代码。这样可以提高代码的效率和可维护性，减少了冗余的代码量。
• 层次化组织：继承可以实现类之间的层次化组织，将共性的属性和行为放在父类中，具体的特性和功能可以通过子类来实现。
• 层次化组织：继承可以实现类之间的层次化组织，将共性的属性和行为放在父类中，具体的特性和功能可以通过子类来实现。
• 多态性：继承是实现多态性的基础。多态性指的是同一类型的对象在不同的情境下表现出不同的行为。通过继承和方法的重写，可以在父类引用的情况下，根据实际的子类对象来调用相应的方法，实现了程序的灵活性和扩展性。
• 继承关系的建立抽象模型：通过继承，可以建立起一种抽象模型，将具有相似属性和行为的对象归类到同一个类别中。这样就能更好地理解和描述问题领域中的实体之间的关系，从而提升了设计和开发的效率。

6.3 继承了什么？

• 属性：子类可以继承父类的属性，包括实例变量和类变量。子类可以直接访问并使用这些属性。
• 方法：子类可以继承父类的方法，这些方法可以被子类直接调用。子类可以通过继承获得父类方法的功能，并根据需要进行重写或扩展。
• 构造函数：如果子类没有自定义构造函数，它将继承父类的构造函数。这意味着子类可以通过继承来创建对象并初始化其属性。
• 内部类（如果有）：如果父类包含内部类，子类也将继承这些内部类。子类可以使用继承的内部类来访问父类中的成员。

注意：子类只能继承父类的非私有成员。私有成员（私有属性和私有方法）无法在子类中直接访问和继承，它们只能在父类内部使用。

6.4 如何继承？

（1）使用关键字 extends：在子类的类声明中使用 extends 关键字来指定父类。语法如下：

class 子类名 extends 父类名 {
    // 子类的成员和方法
}

（2）访问父类的构造函数：如果子类需要初始化父类的属性，可以通过在子类的构造函数中调用父类的构造函数来实现。使用关键字 super 来调用父类的构造函数。语法如下：

class 子类名 extends 父类名 {
   子类名(参数列表) {
       super(参数列表);  // 调用父类的构造函数
       // 子类的其他初始化代码
   }
}

（3）重写父类的方法：子类可以通过在子类中重新定义与父类相同名称的方法来重写父类的方法。在子类中的方法会覆盖父类中的方法。语法如下：
注意 : 方法的访问权限不能低于父类中方法的访问权限

@Override  // 可选注解，用于提醒编译器进行重写检查
返回类型 方法名(参数列表) {
    // 子类的方法实现
}

（4）访问父类的属性和方法：子类可以直接访问继承自父类的公共和受保护（protected）的属性和方法。通过使用 super 关键字，子类可以访问父类的方法或属性。语法如下：

super.父类方法名(参数列表);  // 调用父类的方法
super.父类属性名;  // 访问父类的属性

注意： Java中只支持单继承，即一个子类只能继承一个父类。但是，子类可以成为另一个类的父类，从而形成继承链。

6.5 方法重写

子类可以重写父类的方法，即提供自己的实现。使用 @Override 注解可以明确表示一个方法是重写父类的方法。

例如：

public class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating.");
    }
}

6.6 instanceof 的使用

instanceof 是 Java 中的关键字，用于判断一个对象是否是某个类的实例或子类的实例。它可以用来做类型检查和类型转换。

Animal cat = new Cat();

if (cat instanceof Cat) {
    System.out.println("cat is an instance of Cat");
}

if (cat instanceof Animal) {
    System.out.println("cat is an instance of Animal");
}

6.7 final 的使用

• final 是 Java 中的关键字，可以修饰类、方法和变量。
• final class MyClass：该类不能被继承。
• final void myMethod()：该方法不能被子类重写。
• final int num：该变量是一个常量，不能再次赋值。