面向对象编程

蕾姆的48六

已于 2022-08-02 15:11:21 修改

阅读量512

点赞数

分类专栏： JavaSE 文章标签： java

于 2022-04-27 10:03:05 首次发布

本文链接：https://blog.csdn.net/k1159/article/details/124443779

版权

JavaSE 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

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

封装：

保护性和易用性，有很多表现形式**
private实现封装：
private/ public 这两个关键字表示 “访问权限控制” .
public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用. private 修饰的成员变量或者成员方法, 不能被类的调用者使用，不可见
由小到大的顺序是： private（私有，当前类的内部可见）<default（啥也不写就是包权限）<protected（继承，不同包的有继承关系的类之间可见）<public（当前项目可见）

getter和setter方法：

在外部调用private修饰的变量。
alt+Insert 快捷创建getter或者setter方法

阿里编码规范：

Java类中所有成员变量一律使用private封装，并且根据属性的实际情况对外提供getter(获取)和setter(设置)方法。

【注】private实现属性的和方法封装只是封装的其中一种

构造方法：

构造方法是类中非常特殊的一类方法，使用new关键字实例化对象实际上就是调用该类的构造方法。
可以进行重载，此时重载只可能是参数的个数不同（为不同成员变量赋值）

作用：

产生对象。

使用关键字new产生一个对象时，大致分以下两步：

1、为对象在堆中分配空间，空间大小由该类中成员变量的数据类型决定。
2、JVM调用对象的构造方法为对象成员变量赋值（自动进行赋值）。

语法规则：

1、方法名称与类名称完全相同
2、没有返回值声明（不是void）
3、一个类中至少存在一个构造方法，若没有显式定义，编译器会生成一个默认的无参构造。

this关键字： 重点于当前类

1、调用当前对象的成员变量
【注】修饰属性，表示直接从当前类中寻找同名属性
程序的就近原则，相当于形参=形参，可以使用this关键字打破规则。

使用this关键字后：
在这里插入图片描述
【注】使用this修饰属性时，若存在继承关系，现在当前类中寻找同名属性，若不存在，去父类中寻找同名属性。而当直接使用属性时默认使用this关键字

2、调用当前对象的方法：
【注】修饰方法，表示从当前类中寻找方法
①调用普通成员方法
在这里插入图片描述

②构造方法的互相调用： 若不同参数的构造方法之间出现了重复的调用，可以使用 this(参数)调用其他的构造方法
【注】this和（参数）之间没有引用操作符

构造方法之间调用前：

构造方法之间调用后：

【注】this调用其他的构造方法必须放在当前构造方法的首行。this调用构造方法不能成”环“

3、表示当前对象的引用：当前通过那个对象调用的属性或者方法，this就代表谁。
在这里插入图片描述 【注】this表示当前对象的引用，有对象的。
代码块：
即使用 {} 括起来的一段代码称为代码块，根据定义的代码块的位置以及关键字的不同分为以下四种代码块
1、普通代码块：
定义在方法中，使用{}括起来的代码块
2、成员代码块：
定义在类中，使用{}括起来的代码块，也叫构造快。
作用：优先于构造方法执行，有几个对象产生就调用几次构造块。
3、静态代码块
定义在类中，使用static修饰的代码块，在类加载时执行一次，仅一次。
在这里插入图片描述
4、同步代码块
【synchronized修饰的代码块，保证锁同一个对象，让其只有一个可以进入代码块】

匿名对象：
new出来的对象，没有引用指向，使用后一次就销毁了，就用不成了。
通常用于测试类中的某些功能，使用后一次就被JVM销毁

toString方法：
当一个引用类型的变量调用println函数打印时，默认输出都是引用类型的地址（不是真正的内存地址）
当类中实现了toString方法后，当一个引用类型的变量调用println函数打印时，自动使用toString方法。

继承

当类和类之间满足：一个类 is a另一个类，一定存在继承关系。
当一个类继承了另一个类，另一个类中所有的属性和方法就自然具备了。

extends关键字
在这里插入图片描述
继承的规则：
1、满足类之间需存在is a关系
2、一个子类只能使用extends继承一个父类（Java中）、允许多层继承
3、子类会继承父类所有方法和属性：显示继承（public属性和方法）、隐式继承（private属性和方法）子类虽继承了但无法直接使用
在这里插入图片描述
隐式继承：
子类无法直接使用该属性，必须通过父类提供的方法操作
继承权限：
关于protecte访问权限
【注】同包下不包含子包
super关键字： 重点于父类中寻找
1、修饰属性： 表示先从直接父类中寻找属性，若不存在，继续向上寻找
2、修饰方法：

①修饰构造方法
若存在继承关系，产生子类对象时，默认先产生所有父类对象
在构造方法的首行默认super（父类构造方法参数）。
super() // 调用直接父类的无参构造，若父类中存在无参构造可写可不写。
若父类中不存在无参构造，则子类无参构造方法首行必须使用 super（有参构造）显式调用，且不能和this同时显式出现

②修饰普通方法
super修饰普通方法和属性，直接从父类寻找同名工作
使用“.”引用操作符
【注】super不能指代当前父类的对象引用

类和类之间的关系：
1、继承
2、组合
在这里插入图片描述

3、无关

※※※关于程序执行顺序：

在这里插入图片描述

多态：

一个引用可以表现出多种行为/特性。（父类引用表现子类对象的行为/孙子类/…）
而当引用调用方法时，若当前引用类中不存在该方法则不能调用（若非要调用此方法，需要使用向下转型），表现出的行为或者特性由new出来的对象决定。

类引用：①向上转型（继承类间）：父类对象的引用指向了子类对象
例：父类名称父类引用 = new 子类对象 ()；
【注】不一定时直接子类，可为孙子类，子子孙孙无穷尽也。

意义：
若没有向上转型在多重继承情况下，实现同名方法时有多少子类就要重载多少次很麻烦，所以引入向上转型使得参数统一化，降低使用者的使用难度和创造者的创造

使用向上转型的情况：
①方法传参
在这里插入图片描述
②引用赋值

③方法返回值
在这里插入图片描述

参数统一化：
在这里插入图片描述

多态

同一个方法，根据对象的不同表现出不同的行为
在这里插入图片描述

②向下转型：
【注】发生向下转型的前提：发生了向上转型
子类名称子类引用 =（子类名称）父类引用；
Dog dog = (dog) animal;//此时脱掉animal对应对象外衣，还原为具体子类引用
instanceof关键字：
返回布尔值，表示该引用指向的本质是不是该类的对象
在这里插入图片描述

方法重载和方法重写的区别：
【若子类中没有重写则就近匹配原则】
【子类方法权限>=父类，除了private】
【@override校验重写方法】
【重写返回值类型必须相同，除了向上转型】
在这里插入图片描述

构造方法+重写情况下运行顺序问题：
在这里插入图片描述

抽象类：
抽象类比普通类多了一些抽象方法，抽象方法所在的类必须是抽象类，子类若继承了抽象类，（子类是普通类）必须覆写所有抽象方法。
【抽象类无法实例化，只能通过子类向上转型】
【单继承】
abstract 关键字：
定义抽象类或者抽象方法
什么是抽象方法？
使用abstract声明，没有方法实现
【native方法（本地方法），没有方法体但不是抽象方法】

interface关键字：
声明接口，子类使用implements实现接口
接口：
1、具备某种能力/行为，子类实现接口不是 is a，而是具备这种行为或者能力
2、表示一种规范或者标准。
【当抽象和接口都能满足需求，选择接口实现】
【接口中只有全局常量和抽象方法，别的没有，且public、abstract、final、static关键字可以省略】
【参数统一化=>兼容性】
【允许多实现】
3、接口命名规范：
以 I 开头，子类实现接口时，命名以相应的接口开头，以 Iml 结尾，若子类实现多个父接口，则不需要此规范

在这里插入图片描述

开闭原则：
设计模式的核心思想，程序应当对扩展开放，对修改关闭。防止影响写好的程序

1、import关键字
import导入某一个包中的某一个类，若此时还需用到这个包中其他类，可写作 import.java.util.* //此时将会把整个util包下所有类按需加载，此时导入的仍然时类，不是把util文件夹导入
【注】当程序中用到了两个相同名称的类：1、使用类的全名称
2、import明确指定导入的是哪个包下的哪个类
静态导入： import static 可以导入包中静态方法和静态属性
在这里插入图片描述
常见的系统包：
Java.lang:JDK基础类,System,String,Object都在这个包下，JDK1.1之后这个包下的类自动导入
java.lang.reflect:反射开发包
java.util:工具包（集合类都在这个包下，Arrays，LinkedList，Hash Map）
java.io:I/O开发包，文件读取和写入
java.net :网络编程开发包，Socket
java.sql:数据库开发用到的包

Object类

1、Object类是Java中所有类（class声明）默认父类，无需extends定义
意义:所有类都可向上转型变为Object类，实现参数最高统一化。
2、Object类中所有方法都被子类继承
例：Object类中存在toString方法
在这里插入图片描述
3、Java中引用数据类型之间的相等比较使用equals方法
Object类中equals方法：

4、Object类可以接受所有引用数据类型的对象（数组，接口，类），基本类型用包装类

包装类

1、什么是包装类？
八大基本类型封装到类之中，方便Object类接收
2、有哪些包装类
byte ----->Byte
short ----->Short
int ----->Integer
long ----->Long
float ----->Float
double ----->Double
char ----->Character
boolean ----->Boolean
3、包装类的使用

		Integer i1 =10;//自动装箱
        i1 +=20;//自动拆箱

4、拆、装箱：
装箱：将基本类的数值保存到包装类对象中。
拆箱：将包装类对象中的数值还原为基本类型。
5、自动拆装箱：
使用包装类和使用基本类型无异
仅仅默认值不同。包装类默认值都为null。
在这里插入图片描述
阿里编码规范：所有普通类的成员变量一律使用包装类替代基本类型

接口优先原则

当一个场景既可以使用抽象类也可使用接口时，优先考虑使用接口

JDK内置的常用接口：

java.lang.Comparable: 当一个类实现了Comparable接口，表示该类具备了可比较的能力

package interface_practice;

import java.util.Arrays;

public class ComparableTest {
    public static void main(String[] args) {
        Person[] people = new Person[]{
                new Person("小张", 60),
                new Person("小李", 59),
                new Person("小王", 100),
        };
        Arrays.sort(people);
        System.out.println(Arrays.toString(people));
    }
}

class Person implements Comparable {//person类实现了Comparable接口表示，person类具备可比较的能力
    private String name;
    private int score;

    public Person(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

    /**
     * 返回值为int,有三种情况
     * 1、大于0，表示当前对象this大于传入对象0
     * 2、等于0，表示当前对象等于传入对象
     * 3、小于0，表示当前对象小于传入对象
     *
     * @param o
     * @return
     */
    @Override
    public int compareTo(Object o) {
        if (this == o) {
            return 0;
        }
        if (o instanceof Person) {
            //传入的o为Person类型的对象，此时要比较大小向下转型为Person使用子类的方法比较
            Person p1 = (Person) o;
            return this.score - p1.score;
        }
        //报错，抛出异常
        throw new IllegalArgumentException("不是Person类型无法比较");
    }
}

在这里插入图片描述
java.lang.Colneable: 使一个类具备可复制的能力，实现Cloneable接口，覆写clnoe方法。

package object_test;

public class CloneableTest {
    public static void main(String[] args) {
        Animal animal1 = new Animal("张三");
        Animal animal2 = animal1.clone();
        System.out.println(animal1 == animal2);
        System.out.println(animal2.name);
    }

}

class Animal implements Cloneable {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    @Override
    public Animal clone() {
        Animal animal = null;
        try {
            animal = (Animal) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
        return animal;
    }
}

【注】类似Cloneable接口，称为标记接口，这个接口本身没有任何抽象方法，只有打上这个标记的子类才具备克隆的能力。JVM在运行时会检查所有实现了标签接口的子类，赋予其独特的能力。
在这里插入图片描述

深浅拷贝：
1、浅拷贝：克隆的对象和原对象确实两个独立的对象，原对象的内部包含了其他类的引用，克隆后的对象内部也包含了其他类的引用，这两个其他类的引用都指向了一个对象，没有产生新的对象
在这里插入图片描述
2、深拷贝：

实现方式：
1、递归使用clone方法
2、序列化（把任意对象转为字符串）

蕾姆的48六

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象编程

1、import关键字import导入某一个包中的某一个类，若此时还需用到这个包中其他类，可写作 import.java.util.* //此时将会把整个util包下所有类按需加载，此时导入的仍然时类，不是把util文件夹导入【注】当程序中用到了两个相同名称的类：1、使用类的全名称2、import明确指定导入的是哪个包下的哪个类静态导入： import static 可以导入包中静态方法和静态属性常见的系统包：Java.lang:JDK基础类,System,String,Object都在这个
复制链接

扫一扫

专栏目录