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

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

## 方法重载 ##

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70]

## 修饰符 ##

Java语言提供了很多修饰符，修饰符用来定义类、方法或者变量，通常放在语句的最前端。主要分为以下两类：  
**1、访问修饰符 2、非访问修饰符**  
这里访问修饰符主要讲解public，protected，default，private四种访问控制修饰符。  
非访问修饰符这里就介绍static修饰符，final修饰符和abstract修饰符。  
**访问修饰符：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 1]  
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进行向上、向下转型  
**向上转型** : 通过子类对象(小范围)实例化父类对象(大范围)，这种属于自动转换  
父类引用变量指向子类对象后，只能使用父类已声明的方法，但方法如果被重写会执行子类的方法，如果方法未被重写那么将执行父类的方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 2]

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

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
    构造函数

## 多态 ##

多态是同一个行为具有多个不同表现形式或形态的能力。即一个父类可能有若干子类，各子类实现父类方法有多种多样，调用父类方法时，父类引用变量指向不同子类实例而执行不同方法，这就是所谓父类方法是多态的

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70]: /images/20221120/f4ea2c2992b04b91a848e0894e5af7a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 1]: /images/20221120/50ea64942a704531a53a2df15bec83a1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 2]: /images/20221120/fe850030b1b948bdaba59a421152a5b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 3]: /images/20221120/2b4307eeebf140979e24f03fd20d63cc.png