Java面向对象+

Raccom

已于 2023-08-10 11:00:39 修改

阅读量140

点赞数

分类专栏： Java 文章标签： java 开发语言

于 2023-08-08 18:14:04 首次发布

本文链接：https://blog.csdn.net/Raccon_/article/details/132172300

版权

Java 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

面向对象编程(中级部分)

访问修饰符

java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）:

公开级别: 用public 修饰,对外公开
受保护级别: 用protected 修饰, 对子类和同一个包中的类公开
默认级别: 没有修饰符号,向同一个包的类公开.
私有级别: 用private修饰,只有类本身可以访问,不对外公开.

注意事项

修饰符可以用来修饰类中的属性,成员方法以及类
只有默认的和public才能修饰类，并且遵循上述访问权限的特点。
成员方法的访问规则和属性完全一样.

面向对象编程三大特征

面向对象编程有三大特征：封装、继承和多态。

封装

封装(encapsulation)就是把抽象出的数据 [属性] 和对数据的操作 [方法] 封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作 [方法] ,才能对数据进行操作。

封装可以隐藏实现细节: 方法(连接数据库) <-- 调用(传入参数)，可以对数据进行验证，保证安全合理

Person {name, age}
Person p = new Person();
p.name = "jack" ;
p.age= 1200;

实现步骤

将属性进行私有化private【不能直接修改属性】

提供一个公共的(public)set方法，用于对属性判断并赋值

public void setXxx(类型参数名){//Xxx表示某个属性
    //加入数据验证的业务逻辑
    属性=参数名;
}

提供一个公共的 (public)get 方法，用于获取属性的值

public 数据类型 getXxx(){ //权限判断,Xxx某个属性
    return xx;
}

可以将set方法写在构造器中，这样可以保证验证。

public Person(String name, int age, double salary) {
    // this.name = name;
    // this.age = age;
    // this.salary = salary;
    //我们可以将set 方法写在构造器中，这样仍然可以验证
    setName(name);
    setAge(age);
    setSalary(salary);
}

继承

继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。

基本语法

class 子类 extends 父类 {
}

子类就会自动拥有父类定义的属性和方法
父类又叫超类,基类。
子类又叫派生类。

继承的注意问题

子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
子类必须调用父类的构造器，完成父类的初始化。先调用父类构造器，再调用子类构造器。
当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过.
如果希望指定去调用父类的某个构造器，则显式的调用一下: super(参数列表)
super 在使用时，必须放在构造器第一行( super 只能在构造器中使用 )
super() 和this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器。
java 所有类都是Object类的子类, Object 是所有类的基类.
父类构造器的调用不限于直接父类！将一直往上追溯直到Object类(顶级父类)
子类最多只能继承一个父类(指直接继承)，即java中是单继承机制。
不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

super 关键字

super 代表父类的引用，用于访问父类的属性、方法、构造器

基本语法

1.访问父类的属性，但不能访问父类的private属性[案例]
super.属性名;
2.访问父类的方法,不能访问父类的private方法
super.方法名(参数列表);
3.访问父类的构造器:
super(参数列表);只能放在构造器的第一句，只能出现一句!

super 的效果

调用父类的构造器的好处(分工明确,父类属性由父类初始化，子类的属性由子类初始化)
当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果!
super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员; 如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则。A->B->C，当然也需要遵守访问权限的相关规则

方法重写/覆盖(override)

方法覆盖(重写)就是子类有一个方法, 和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的方法。

注意事项

方法重写也叫方法覆盖，需要满足下面的条件

子类的方法的形参列表,方法名称,要和父类方法的形参列表方法名称完全一样。
子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类

比如交类返回类型是Object,子类方法返回类型是String
```
public object getInfo()
public String getInfo()
```
子类方法不能缩小父类方法的访问权限。最好大于等于父类的权限。（public > protected > 默认>private）

多态

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的，重写和重载就体现多态。

一个对象的编译类型和运行类型可以不一致
编译类型在定义对象时，就确定了，不能改变
运行类型是可以变化的
编译类型看定义时 = 号的左边，运行类型看 = 号的右边
多态的前提是：两个对象(类)存在继承关系

Animal animal = new Dog() // animal编译类型是Animal，运行类型Dog
animal = new Cat();// animal的运行类型变成了Cat,编译类型仍然是 Animal

多态的向上转型

本质:父类的引用指向了子类的对象
语法:父类类型引用名=new子类类型();
特点:编译类型看左边,运行类型看右边。

可以调用父类中的所有成员(需遵守访问权限),不能调用子类中特有成员;
最终运行效果看子类的具体实现! （运行时看运行类型，例如找方法时就是采用就近原则）

因为在编译阶段，能调用哪些成员，是由编译类型决定的。

多态向下转型

只能强转父类的引用，不能强转父类的对象
语法: 子类类型引用名 = (子类类型) 父类引用;
要求父类的引用必须指向的是当前目标类型的对象
当向下转型后，可以调用子类类型中所有的成员

instanceOf 比较操作符

用于判断对象的 运行类型

package com.hspedu.poly_.detail_;

public class PolyDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof  BB);// true
        System.out.println(bb instanceof  AA);// true

        //aa 编译类型 AA, 运行类型是BB
        //BB是AA子类
        AA aa = new BB();
        System.out.println(aa instanceof AA); // true
        System.out.println(aa instanceof BB); // true

        Object obj = new Object();
        System.out.println(obj instanceof AA);//false
        String str = "hello";
        //System.out.println(str instanceof AA);
        System.out.println(str instanceof Object);//true
    }
}

class AA {} //父类
class BB extends AA {}//子类

java 的动态绑定机制

1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
2.当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用，找不到再去父类中寻找。

Object 类详解

equals 方法

==和equals 的对比

==是一个比较运算符，既可以判断基本类型，又可以判断引用类型

==:如果判断基本类型，判断的是值是否相等。示例: int i=10; double d=10.0;
==:如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象

equals是Object类中的方法，只能判断引用类型

默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如 Integer,String

hashCode 方法

public int hashCode()

返回该对象的哈希码值。支持此方法是为了提高哈希表（例如java.util.Hashtable 提供的哈希表）的性能。

hashCode 的常规协定是：

在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

实际上由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 Java 编程语言不需要这种实现技巧。）

提高具有哈希结构的容器的效率
两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
两个引用，如果指向的是不同对象，则哈希值是不一样的（当然也可能存在碰撞）
哈希值主要根据地址号来的！不能完全将哈希值等价于地址。（java跑在JVM上，无法真正拿到其内部地址）

toString 方法

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

默认返回全类名+@+哈希值的十六进制，子类往往重写toString 方法，用于返回对象的属性信息（全类名就是包名 + 类名）

打印对象或拼接对象时，都会自动调用该对象的toString ，比如System.out.println(monster) ；// 就会默认调用monster.toString()

finalize 方法

当对象被回收时，系统自动调用该对象的finalize 方法。子类可以重写该方法，做一些释放资源（数据库的连接，打开或者关闭文件）的操作。
什么时候被回收：当某个对象没有任何引用时，则jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize 方法。（当然并不是一有垃圾就立马回收，有对应的垃圾回收GC算法）。
垃圾回收机制的调用，是由系统来决定(即有自己的GC算法), 也可以通过System.gc() 主动触发垃圾回收机制。
我们在实际开发中，几乎不会运用finalize , 所以更多就是为了应付面试。