面向对象总结

一、面向对象基础概念

1.面向对象与面向过程

        面向过程：将问题分解成具体步骤，按模块划分，以函数为中心，关注步骤；

        面向对象：将事物抽象成对象，封装数据与操作，以对象为中心，关注对象交互。

2.三大基本特性

        封装：两层含义，一是将事物的属性与方法封装成一个整体（对象），二是隐藏信息和保证数据安全（仅暴露必要接口）。

        继承：主要描述类与类之间的关系，通过代码复用，建立类之间的关系。

        多态：同一操作作用于不同类或对象产生不同行为。

二、类与对象

1.类的定义

[修饰符] class 类名 {
    // 成员变量(属性)
    // 构造方法
    // 成员方法
    // 代码块
    // 内部类
}

        修饰符：通常选用public，protected，缺省（默认），private进行修饰。

        class：定义类的关键字，不可省略！

        类名：合法的标识符，需符合见名知意原则，首字母大写，若以多个单词组成的类名的每个单词首字母均大写。

        花括号：包含类的主体内容。

2.对象的创建与使用

格式1：
类名 对象名称=null;
对象名称=new 类名();

格式2：
类名 对象名称=new 类名();

第一种格式：第1条语句定义对象变量，第2条语句实例化对象；

第二种格式：将第一种格式中的两条语句合成一条语句。

        null关键字代表引用类型初始值为空；

        使用new关键字实例化对象；

        对象存储在堆内存中；

        引用变量存储在栈内存中。

3.成员变量与局部变量

        作用域不同，初始值不同，存储位置不同。

三、方法详解

1.方法定义

[修饰符] 返回类型 方法名([参数列表]) [throws 异常列表] {
    // 方法体
}

2.方法重载

        定义：在一个Java类中，方法名相同，参数类型、参数个数或者参数顺序不同的多个方法，被称为方法的重载。

        满足条件：（1）在同一类中；（2）方法名相同；（3）参数列表不同（类型、个数、顺序）。【返回类型可相同可不同】

3.参数传递机制

        基本类型：值传递

        引用类型：引用值传递（引用类型包括类、接口、数组等）

四、封装

1.访问权限修饰符

        

权限修饰符	同一类中	同一包中的类	不同包的子类	不同包的所有类
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√

简单来说，private：仅本类可见；default：同包可见；protected：同包+子类可见；public：所有类可见。

2.封装实现

        对成员变量进行私有化（private），提供使用public的getter/setter方法，外部类可通过public修饰的方法进行访问。

public class Person {
//私有化成员变量
    private String name;
    private int age;
    private String gender;
//提供公共的getter/setter方法
    public String getName() {
        return name;
    }

    public void setName(String name){
        this.name=name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

}

        封装目的：将属性隐藏起来，确保代码的复用性与安全性。

五、构造方法

1.构造方法的特点

（1）构造方法名与类名相同；（2）无返回值类型；（3）参数列表个数为0个、1个或多个；（4）只能通过new关键字调用。

2.构造方法的种类

        无参构造方法（默认构造方法）：方法体为空，且如果没有显式定义，则编译器会自动添加，若定义了其他构造方法，则不会自动添加。

        有参构造方法：参数与类的属性相关，参数个数不能超过类的属性的个数。

3.说明

（1）若在构造方法名前添加了返回值类型，编译不会出错，但该方法会被当作普通方法使用，无构造方法功能；

（2）有参构造方法可以在实例化对象时直接给属性赋值，可以初始化数据；

（3）构造方法不能被子类继承。

4.构造方法重载

        可定义多个参数列表不同的构造方法。

5.this关键字

       在Java中， 如果出现类的属性和方法中的变量重名，根据同名变量就近原则，需要在方法中使用this关键字来区分类的属性和方法中的变量。

        使用this关键字访问本类中的成员变量和方法时，this关键字指代当前对象，可区分成员变量和局部变量，this关键字主要有以下三种使用方法：

        （1）访问本类中的属性；（2）调用本类中的成员方法；（3）调用本类中的构造方法【this（）】。

六、继承

1.extends关键字

class 父类名{...}
class 子类名 extends 父类名 {...}

2.特点

（1）类只能单继承（一个类只能有一个直接父类）；

（2）支持多层次继承（一个类可以是某个类的子类，也可以是另一个类的父类）；

（3）子类继承父类非私有成员（除构造方法外的全部非私有的属性和方法）。

3.方法重写（方法覆盖）

        要求：（1）子类重写父类的方法；（2）具有相同的方法名、返回值类型和参数列表；（3）访问权限不能更严格；（4）不能抛出更宽泛的异常。

public class Animal {
    protected String name;

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

    public void makeSound(){
        System.out.println("动物发出声音");
    }
}
public class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
//方法重写
    public void makeSound(){
        System.out.println(name);
        System.out.println("汪汪汪");
    }

    //测试
    public static void main(String[] args){
        Dog dog=new Dog("旺财");
        dog.makeSound();
    }
}

在这个实例中，子类Dog类对父类Animal中的makeSound方法进行了重写。

        注意：（1）父类中的成员方法只能被它的子类重写；（2）父类中声明为final的方法不能被重写；（3）父类中声明为static的方法不能被重写，能被再次声明；（4）构造方法不能被重写。

4.super关键字

        super指代父类对象，可访问父类成员

super.属性名;
super.方法名（[实参列表]);

        可调用父类构造方法

super([实参列表]);

       使用super关键字调用父类构造方法需注意以下两点：

（1）super关键字必须放在子类构造方法体的首行；

（2）super关键字不可以在多个构造方法之间互相调用。

5.Object类

        Object类是包java.lang下的核心类，是所有类的父类，所有类都默认继承了Object类。

        重要方法：equals(),hashCode(),toString(),getClass(),clone(),finalize()...

七、多态

1.分类

        多态分为静态多态和动态多态。静态多态（编译时多态）：方法的重载，在编译时体现多态，在运行时未体现出多态；动态多态是通过动态绑定来实现的，也就是常说的多态性。

2.实现条件

        动态多态需要满足继承关系、方法重载和向上转型（父类引用指向子类对象）3个必要条件。

3.引用类型转换

        向上转型（自动）：子类→父类

        向下转型（强制）：父类→子类，需使用instanceof检查

八、抽象类和接口

1.抽象类

        抽象方法定义的一般格式：

权限修饰符 abstract 返回值类型 方法名（[参数]）;

        抽象类定义的一般格式：

abstract class Animal {
    abstract void makeSound();
    void sleep() { /* 具体实现 */ }
}

        使用抽象类和抽象方法的注意事项：

（1）必须使用abstract关键字修饰；(2)抽象类不能直接实例化对象，只能通过继承使用；（3)抽象类中可以有一个或多个抽象方法；（4）抽象方法所在类必须为抽象类；（5）抽象方法只有方法头，没有方法体；（6）继承抽象类的子类，需要实现抽象类中的所有抽象方法。

2.接口

        一个类可以实现多个接口

        接口定义格式：

[权限修饰符] interface 接口名[extends 其他接口名]{
    [public static final]数据类型 常量名=常量值;
    public default 返回值类型 方法名([参数列表]){
        
        //方法体

    }
    [public abstract] 返回值类型 方法名 ([参数列表]);

}

        实现接口的一般格式：

[修饰符] class 类名 implements 接口1，接口2...接口n{
    ...
}

3.抽象类VS接口

（1）抽象类单继承，接口多实现；（2）抽象类可以有普通方法，接口只能有抽象方法和default关键字修饰的非抽象方法；（3）成员变量不同，构造方法不同。

九、static和final

1.static关键字

        静态变量：类所有实例共享

        静态方法：只能访问静态成员

        静态代码块：类加载时执行一次，通常用于初始化数据

2.final关键字

        final变量：常量，不可修改

        final方法：不可重写

        final类：不可继承

十、内部类

        内部类是在一个类内部定义的类，其所在的类被成为外部类。

        内部类具有以下特性：（1）内部类属于独立类，编译后生成独立字节码文件，但内部类字节码文件前会冠以外部类的类名和符号$；（2）内部类是外部内的成员，可访问外部类的成员变量；（3）内部类因位置、修饰符和定义方式不同又分为4类。

1.成员内部类（内部类所在位置与类的成员同级）

例：

public class Outter{
    class Inner{
    }
}

        普通内部类：持有外部类引用

        静态内部类：不持有外部类引用

2.静态内部类

        使用static关键字修饰的成员内部类，只能访问外部类中的静态成员。

格式如下：

外部类名.静态内部类名 静态内部类对象名=new 外部类名.静态内部类名();

3.局部内部类（方法内部类）

        定义在方法或作用域内。

4.匿名内部类

        没有类名，直接实例化，这种类只被使用一次，通过调用匿名内部类所在的外部类的成员方法来创建。

例：

new 类名/接口名(){
    //匿名内部类实现代码
    
    }

十一、异常处理

1.异常分类

        Throwable:

                Error:系统错误

                Exception:可处理异常（运行时异常与非运行时异常[检查异常]）

2.异常处理

        捕获：try-catch-finally

        抛出：throws声明  throw抛出