java面向对象编程（中级）

面向对象编程（中级）

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的比较

不同点	this	super
访问属性	访问本类中的属性，如果本类没有此属性则从父类继续查找	从父类开始查找属性
调用方法	访问本类中的方法，如果本类没有此方法则从父类继续查找	从父类开始查找方法
调用构造器	调用本类构造器，必须放在构造器的首行	调用父类的构造器，必须放在子类构造器的首行
特殊	表示当前对象	子类中访问父类对象

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 , 所以更多就是为了应付面试.