面向对象

面向对象

　　万物皆对象。所有的事物都有属性（是什么）和方法（能做什么），以对象为中心，使用对象的关系来描述事物之间的联系，把解决的问题按照一定规则划分为多个对象，然后通过调用对象的方法来解决问题。——面向对象思想

类和对象

面向对象的三大特征是封装、继承、多态。

类

类是对象的抽象，用于描述一组对象的共同特征和行为。
类中可定义：
- 成员变量（属性）
- 成员方法（方法）

成员变量和局部变量的区别：
1.
成员变量定义在类中，整个类中都可以访问。
局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。
2.
成员变量存在于堆内存的对象中。
局部变量存在于栈内存的方法中。
3.
成员变量随着对象的创建而存在，随着对象的消失而消失。
局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。
4.
成员变量都有默认初始化值。
局部变量没有默认初始化值。

对象

具体的一个实例。

类名 对象名称 = new 类名();//对象引用在栈内存，对象内容在堆内存

构造函数

定义同时满足以下条件（特点）：
1. 函数名与类名相同
2. 不用定义返回值类型
3. 不可以写return语句
作用： 给对象进行初始化。
注意：
1. 默认构造函数的特点。
2. 多个构造函数是以重载的形式存在的。

封装

封装：是指隐藏对象的属性和实现细节，仅对外提供 公共访问方式。用private表示此成员属性为该类的私有属性。

private关键字：

• 是一个权限修饰符。
• 用于修饰成员(成员变量和成员函数)。
• 被私有化的成员只在本类中有效。

JavaBean:

JavaBean是一个遵循特定写法的Java类。

它通常具有如下特点：
1.这个Java类必须具有一个无参的构造函数。
2.字段必须私有化。
3.私有化的字段必须通过public类型的方法（getXxx()方法和setXxx()方法）暴露给其它程序。

访问权限修饰符：

Public ：表示所有的地方均可见。
Protected：同包可见+不同包的子类可见。
default ：表示默认，不仅本类访问，而且是同包可见。
private ：本类访问。

继承（extends）

描述事物之间的所属关系，如蓝色继承自颜色，蓝色是颜色的一种。（A继承自B，A是B的一种）

特点：
- Java只支持单继承，不支持多继承。（注：Object是所有类的父类以及接口可多继承接口）
- Java支持多层继承(继承体系)。

this与super

this关键字：本类对象的引言。
super关键字：父类引用。

　　在子类的构造函数中第一行有一个默认的隐式语句super()。如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用父类中哪个构造函数，supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。

方法的重写　　

• 子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为覆盖或者复写。
• 父类中的私有方法不可以被重写。
• 在子类重写方法中，继续使用被重写的方法可以通过[super.函数名]获取。
• 重写时，子类方法权限一定要大于等于父类方法权限。
• 静态只能重写静态。

多态

就是一个对象对应着不同类型，父类或者接口的引用指向其子类的对象。前提必须有关系（继承-方法重写，接口、抽象类-方法实现）。

编译时多态和运行时多态

编译时多态：编译时动态重载，也就是方法重载。
运行时多态：一个对象具有多个类型，可通过继承和接口的方式实现。
针对引用调用的方法：

class Fu{
    static String staticAtt = "父类静态成员属性";
    String Att = "父类成员属性";
    public static void staticFunction(){
        System.out.println("父类静态成员方法");
    }
    public void function(){
        System.out.println("父类成员方法");
    }
}

class Zi extends Fu{
    static String staticAtt = "子类静态成员属性";
    String Att = "子类成员属性";
    public static void staticFunction(){
        System.out.println("子类静态成员方法");
    }
    public void function(){
        System.out.println("子类成员方法");
    }
}

public class Polymorphism {
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.staticAtt);//输出：父类静态成员属性
        System.out.println(f.Att);      //输出：父类成员属性
        f.staticFunction();             //输出：父类静态成员方法
        f.function();                   //输出：子类成员方法(成员函数被重写)
    }

}

总结：f是Fu类的引用，静态随着类加载到堆内存时已执行，而普通成员方法被重写覆盖。

代码块、成员属性、构造方法运行顺序（含静态与继承）

class Fu{
    static{
        System.out.println("父类静态代码块");
    }
    {
        System.out.println("父类代码块");
    }
    private static String staticAtt = getStaticAtt();
    private String Att = getAtt();
    public Fu(){
        System.out.println("父类构造方法");
    }
    private String getAtt() {
        System.out.println("父类成员属性");
        return null;
    }
    private static String getStaticAtt() {
        System.out.println("父类静态成员属性");
        return null;
    }

}

class Zi extends Fu{
    static{
        System.out.println("子类静态代码块");
    }
    {
        System.out.println("子类代码块");
    }
    private static String staticAtt = getStaticAtt();
    private String Att = getAtt();
    public Zi(){
        System.out.println("子类构造方法");
    }
    private String getAtt() {
        System.out.println("子类成员属性");
        return null;
    }
    private static String getStaticAtt() {
        System.out.println("子类静态成员属性");
        return null;
    }
}

public class JavaSequence {
    public static void main(String[] args) {    
        Zi z = new Zi();;
    }
}

输出：
父类静态代码块
父类静态成员属性
子类静态代码块
子类静态成员属性
父类代码块
父类成员属性
父类构造方法
子类代码块
子类成员属性
子类构造方法

总结：执行顺序：代码块->成员属性->构造方法（如有父类先执行完父类，如有静态先执行完静态）。

抽象类和接口

抽象类（abstract）

Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

特点：
- 抽象类和抽象方法必须用abstract关键字来修饰。
- 抽象方法只有方法声明，没有方法体，定义在抽象类中。[格式：修饰符 abstract 返回值类型 函数名(参数列表) ; ]
- 抽象类不可以被实例化，也就是不可以用new创建对象。
- 抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象，方法后才可以创建对象，否则该子类也是抽象类。
- 含抽象方法一定是抽象类，抽象类可以没有抽象方法。

接口(interface)

如果一个抽象类中所有方法都是抽象的，则这个类可以定义为接口。

接口中的成员修饰符是固定的。
•成员常量：public static final
•成员方法：public abstract

特点：
- 接口中的方法都是抽象的，不能实例化对象。
- 当一个类实现接口时，如果这个类是抽象类，则可实现部分方法，否则需实现全部方法。
- 可多实现，即实现多接口，同逗号隔开。
- 接口可继承多个接口。
- 一个类同时继承一个类和实现一个接口时，extends关键字位于implements关键字之前。

异常

是在运行时期发生的不正常情况。（Error类称为错误类，Exception类称为异常类）

解决方式

try···catch和finally：捕获异常并处理。
throws：抛出异常，但下次调用时仍需处理。

throws 和throw的区别：

1.throws使用在函数上。throw使用在函数内。
2.throws抛出的是异常类，可以抛出多个，用逗号隔开。throw抛出的是异常对象。

运行时异常和编译时异常

运行时异常：RuntimeException类及其子类都是运行时异常，编译器不对其进行检查。
编译时异常：Exception类中除了RuntimeException类及其子类都是编译时异常，编译器会对其进行检查，需处理。

自定义异常

自定义异常类继承自Exception或其子类，使用时用throw抛出其自定义异常的实例对象。