java面向对象基础知识点总结

最新推荐文章于 2024-06-24 10:05:31 发布

安好安好33

最新推荐文章于 2024-06-24 10:05:31 发布

阅读量407

点赞数 1

分类专栏： javase基础文章标签： java

本文链接：https://blog.csdn.net/weixin_44093711/article/details/111831616

版权

javase基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

面向对象三大特征

封装继承多态

封装

是对类的封装，封装是对类的属性和方法进行封装，只对外暴露方法而不暴露具体使用细节，所以我们一般设计类成员变量时候大多设为私有而通过一些get、set方法去读写

继承

子类继承父类的属性和方法，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的方法。父类有时也叫基类、超类；子类有时也被称为派生类。
为什要继承？
使用继承不仅大大的减少了代码量，也使得代码结构更加清晰可见。
继承的分类：
分为单继承（一个子类只拥有一个父类）和多继承（一个子类拥有多个直接的父类），Java语言只支持类的单继承，但可以通过实现接口的方式达到多继承的目的
单继承：
类层次结构上比较清晰，但缺点是结构的丰富度有时不能满足使用需求
多继承：
子类的丰富度很高，但是缺点就是容易造成混乱
Java虽然不支持多继承，但是Java有三种实现多继承效果的方式，分别是内部类、多层继承和实现接口
内部类可以继承一个与外部类无关的类，保证了内部类的独立性，正是基于这一点，可以达到多继承的效果。
多层继承：子类继承父类，父类如果还继承其他的类，那么这就叫多层继承。这样子类就会拥有所有被继承类的属性和方法
实现接口是满足多继承使用需求的最好方式，一个类可以实现多个接口满足自己在丰富性和复杂环境的使用需求
类和接口相比，类就是一个实体，有属性和方法，而接口更倾向于一组方法
实现继承extends，还可以用implements这个关键字实现

继承的特点

this和super关键字，分别表示当前对象的引用和父类对象的引用
this和super关键字只能出现在非static修饰的代码中。
this()和super()都只能在构造方法的第一行出现，如果使用this()表示调用当前类的其他构造方法，使用super()表示调用父类的某个构造方法，所以两者只能根据自己使用需求选择其一

构造方法

与类同名，分为有参构造和无参构造
父类的构造方法不能被继承
子类的构造方法必须调用其父类的构造方法:
Java虚拟机构造子类对象前会先构造父类对象，父类对象构造完成之后再来构造子类特有的属性，这被称为内存叠加。而Java虚拟机构造父类对象会执行父类的构造方法，所以子类构造方法必须调用super()即父类的构造方法
如果子类的构造方法中没有显示地调用父类构造方法，则系统默认调用父类无参数的构造方法

public class BaseClass {
    public BaseClass(){
        
    }
    public BaseClass(String name ){
        System.out.println("父类");
    }
}


public class SubClass extends BaseClass{
    public SubClass(String name) {

//        super(name);注释掉，在父类加上无参构造
        System.out.println("子类");
    }
}

方法重写

@Override
方法重写也就是子类中出现和父类中一模一样的方法(包括返回值类型，方法名，参数列表)
从重写的要求上看：
重写的方法和父类的要一致(包括返回值类型、方法名、参数列表)
方法重写只存在于子类和父类之间，同一个类中只能重载
从访问权限上看：
子类方法不能缩小父类方法的访问权限
子类方法不能抛出比父类方法更多的异常
父类的私有方法不能被子类重写
从静态和非静态上看：
父类的静态方法不能被子类重写为非静态方法
子类可以定义于父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法（满足重写约束）
父类的非静态方法不能被子类重写为静态方法
从抽象和非抽象来看：
父类的抽象方法可以被子类通过两种途径重写（即实现和重写）
父类的非抽象方法可以被重写为抽象方法

方法重载

方法名相同，但参数不一致（(参数个数或类型或顺序不一样）
方法重写和方法重载的区别：

在这里插入图片描述

修饰符

Java语言提供了很多修饰符，修饰符用来定义类、方法或者变量，通常放在语句的最前端。主要分为以下两类：
1、访问修饰符 2、非访问修饰符
这里访问修饰符主要讲解public，protected，default，private四种访问控制修饰符。
非访问修饰符这里就介绍static修饰符，final修饰符和abstract修饰符。
访问修饰符：
在这里插入图片描述
1、private：Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。
2、default：(也有称friendly)即不加任何访问修饰符，通常称为“默认访问权限“或者“包访问权限”。该模式下，只允许在同一个包中进行访问。
3、protected：介于public 和 private 之间的一种访问修饰符，一般称之为“保护访问权限”。被其修饰的属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
4、public：Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包访问。
Java 子类重写继承的方法时，不可以降低方法的访问权限，子类继承父类的访问修饰符作用域不能比父类小，也就是更加开放，假如父类是protected修饰的，其子类只能是protected或者public，绝对不能是default(默认的访问范围)或者private
非访问修饰符
static 修饰符
static 与变量，方法和类一起使用，称为静态变量，静态方法(也称为类变量、类方法)。如果在一个类中使用static修饰变量或者方法的话，它们可以直接通过类访问，不需要创建一个类的对象来访问成员
我们在设计类的时候可能会使用静态方法，有很多工具类比如Math，Arrays等类里面就写了很多静态方法。static修饰符的注意事项：
构造方法不允许声明为 static 的。
静态方法中不存在当前对象，因而不能使用 this，当然也不能使用 super。
静态方法不能被非静态方法重写(覆盖)
静态方法能被静态方法重写(覆盖)
final修饰符
final 类:不能被继承，没有类能够继承 final 类的任何特性
父类中的 final 方法:可以被子类继承，但是不能被子类重写。声明 final 方法的主要目的是防止该方法的内容被修改
final变量:一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值(即不能只声明)。final 修饰符通常和 static 修饰符一起使用来创建类常量
abstract 修饰符
抽象类：有抽象方法的类必须是抽象类，抽象类可以表达概念但是无法构造实体的类
抽象方法：有很多不同类的方法是相似的，但是具体内容又不太一样，所以我们只能抽取他的声明，没有具体的方法体，即抽象方法可以表达概念但无法具体实现
注意:
抽象类也是类，如果一个类继承于抽象类，就不能继承于其他的（类或抽象类）
子类可以继承于抽象类，但是一定要实现父类所有abstract的方法。如果不能完全实现，那么子类也必须被定义为抽象类
只有实现父类的所有抽象方法，才能是完整类

Object类和转型

Object(java.lang.Object)
Object是类层次结构的根类，所有的类都隐式的继承Object类,那么重写toString()、equals()、hashCode()、wait()、notify()、getClass()等
Java所有的对象都拥有Object默认方法
Object类的构造方法有一个，并且是无参构造
任何类都可以使用Object类的方法，创建的类也可和Object进行向上、向下转型
向上转型 : 通过子类对象(小范围)实例化父类对象(大范围)，这种属于自动转换
父类引用变量指向子类对象后，只能使用父类已声明的方法，但方法如果被重写会执行子类的方法，如果方法未被重写那么将执行父类的方法
在这里插入图片描述

向下转型 : 通过父类对象(大范围)实例化子类对象(小范围)，在书写上父类对象需要加括号()强制转换为子类类型，但父类引用变量实际引用必须是子类对象才能成功转型
子类引用变量指向父类引用变量指向的对象后(一个Son()对象)，就完成向下转型
在这里插入图片描述

Object object=new Integer(666);//向上转型
Integer i=(Integer)object;//向下转型Object->Integer，object的实质还是指向Integer
String str=(String)object;//错误的向下转型，虽然编译器不会报错但是运行会报错

子父类初始化顺序

静态>非静态，父类>子类，非构造函数>构造函数
静态变量也称类变量，可以看成一个全局变量，静态成员变量和静态代码块在类加载的时候就初始化，而非静态变量和代码块在对象创建的时候初始化。所以静态快于非静态初始化。
而在创建子类对象的时候需要先创建父类对象，所以父类优先于子类。
而在调用构造函数的时候，是对成员变量进行一些初始化操作，所以普通成员变量和代码块优于构造函数执行。
在Java继承中，父子类初始化先后顺序为：
父类中静态成员变量和静态代码块
子类中静态成员变量和静态代码块
父类中普通成员变量和代码块，父类的构造函数
子类中普通成员变量和代码块，子类的构造函数
静态代码块，构造代码块，构造函数执行的顺序
静态代码块优先执行只有一次
构造代码块每次构造对象就会执行
执行顺序：
静态代码块>构造代码块>构造函数执行

public class Test {
    static {
        System.out.println("静态代码块1");
    }

    {
        System.out.println("代码块");
    }

    public  Test(){
        System.out.println("构造函数");
    }

    public static void main(String[] args) {
        Test test = new Test();
    }
}
静态代码块1
代码块
构造函数

详解：
静态代码块：
它是随着类的加载而执行，只执行一次，并优先于主函数。具体说，静态代码块是由类调用的。类调用时，先执行静态代码块，然后才执行主函数的。
静态代码块其实就是给类初始化的，而构造代码块是给对象初始化的。
静态代码块中的变量是局部变量，与普通函数中的局部变量性质没有区别。
一个类中可以有多个静态代码块
构造代码块：
构造代码块的作用是给对象进行初始化。
对象一建立就运行构造代码块了，而且优先于构造函数执行。这里要强调一下，有对象建立，才会运行构造代码块，类不能调用构造代码块的，而且构造代码块与构造函数的执行顺序是前者先于后者执行。
构造函数
1.对象一建立，就会调用与之相应的构造函数，也就是说，不建立对象，构造函数时不会运行的。
2.构造函数的作用是用于给对象进行初始化。
3.一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次
构造代码块与构造函数的区别是：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，因为构造函数是可以多个的，运行哪个构造函数就会建立什么样的对象，但无论建立哪个对象，都会先执行相同的构造代码块。

public class Test {
    {
        System.out.println("构造代码块1");
    }
    {
        System.out.println("构造代码块2");
    }
    static {
        System.out.println("静态代码块1");
    }



    public  Test(){
        System.out.println("构造函数");
    }

    public static void main(String[] args) {
        Test test = new Test();
        Test test1 = new Test();
    }
}
静态代码块1
构造代码块1
构造代码块2
构造函数
构造代码块1
构造代码块2
构造函数