java面向对象编程（中级）

2023-12-25 20:42:56

面向对象编程（中级）

1、包

（1） 什么是包？

在Java中，包（Package）是用于组织和管理类以及其他Java 程序元素的一种机制。它是一种命名空间，可以将相关的类和接口组织在一起。Java包通常对应着目录结构。例如，com.example.myapp 包可能对应着文件系统中的 com/example/myapp 文件夹，类文件会按照包名的层次结构存储在相应的文件夹中。

（2） 包的三大作用

  1. 区分相同名字的类

  2. 当类很多时，可以很好的管理类（比如Java 的API 官方文档）

  3. 控制访问的范围。

    ? Java中的访问修饰符（如 public、protected、private、默认访问控制符等）可用于限制类和接口在包内的可见性。类和接口可以在同一包中直接访问彼此，但在其他包中，要想访问就需要使用合适的访问修饰符。

（3） 包的基本语法
package com.example.myapp;
说明：
    1、packege 关键字，表示打包
    2、com.myapp 表示包的名字
（4）包的本质

? 包的本质就是创建不同的文件夹/目录，来保存类文件

（5）包的命名

只能包含数字、字母、下划线、小圆点，不能是数字开头，不能是关键字或者保留字

一般是小写字母加上小圆点

比如：com.sina.crm.user

(6) 常用的包
  1. java.lang.* 是java的基本包，默认引用，不需要再引入
  2. java.util.* 系统提供的工具包，工具类，比如 Scanner
  3. java.net.* 网络包，用于网络的开发
  4. java.awt.* java的界面开发，GUI
（7） 引用包
//引用包的语法：import+包的名字
import java.util.Scanner;       //只是引用一个类Scanner
import java.util.*;             //引用java.util的所有包（不建议）

2、访问修饰符

（1）基本介绍

Java 中有四种访问修饰符：

  1. public（公共）：
    • 公共访问修饰符表示任何类都可以访问该成员（类、方法、变量等）。
    • 在同一个包中或其他包中的任何类都可以访问公共成员。
  2. private（私有）：
    • 私有访问修饰符表示只有在声明它的类内部才能访问该成员。
    • 私有成员对于同一个包中的其他类是不可见的。
  3. protected（受保护）：
    • 受保护访问修饰符允许同一个包内的类和该类的子类访问成员。
    • 对于其他包中的类来说，只有在它是该类的子类时才能访问受保护成员。
  4. 默认（包级私有，默认）：
    • 如果没有指定任何访问修饰符（不使用 public、private 或 protected），则该成员将具有默认访问权限。
    • 默认访问权限意味着只有同一个包内的其他类能够访问这个成员。
（2）访问修饰符的访问范围
访问级别访问控制修饰符同类同包子类不同包
公开public√√√√
受保护protected√√√×
默认没有修饰符√√××
私有private√×××
（3） 注意事项
  1. 修饰符可以修饰类中的属性，成员方法和类
  2. 只有默认和public才能修饰类
  3. 访问方法的访问规则和属性一样

3、面向对象编程三大特征介绍

面向对象的三大特征：封装、继承、多态

  1. 封装（Encapsulation）：
    • 封装是指将数据和操作数据的方法（即行为）捆绑在一起，并限制对外部的访问。
    • 通过封装，对象的内部细节对外部是隐藏的，只暴露必要的接口来与对象交互。
    • 这种机制提高了安全性，并且使得更容易维护和修改代码，因为改变对象内部实现不会影响外部代码。
  2. 继承（Inheritance）：
    • 继承是指一个类（子类）可以通过继承另一个类（父类）的特性和行为。
    • 子类可以继承父类的属性和方法，而且还可以在此基础上添加新的属性和方法。
    • 继承支持代码重用和层次化，使得代码更具扩展性和灵活性。
  3. 多态（Polymorphism）：
    • 多态性是指同一个方法在不同的对象上可以具有不同的行为。
    • 在面向对象编程中，多态性通常表现为子类对象可以被当做父类对象对待。这允许在不同对象上使用相同的方法名进行操作，但实际调用的方法可能会因对象类型的不同而有所不同。
    • 多态性提高了代码的灵活性和可扩展性，同时使代码更易于重用。

4、封装

封装是指将数据和操作数据的方法（即行为）捆绑在一起，并限制对外部的访问。

（1）封装的步骤

封装的步骤通常包括：

  1. 数据声明为私有（Private Data Declaration）：
    • 将类的数据成员声明为私有（private），这样它们只能在类的内部访问，外部无法直接访问这些数据。
    • 通过将数据设为私有，可以防止外部直接访问和修改数据，确保数据的安全性。
  2. 提供公共方法（Provide Public Methods）：
    • 通过公共方法（getter 和 setter 方法）来间接访问和修改私有数据。getter 方法用于获取数据的值，setter 方法用于设置数据的值。
    • 公共方法提供了外部访问数据的接口，使得外部类可以通过这些方法与对象进行交互。
（2）举例
public class Person {
    private String name; // 将数据声明为私有

    // 提供公共方法来访问和修改私有数据
    public String getName() {
        return name; // getter 方法用于获取数据
    }

    public void setName(String newName) {
        this.name = newName; // setter 方法用于设置数据
    }
}

5、继承

继承是指一个类（子类）可以通过继承另一个类（父类）的特性和行为。继承支持代码重用和层次化，使得代码更具扩展性和灵活性。

(1) 继承的基本语法
  • 通过extends继承父类的成员变量和方法
  • 子类会自动拥有父类定义的属性和方法
// 父类（基类、超类）
class Parent {
    // 父类的成员变量和方法
}

// 子类（派生类）继承父类（基类）
class Child extends Parent {
    // 子类新增的成员变量和方法
}
（2）注意事项和细节

  1. 子类继承了父类所有的属性和方法，非私有的属性和方法可以直接访问，但是父类私有的方法和属性不能直接访问，需要父类提供公共的方法去访问

  2. 子类必须调用父类的构造器， 完成父类的初始化

  3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则编译不通过。

  4. 如果希望指定去调用父类的某个构造器，则显式的调用一下: super(参数列表)

  5. super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)

  6. super() 和this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

  7. java 所有类都是Object 类的子类, Object 是所有类的基类.

  8. 父类构造器的调用不限于直接父类！将一直往上追溯直到Object 类(顶级父类)

  9. 子类最多只能继承一个父类(指直接继承)，即java 中是单继承机制。
    思考：如何让A 类继承B 类和C 类？ 【A 继承B， B 继承C】

  10. 不能滥用继承，子类和父类之间必须满足is-a 的逻辑关系

    Person is a Music  //不合理
Father is a Person //合理
（3）继承的本质（重要）
  1. 首先会调用Object 的构造器，然后是GrandPa 的构造器，然后是Father 的构造器，最后才是Son 的构造器
  2. 当子类对象创建好之后，是一种查找的关系

在这里插入图片描述

代码如下：

/**
 * 讲解继承的本质
 */
public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();
        //按照查找关系来返回信息
        //(1)首先看子类是否有该属性，如果子类有这个属性，并且可以访问，则返回信息
        //(2)如果子类没有这个属性，就看父类有咩有属性（如果有并且可以访问，则返回信息）
        //(3)如果父类没有，就按照（2）的规则，继续往上找上级的父类，直到object类
        System.out.println(son.name);   //返回是大头儿子
        System.out.println(son.age);    //返回是39
        System.out.println(son.hobby);  //返回的是旅游
    }
}

class GrandPa{
    String name = "大头爷爷";
    String hobby = "旅游";
}
class Father extends GrandPa{
    String name = "大头爸爸";
    int age = 39;
}
class Son extends Father{
    String name = "大头儿子";

}

6、多态

它允许不同类的对象对同一消息作出不同的响应。多态性是通过“一个接口，多种实现”来实现的。多态可以表现为方法的多态和对象的多态。

（1）方法的多态
  • 方法重载（Overloading）
    • 编译时多态是通过方法重载实现的，即在编译阶段确定调用哪个方法，根据方法名和参数列表来区分不同的方法。
  • 方法重写（Overriding）
    • 运行时多态是通过方法重写实现的，即在运行时确定调用哪个方法，根据对象的实际类型来决定方法的调用。
（2）对象的多态（核心、重点、困难）
  1. 一个对象的编译类型和运行类型可以不一致
  2. 编译类型在定义对象时，就确定了，不能改变
  3. 运行类型是可以改变的
  4. 编译类型看定义时 =的左边，运行类型看 =的右边

Animal animal = new Dog() 解释：animal编译类型是Animal，运行类型是Dog

animal = new Cat(); 解释：Animal的运行类型变成了Cat，但是编译类型仍然是Animal

（3） 向上转型

多态的前提是：两个对象存在继承关系

  1. 向上转型的 本质是：父类的引用指向了子类的对象
  2. 语法特点： 父类类型 引用名 = new 子类类型（）；
  3. 特点：
    1. 编译类型看左边，运行类型看右边
    2. 可以调用父类中的所有成员（方法和属性）（需遵守访问权限）
    3. 不能调用子类中的特有成员；
    4. 最终运行效果要看子类的具体实现。

举例：

//父类
public class Animal {
    String name;

    public void eat(){
        System.out.println("Animal 吃");
    }

    public void run(){
        System.out.println("Animal 跑");
    }

    public void  show(){
        System.out.println("Animal Show");
    }
}
//子类
public class Cat extends Animal{
    int age;
    public void eat(){
        System.out.println("Cat 吃");
    }
    public  void special(){
        System.out.println("Cat special");
    }
}
//实现
public class Test {
    public static void main(String[] args) {
        Animal animal = new Cat();
        //无法解析Car中独有的方法和属性
//        animal.special();  报错
//        animal.age;		报错
        //重写，首先是先找car里面有的方法，运行的时候看子类
        animal.eat();		//首先父类有这个方法，然后子类重写了，最终运行的时候还是看子类的运行结果

    }
}
（4） 向下转型

向下转型是针对于向上转型之后的，重新转回本来运行类型的对象。

  1. 语法：子类类型 引用名 = （子类类型） 父类引用；
  2. 只能强转父类的引用，不能强转父类的对象
  3. 要求父亲的引用必须指向的是当前目标类型的对象
  4. 当向下转型后，可以调用子类类型中所有的成员。
//实现
public class Test {
    public static void main(String[] args) {
        Animal animal = new Cat();
        //再继续向下转型，引用必须是当前目标类型的对象
        Cat cat = (Cat) animal
        //可以调用子类类型中所有的成员
	    animal.special(); 
        animal.age;		
        animal.eat();	

    }
}
（5）属性值

属性的值没有重写，属性值直接看编译类型

//假设Cat为Animal的子类
Cat子类 age = 10;
Animal 父类 age = 20;

//向上转型
Animal animal = new Cat();
//向下转型
Cat cat = (Cat)animal;
System.out.println(animal.age);		//因为编译类型为animal，所以输出为animal的age=20
System.out.println(cat.age);		//重新修改编译类型，现在的编译类型为cat，所以age=10
（6）java的动态绑定机制（重要）
  • 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
  • 当调用对象属性时，没有动态绑定机制，哪里声明哪里使用

举例：

public class DynamicalBand {
    public static void main(String[] args) {
        A a = new B();
        //实现逻辑：a.sum()的运行对象是b，但是b中没有sum方法，所以从父类找，父类的sum方法里面，有个getI方法，这个方法首先看运行对象里面是否有，这里有的话，get的运行对象的i，所以最后的结果是30
        System.out.println(a.sum());
        //实现逻辑：a.sum1()的运行对象是b，但是b中没有sum1方法，所以从父类找，父类的sum1里面有个i，但是属性并没有动态绑定机制，所以直接是采用A父类的i，所以结果是20
        System.out.println(a.sum1());
    }
}

class A{//父类
    public int i = 10;
    public int sum(){
        return getI() + 10;
    }
    public int sum1(){
        return i + 10;
    }
    public int getI(){
        return i;
    }
}

class B extends A{//父类
    public int i = 20;
//    public int sum(){
//        return i + 20;
//    }
//    public int sum1(){
//        return i + 10;
//    }
    public int getI(){
        return i;
    }
}

7、SUPER 关键字

super 是 Java 中的关键字，用于引用父类的成员（方法、变量）或调用父类的构造方法。

（1）使用方法

? 1、访问父类的属性，但不能访问父类的private属性

? super.属性名;

? 2、调用父类的方法，不能访问父类的private 方法

? super.方法名（参数列表）;

? 3、访问父类的构造器

? super(参数列表);只能放在构造器的第一句，而且只能出现一句。

示例：

public class Parent {
    int value = 10;
    
	Parent() {
        System.out.println("Parent constructor");
    }
    
    void display() {
        System.out.println("Value in parent: " + value);
    }
}

public class Child extends Parent {
    int value = 20;
	Child() {
        super(); // 调用父类的构造方法
        System.out.println("Child constructor");
    }
    
    void display() {
        super.display(); // 调用父类的 display 方法
        System.out.println("Value in child: " + value);
        System.out.println("Value in parent using super: " + super.value); // 访问父类的 value
    }
}
(2) super关键字的好处
  1. 调用父类的构造器的好处，分工明确，父类属性由父类初始化，子类的属性由子类初始化
  2. 当子类有和父类中的成员（属性和方法） 重名，为了访问父类的成员，必须通过super，如果没有重名，使用super、this、直接访问都是一样的效果。
  3. super访问**不限于直接父类，如果爷爷类与本类有同名的成员，也可以使用super去访问爷爷类的成员。**如果多个基类都有同名的成员，使用super遵循就近原则 A->B->C，同时也需要遵循访问权限的相关规则。
（3) super与this的比较
不同点thissuper
访问属性访问本类中的属性，如果本类没有此属性则从父类继续查找从父类开始查找属性
调用方法访问本类中的方法，如果本类没有此方法则从父类继续查找从父类开始查找方法
调用构造器调用本类构造器，必须放在构造器的首行调用父类的构造器，必须放在子类构造器的首行
特殊表示当前对象子类中访问父类对象

8、方法重载/重写（OVERRIDE）

方法重写（Method Overriding）指的是子类可以重新定义（覆盖）从其父类继承而来的方法。当子类声明了一个与父类中某个方法签名完全相同的方法时，就发生了方法重写。

举例：

class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    // 方法重写
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}
(1) 注意事项

  1. 子类的方法的形参列表、方法名称要和父类方法的形参列表，方法名称完全一样

  2. 子类方法的返回类型和父类方法的返回类型一样，或者是父类返回类型的子类

    ? 比如：父类的返回类型是Object，子类的返回类型是String

    ? public Object getInfo（）{} public String getInfo(){}

  3. 子类方法不能缩小父类的方法的权限，但是可以扩大

class Animal {
    protected void makeSound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    // 这是合法的重写，子类可以扩大父类方法的访问权限
    public void makeSound() {
        System.out.println("Bark");
    }
}
(2) 重写（Override）和重载（Overload）的比较
名称发生范围方法名形参列表返回类型修饰符
重载（Overload）本类必须一样类型、个数或者顺序至少有一个不同无要求无要求
重写（override）父子类必须一样相同相同或者子类的返回类型是父类返回类型的子类子类方法不能缩小父类方法的访问类型

9、OBJECT 类详解

（1）equals方法

equals() 方法是用于比较 两个对象是否在逻辑上相等的方法。该方法定义在 Object 类中，因此所有 Java 类都继承了这个方法。然而，它通常需要在类中进行重写，以便根据对象的实际内容（而不是引用地址）来判断相等性。

equals 与== 的比较

  1. ==既可以判断基本类型，又可以判断引用类型
  2. ==如果判断基本类型，判断的是值是否相等
  3. ==如果是判断引用类型，判断的是地址是否相等，即判定是否为同一个对象
  4. equals是Object类中的方法，只能判断引用类型。默认判断的是地址是否相等，子类会进行重写，判断两者内容是否相同。
（2）hashCode方法
  1. hashCode主要用来提高具有哈希结构的容器的效率
  2. 两个引用，如果指向的是同一个对象，哈希值是一样的
  3. 两个引用，如果指向的是不同的对象，哈希值是不一样的
  4. 哈希值主要是根据地址来的，但是不能完全将哈希值等价于地址
（3） toString方法

**Object源码：**默认返回：全类名+@+哈希值的十六进制

  public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

子类往往会重写toString方法，打印对象或者拼接对象时，都会自动调用该对象的toString方法

System.out.println(monster); //默认调用monster.toString()

重写示例：

//快捷键 Alt+Insert
public String toString() {  //重写toString，一般默认是class类名以及属性输出
    return "Employee{" +
        "name='" + name + '\'' +
        ", salary=" + salary +
        '}';
}
(4) finalize方法

finalize 被设计用来在对象被垃圾回收之前进行资源释放或清理操作。程序员可以在finalize方法里面写自己的一些业务逻辑（如：释放资源，数据库连接，或者打开的文件等）

  1. 当 **对象被回收时，系统自动调用该对象的finalize 方法。**子类可以重写该方法，做一些释放资源的操作
  2. 什么时候被回收： 当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize 方法
  3. 垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制

我们在实际开发中，几乎不会运用 finalize , 所以更多就是为了应付面试.

文章来源:https://blog.csdn.net/m0_46335449/article/details/135207909
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。